Revert "update content when changing variation"

This reverts commit b487436d93.

.gitignore

@@ -1,141 +1,134 @@
-*.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
+*.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

README.md

@@ -13,11 +13,11 @@ 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 350,000 sites trust Umbraco** 
+**More than 177,000 sites trust Umbraco** 
 
 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 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.  
+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.  
 
 To view more examples, please visit [http://umbraco.com/why-umbraco/#caseStudies](http://umbraco.com/why-umbraco/#caseStudies)
 

apidocs/docfx.filter.yml

@@ -1,18 +0,0 @@
-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

@@ -1,75 +0,0 @@
-{
-  "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

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

apidocs/toc.yml

@@ -1,5 +0,0 @@
-
-- 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

@@ -1,257 +0,0 @@
-{{!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

@@ -1,13 +0,0 @@
-{{!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

@@ -1,18 +0,0 @@
-{{!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

@@ -1,18 +0,0 @@
-{{!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

@@ -1,22 +0,0 @@
-{{!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

@@ -1,101 +0,0 @@
-{{!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

@@ -1,73 +0,0 @@
-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

@@ -1,51 +0,0 @@
-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

@@ -0,0 +1,170 @@
+/* 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

@@ -0,0 +1,172 @@
+<?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/BuildBelle.bat

@@ -23,7 +23,6 @@ ECHO Change directory to %CD%\..\src\Umbraco.Web.UI.Client\
 CD %CD%\..\src\Umbraco.Web.UI.Client\
 
 ECHO Do npm install and the grunt build of Belle
-call npm cache clean --quiet
 call npm install --quiet
 call npm install -g grunt-cli --quiet
 call npm install -g bower --quiet

build/BuildDocs.bat

@@ -1,20 +0,0 @@
-@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,100 +1,27 @@
-$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"
+##We cannot continue if sandcastle is not installed determined by env variable: SHFBROOT
 
-
-################ 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"
-}
-
-"Installing node"
-# Check if Install-Product exists, should only exist on the build server
-if (Get-Command Install-Product -errorAction SilentlyContinue)
+if (-not (Test-Path Env:\SHFBROOT))
 {
-    Install-Product node ''
+	throw "The docs cannot be build, install Sandcastle help file builder"
 }
 
-"Installing node modules"
-& npm install
+$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 grunt"
-& npm install -g grunt-cli
+"Building docs with project file:  $ProjFile"
 
-"Moving back to build folder"
-cd ..
-cd ..
-cd build
-Write-Host $(Get-Location)
+$MSBuild = "$Env:SYSTEMROOT\Microsoft.NET\Framework\v4.0.30319\msbuild.exe"
 
- & grunt --gruntfile ../src/umbraco.web.ui.client/gruntfile.js docs
+# build it!
+& $MSBuild "$ProjFile"
 
-# 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
+# remove files left over
+Remove-Item $BuildRoot\* -include csharp-api-docs.shfbproj_*
 
-& $7Zip a -tzip ui-docs.zip $NgDocsSiteOutput -r
+# copy our custom styles in
+Copy-Item $BuildRoot\ApiDocs\TOC.css $OutputPath\TOC.css
 
-################ 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
+""
+"Done!"

build/NuSpecs/UmbracoCms.Core.nuspec

@@ -31,7 +31,7 @@
       <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, 9.0.0)" />
-      <dependency id="Examine" version="[0.1.69-beta, 1.0.0)" />
+      <dependency id="Examine" version="[0.1.68, 1.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)" />
@@ -72,6 +72,7 @@
     <file src="..\_BuildOutput\WebApp\bin\UmbracoExamine.dll" target="lib\UmbracoExamine.dll" />
     <file src="..\_BuildOutput\WebApp\bin\UmbracoExamine.xml" target="lib\UmbracoExamine.xml" />
     <file src="tools\install.core.ps1" target="tools\install.ps1" />
+    <file src="tools\uninstall.core.ps1" target="tools\uninstall.ps1" />
 
     <!-- Added to be able to produce a symbols package -->
     <file src="..\_BuildOutput\bin\SQLCE4Umbraco.pdb" target="lib" />

build/NuSpecs/UmbracoCms.nuspec

@@ -17,7 +17,7 @@
     <dependencies>
       <dependency id="UmbracoCms.Core" version="[$version$]" />
       <dependency id="Newtonsoft.Json" version="[6.0.8, 9.0.0)" />
-      <dependency id="Umbraco.ModelsBuilder" version="[3.0.2, 4.0.0)" />
+      <dependency id="Umbraco.ModelsBuilder" version="[3.0.0, 4.0.0)" />
     </dependencies>
   </metadata>
   <files>
@@ -33,6 +33,7 @@
     <file src="..\_BuildOutput\WebApp\umbraco\**" target="UmbracoFiles\umbraco" />
     <file src="..\_BuildOutput\WebApp\umbraco_client\**" target="UmbracoFiles\umbraco_client" />
     <file src="tools\install.ps1" target="tools\install.ps1" />
+    <file src="tools\uninstall.ps1" target="tools\uninstall.ps1" />
     <file src="tools\Readme.txt" target="tools\Readme.txt" />
     <file src="tools\ReadmeUpgrade.txt" target="tools\ReadmeUpgrade.txt" />
     <file src="tools\Web.config.install.xdt" target="Content\Web.config.install.xdt" />

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

@@ -21,8 +21,6 @@
   <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">

build/NuSpecs/tools/install.ps1

@@ -77,28 +77,8 @@ if ($project) {
 	{
 		$packageWebConfigSource = Join-Path $installPath "UmbracoFiles\Web.config"
 		Copy-Item $packageWebConfigSource $destinationWebConfig -Force
-
-		# 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/NuSpecs/tools/uninstall.core.ps1

@@ -0,0 +1,48 @@
+param($installPath, $toolsPath, $package, $project)
+
+Write-Host "installPath:" "${installPath}"
+Write-Host "toolsPath:" "${toolsPath}"
+
+Write-Host " "
+
+if ($project) {
+	
+	# 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"
+	Write-Host "backupPath:" "${backupPath}"
+	$umbracoBinFolder = Join-Path $projectPath "bin"
+	Write-Host "umbracoBinFolder:" "${umbracoBinFolder}"
+
+	# Remove backups
+	Write-Host "removing backups:" "${backupPath}"
+	if(Test-Path $backupPath) { Remove-Item -Recurse -Force $backupPath -Confirm:$false }
+	
+	# Delete files Umbraco ships with	
+
+	Write-Host "removing dlls:" "${umbracoBinFolder}"
+	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 }
+	if(Test-Path $umbracoBinFolder\interfaces.dll) { Remove-Item $umbracoBinFolder\interfaces.dll -Force -Confirm:$false }
+	if(Test-Path $umbracoBinFolder\log4net.dll) { Remove-Item $umbracoBinFolder\log4net.dll -Force -Confirm:$false }
+	if(Test-Path $umbracoBinFolder\Microsoft.ApplicationBlocks.Data.dll) { Remove-Item $umbracoBinFolder\Microsoft.ApplicationBlocks.Data.dll -Force -Confirm:$false }
+	if(Test-Path $umbracoBinFolder\SQLCE4Umbraco.dll) { Remove-Item $umbracoBinFolder\SQLCE4Umbraco.dll -Force -Confirm:$false }
+	if(Test-Path $umbracoBinFolder\System.Data.SqlServerCe.dll) { Remove-Item $umbracoBinFolder\System.Data.SqlServerCe.dll -Force -Confirm:$false }
+	if(Test-Path $umbracoBinFolder\System.Data.SqlServerCe.Entity.dll) { Remove-Item $umbracoBinFolder\System.Data.SqlServerCe.Entity.dll -Force -Confirm:$false }
+	if(Test-Path $umbracoBinFolder\TidyNet.dll) { Remove-Item $umbracoBinFolder\TidyNet.dll -Force -Confirm:$false }
+	if(Test-Path $umbracoBinFolder\umbraco.dll) { Remove-Item $umbracoBinFolder\umbraco.dll -Force -Confirm:$false }
+	if(Test-Path $umbracoBinFolder\Umbraco.Core.dll) { Remove-Item $umbracoBinFolder\Umbraco.Core.dll -Force -Confirm:$false }
+	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.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 }
+		
+	$amd64Folder = Join-Path $umbracoBinFolder "amd64"
+	if(Test-Path $amd64Folder) { Remove-Item $amd64Folder -Force -Recurse -Confirm:$false }
+	$x86Folder = Join-Path $umbracoBinFolder "x86"
+	if(Test-Path $x86Folder) { Remove-Item $x86Folder -Force -Recurse -Confirm:$false }		
+}

build/NuSpecs/tools/uninstall.ps1

@@ -0,0 +1,39 @@
+param($installPath, $toolsPath, $package, $project)
+
+Write-Host "installPath:" "${installPath}"
+Write-Host "toolsPath:" "${toolsPath}"
+
+Write-Host " "
+
+if ($project) {
+	
+	# 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"
+	Write-Host "backupPath:" "${backupPath}"
+	$appBrowsers = Join-Path $projectPath "App_Browsers"
+	Write-Host "appBrowsers:" "${appBrowsers}"
+	$appData = Join-Path $projectPath "App_Data"
+	Write-Host "appData:" "${appData}"
+	
+	# Remove backups
+	Write-Host "removing backups:" "${backupPath}"
+	if(Test-Path $backupPath) { Remove-Item -Recurse -Force $backupPath -Confirm:$false }	
+
+	# Remove app_data files
+	Write-Host "removing app_data files:" "${appData}"
+	if(Test-Path $appData\packages) { Remove-Item $appData\packages -Recurse -Force -Confirm:$false }
+
+	Write-Host "removing app_browsers:" "${appBrowsers}"
+	if(Test-Path $appBrowsers\Form.browser) { Remove-Item $appBrowsers\Form.browser -Force -Confirm:$false }
+	if(Test-Path $appBrowsers\w3cvalidator.browser) { Remove-Item $appBrowsers\w3cvalidator.browser -Force -Confirm:$false }
+
+	# Remove umbraco and umbraco_files	
+	$umbracoFolder = Join-Path $projectPath "Umbraco"	
+	Write-Host "removing umbraco folder:" "${umbracoFolder}"
+	if(Test-Path $umbracoFolder) { Remove-Item $umbracoFolder -Recurse -Force -Confirm:$false }
+	$umbracoClientFolder = Join-Path $projectPath "Umbraco_Client"	
+	Write-Host "removing umbraco client folder:" "${umbracoClientFolder}"
+	if(Test-Path $umbracoClientFolder) { Remove-Item $umbracoClientFolder -Recurse -Force -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.5.0
-beta
+7.4.1

src/SolutionInfo.cs

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

src/Umbraco.Core/Cache/ICacheProvider.cs

@@ -4,7 +4,7 @@ using System.Collections.Generic;
 namespace Umbraco.Core.Cache
 {
     /// <summary>
-    /// An interface for implementing a basic cache provider
+    /// An abstract class 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/Configuration/UmbracoSettings/ISecuritySection.cs

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

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

@@ -28,18 +28,6 @@ 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
         {
@@ -74,11 +62,6 @@ 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.5.0");
+        private static readonly Version Version = new Version("7.4.1");
 
         /// <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 "beta"; } }
+        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

src/Umbraco.Core/Constants-Applications.cs

@@ -73,11 +73,6 @@
             /// </summary>
 			public const string DataTypes = "dataTypes";
 
-            /// <summary>
-            /// alias for the packages tree
-            /// </summary>
-            public const string Packages = "packager";
-
 			/// <summary>
 			/// alias for the dictionary tree.
 			/// </summary>

src/Umbraco.Core/Constants-ObjectTypes.cs

@@ -143,10 +143,7 @@ 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,15 +419,6 @@ 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/Dynamics/ExtensionMethodFinder.cs

@@ -5,10 +5,8 @@ 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
 {
@@ -22,20 +20,6 @@ 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>
@@ -52,7 +36,7 @@ namespace Umbraco.Core.Dynamics
                 // assemblies that contain extension methods
                 .Where(a => a.IsDefined(typeof (ExtensionAttribute), false))
                 // types that contain extension methods
-                .SelectMany(a => GetTypes(a)
+                .SelectMany(a => a.GetTypes()
                     .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)
@@ -61,9 +45,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);
@@ -73,7 +57,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>
@@ -94,7 +78,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
@@ -118,7 +102,7 @@ namespace Umbraco.Core.Dynamics
 
 		        return filtr3.ToArray();
 		    });
-
+		    
         }
 
         private static MethodInfo DetermineMethodFromParams(IEnumerable<MethodInfo> methods, Type genericType, IEnumerable<object> args)
@@ -139,12 +123,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());
@@ -175,7 +159,7 @@ namespace Umbraco.Core.Dynamics
                 .ToArray();
 
             var methods = GetAllExtensionMethods(runtimeCache, thisType, name, args.Length).ToArray();
-
+            
             return DetermineMethodFromParams(methods, genericType, args);
         }
     }

src/Umbraco.Core/Events/MigrationEventArgs.cs

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

@@ -69,16 +69,7 @@ namespace Umbraco.Core.IO
             }
         }
 
-        public static string AppCode
-        {
-            get
-            {
-                //NOTE: this is not configurable and shouldn't need to be
-                return "~/App_Code";
-            }
-        }
-
-        public static string AppPlugins
+		public static string AppPlugins
 		{
 			get
 			{

src/Umbraco.Core/Models/Content.cs

@@ -1,7 +1,6 @@
 using System;
 using System.Collections;
 using System.Collections.Generic;
-using System.ComponentModel;
 using System.Linq;
 using System.Reflection;
 using System.Runtime.Serialization;
@@ -156,7 +155,6 @@ 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/ContentTypeBase.cs

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

src/Umbraco.Core/Models/DataTypeDatabaseType.cs

@@ -6,6 +6,10 @@ 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/IContent.cs

@@ -1,5 +1,4 @@
 using System;
-using System.ComponentModel;
 using System.Diagnostics;
 using Umbraco.Core.Persistence.Mappers;
 
@@ -22,7 +21,6 @@ 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,12 +7,6 @@ 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/IRedirectUrl.cs

@@ -1,18 +0,0 @@
-using System;
-using System.Runtime.Serialization;
-using Umbraco.Core.Models.EntityBase;
-
-namespace Umbraco.Core.Models
-{
-    public interface IRedirectUrl : IAggregateRoot, IRememberBeingDirty
-    {
-        [DataMember]
-        int ContentId { get; set; }
-
-        [DataMember]
-        DateTime CreateDateUtc { get; set; }
-
-        [DataMember]
-        string Url { get; set; }
-    }
-}

src/Umbraco.Core/Models/MediaType.cs

@@ -38,30 +38,5 @@ 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,54 +124,10 @@ namespace Umbraco.Core.Models
                 bool typeValidation = _propertyType.IsPropertyTypeValid(value);
 
                 if (typeValidation == false)
-                {
-                    // 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));
-                    }
-                }
+                    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,6 +1,5 @@
 using System;
 using System.Diagnostics;
-using System.Linq;
 using System.Reflection;
 using System.Runtime.Serialization;
 using System.Text.RegularExpressions;
@@ -222,9 +221,8 @@ namespace Umbraco.Core.Models
         }
 
         /// <summary>
-        /// Gets or sets the identifier of the PropertyGroup this PropertyType belongs to.
+        /// Gets or Sets the PropertyGroup's Id for which this PropertyType belongs
         /// </summary>
-        /// <remarks>For generic properties, the value is <c>null</c>.</remarks>
         [DataMember]
         internal Lazy<int> PropertyGroupId
         {
@@ -426,19 +424,6 @@ 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

@@ -114,25 +114,10 @@ namespace Umbraco.Core.Models.PublishedContent
         internal static void ClearContentType(int id)
         {
             Logging.LogHelper.Debug<PublishedContentType>("Clear content type w/id {0}.", () => id);
-
-            // 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
+            // requires a predicate because the key does not contain the ID
+            // faster than key strings comparisons anyway
             ApplicationContext.Current.ApplicationCache.StaticCache.ClearCacheObjectTypes<PublishedContentType>(
-                (key, value) => ids.Contains(value.Id));
+                (key, value) => value.Id == id);
         }
 
         internal static void ClearDataType(int id)

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

@@ -1,5 +1,4 @@
-using System;
-using Umbraco.Core.Persistence;
+using Umbraco.Core.Persistence;
 
 namespace Umbraco.Core.Models.Rdbms
 {
@@ -19,8 +18,5 @@ 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,8 +51,5 @@ namespace Umbraco.Core.Models.Rdbms
 
         [Column("dbType")]
         public string DbType { get; set; }
-
-        [Column("UniqueID")]        
-        public Guid UniqueId { get; set; }
     }
 }

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

@@ -1,35 +0,0 @@
-using System;
-using Umbraco.Core.Persistence;
-using Umbraco.Core.Persistence.DatabaseAnnotations;
-
-namespace Umbraco.Core.Models.Rdbms
-{
-    [TableName("umbracoRedirectUrl")]
-    [PrimaryKey("id")]
-    [ExplicitColumns]
-    class RedirectUrlDto
-    {
-        public RedirectUrlDto()
-        {
-            CreateDateUtc = DateTime.UtcNow;
-        }
-
-        [Column("id")]
-        [PrimaryKeyColumn(IdentitySeed = 1, Name = "PK_umbracoRedirectUrl")]
-        public int Id { get; set; }
-
-        [Column("contentId")]
-        [NullSetting(NullSetting = NullSettings.NotNull)]
-        [ForeignKey(typeof(NodeDto), Column = "id")]
-        public int ContentId { get; set; }
-
-        [Column("createDateUtc")]
-        [NullSetting(NullSetting = NullSettings.NotNull)]
-        public DateTime CreateDateUtc { get; set; }
-
-        [Column("url")]
-        [NullSetting(NullSetting = NullSettings.NotNull)]
-        [Index(IndexTypes.UniqueNonClustered, Name = "IX_umbracoRedirectUrl", ForColumns = "url, createDateUtc")]
-        public string Url { get; set; }
-    }
-}

src/Umbraco.Core/Models/RedirectUrl.cs

@@ -1,61 +0,0 @@
-using System;
-using System.Reflection;
-using System.Runtime.Serialization;
-using Umbraco.Core.Models.EntityBase;
-
-namespace Umbraco.Core.Models
-{
-    [Serializable]
-    [DataContract(IsReference = true)]
-    public class RedirectUrl : Entity, IRedirectUrl
-    {
-        public RedirectUrl()
-        {
-            CreateDateUtc = DateTime.UtcNow;
-        }
-
-        private static readonly PropertyInfo ContentIdSelector = ExpressionHelper.GetPropertyInfo<RedirectUrl, int>(x => x.ContentId);
-        private static readonly PropertyInfo CreateDateUtcSelector = ExpressionHelper.GetPropertyInfo<RedirectUrl, DateTime>(x => x.CreateDateUtc);
-        private static readonly PropertyInfo UrlSelector = ExpressionHelper.GetPropertyInfo<RedirectUrl, string>(x => x.Url);
-
-        private int _contentId;
-        private DateTime _createDateUtc;
-        private string _url;
-
-        public int ContentId
-        {
-            get { return _contentId; }
-            set
-            {
-                SetPropertyValueAndDetectChanges(o =>
-                {
-                    return _contentId = value;
-                }, _contentId, ContentIdSelector);
-            }
-        }
-
-        public DateTime CreateDateUtc
-        {
-            get {  return _createDateUtc; }
-            set
-            {
-                SetPropertyValueAndDetectChanges(o =>
-                {
-                    return _createDateUtc = value;
-                }, _createDateUtc, CreateDateUtcSelector);
-            }
-        }
-
-        public string Url
-        {
-            get { return _url; }
-            set
-            {
-                SetPropertyValueAndDetectChanges(o =>
-                {
-                    return _url = value;
-                }, _url, UrlSelector);
-            }
-        }
-    }
-}

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

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

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

@@ -134,16 +134,13 @@ 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()
@@ -240,8 +237,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/Initial/DatabaseSchemaCreation.cs

@@ -80,12 +80,11 @@ namespace Umbraco.Core.Persistence.Migrations.Initial
                                                                               {40, typeof (ServerRegistrationDto)},
                                                                               {41, typeof (AccessDto)},
                                                                               {42, typeof (AccessRuleDto)},
-                                                                              {43, typeof (CacheInstructionDto)},
+                                                                              {43, typeof(CacheInstructionDto)},
                                                                               {44, typeof (ExternalLoginDto)},
                                                                               {45, typeof (MigrationDto)},
                                                                               {46, typeof (UmbracoDeployChecksumDto)},
-                                                                              {47, typeof (UmbracoDeployDependencyDto)},
-                                                                              {48, typeof (RedirectUrlDto) }
+                                                                              {47, typeof (UmbracoDeployDependencyDto)}
                                                                           };
         #endregion
         

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

@@ -1,6 +1,5 @@
 using System;
 using System.Collections.Generic;
-using System.ComponentModel;
 using System.IO;
 using System.Linq;
 using System.Text;
@@ -28,21 +27,18 @@ 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)
         {
@@ -96,7 +92,7 @@ namespace Umbraco.Core.Persistence.Migrations
                                  : OrderedDowngradeMigrations(foundMigrations).ToList();
 
             
-            if (Migrating.IsRaisedEventCancelled(new MigrationEventArgs(migrations, _currentVersion, _targetVersion, _productName, true), this))
+            if (Migrating.IsRaisedEventCancelled(new MigrationEventArgs(migrations, _currentVersion, _targetVersion, true), this))
             {
                 _logger.Warn<MigrationRunner>("Migration was cancelled by an event");
                 return false;
@@ -125,7 +121,7 @@ namespace Umbraco.Core.Persistence.Migrations
                 throw;
             }
 
-            Migrated.RaiseEvent(new MigrationEventArgs(migrations, migrationContext, _currentVersion, _targetVersion, _productName, false), this);
+            Migrated.RaiseEvent(new MigrationEventArgs(migrations, migrationContext, _currentVersion, _targetVersion, false), this);
 
             return true;
         }

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

@@ -1,32 +0,0 @@
-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,19 +32,17 @@ namespace Umbraco.Core.Persistence.Migrations.Upgrades.TargetVersionSeven
         {
             if (database != null)
             {
-                var dtSql = new Sql().Select("nodeId")
-                    .From<DataTypeDto>(SqlSyntax)
-                    .Where<DataTypeDto>(dto => dto.PropertyEditorAlias == Constants.PropertyEditors.RelatedLinksAlias);
-
+                var dtSql = new Sql().Select("nodeId").From<DataTypeDto>().Where<DataTypeDto>(dto => dto.PropertyEditorAlias == Constants.PropertyEditors.RelatedLinksAlias);
                 var dataTypeIds = database.Fetch<int>(dtSql);
-                if (dataTypeIds.Any() == false) return string.Empty;
 
-                // need to use dynamic, as PropertyDataDto has new properties (eg decimal...) in further versions that don't exist yet
+                if (!dataTypeIds.Any()) return string.Empty;
+
+                // need to use dynamic, as PropertyDataDto has new properties
                 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;
+                        + " 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 => (int) x.contentNodeId).Distinct().ToArray();
+                var nodesIdsWithProperty = propertyData.Select(x => x.NodeId).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
@@ -56,32 +54,32 @@ namespace Umbraco.Core.Persistence.Migrations.Upgrades.TargetVersionSeven
                     cmsContentXmlEntries.AddRange(database.Fetch<ContentXmlDto>("WHERE nodeId in (@nodeIds)", new { nodeIds = batch }));
                 }
 
-                var propertyTypeIds = propertyData.Select(x => (int) x.propertytypeid).Distinct();
+                var propertyTypeIds = propertyData.Select(x => 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.dataNtext) == false)
+                    if (string.IsNullOrEmpty(data.Text) == false)
                     {
                         XmlDocument xml;
                         //fetch the current data (that's in xml format)
                         try
                         {
                             xml = new XmlDocument();
-                            xml.LoadXml(data.dataNtext);
+                            xml.LoadXml(data.Text);
                         }
                         catch (Exception 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 +
+                            int dataNodeId = data.nodeId;
+                            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.dataNtext = "";
+                            data.dataNText = "";
                             database.Update("cmsPropertyData", "id", data, new[] { "dataNText" });
 
                             UpdateXmlTable(propertyTypes, data, cmsContentXmlEntries, database);
@@ -115,7 +113,7 @@ namespace Umbraco.Core.Persistence.Migrations.Upgrades.TargetVersionSeven
                         }
 
                         //store the serialized data
-                        data.dataNtext = JsonConvert.SerializeObject(links);
+                        data.dataNText = JsonConvert.SerializeObject(links);
 
                         database.Update("cmsPropertyData", "id", data, new[] { "dataNText" });
 
@@ -132,20 +130,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, dynamic data, List<ContentXmlDto> cmsContentXmlEntries, Database database)
+        private static void UpdateXmlTable(List<PropertyTypeDto> propertyTypes, PropertyDataDto 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.contentNodeId);
+                var xmlItem = cmsContentXmlEntries.SingleOrDefault(x => x.NodeId == data.NodeId);
                 if (xmlItem != null)
                 {
                     var x = XElement.Parse(xmlItem.Xml);
                     var prop = x.Element(propertyType.Alias);
                     if (prop != null)
                     {
-                        prop.ReplaceAll(new XCData(data.dataNtext));
+                        prop.ReplaceAll(new XCData(data.Text));
                         database.Update(xmlItem);
                     }
                 }

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

@@ -1,40 +0,0 @@
-using System.Linq;
-using Umbraco.Core.Configuration;
-using Umbraco.Core.Logging;
-using Umbraco.Core.Persistence.SqlSyntax;
-
-namespace Umbraco.Core.Persistence.Migrations.Upgrades.TargetVersionSevenFiveZero
-{
-    [Migration("7.5.0", 100, GlobalSettings.UmbracoMigrationName)]
-    public class AddRedirectUrlTable : MigrationBase
-    {
-        public AddRedirectUrlTable(ISqlSyntaxProvider sqlSyntax, ILogger logger)
-            : base(sqlSyntax, logger)
-        { }
-
-        public override void Up()
-        {
-            // don't exeucte if the table is already there
-            var tables = SqlSyntax.GetTablesInSchema(Context.Database).ToArray();
-            if (tables.InvariantContains("umbracoRedirectUrl")) return;
-
-            Create.Table("umbracoRedirectUrl")
-                .WithColumn("id").AsInt32().Identity().PrimaryKey("PK_umbracoRedirectUrl")
-                .WithColumn("contentId").AsInt32().NotNullable()
-                .WithColumn("createDateUtc").AsDateTime().NotNullable()
-                .WithColumn("url").AsString(2048).NotNullable();
-
-            //Create.PrimaryKey("PK_umbracoRedirectUrl").OnTable("umbracoRedirectUrl").Columns(new[] { "id" });
-
-            Create.Index("IX_umbracoRedirectUrl").OnTable("umbracoRedirectUrl")
-                  .OnColumn("url")
-                  .Ascending()
-                  .OnColumn("createDateUtc")
-                  .Ascending()
-                  .WithOptions().NonClustered();
-        }
-
-        public override void Down()
-        { }
-    }
-}

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

@@ -1,57 +0,0 @@
-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/Querying/BaseExpressionHelper.cs

@@ -128,34 +128,6 @@ 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);
@@ -180,7 +152,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;
             }
         }
 
@@ -259,47 +231,25 @@ namespace Umbraco.Core.Persistence.Querying
             switch (u.NodeType)
             {
                 case ExpressionType.Not:
-                    return VisitNot(u.Operand);
+                    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);                            
+                    }
                 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/Repositories/ContentRepository.cs

@@ -105,7 +105,6 @@ 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)",
@@ -143,7 +142,6 @@ namespace Umbraco.Core.Persistence.Repositories
         {
             var list = new List<string>
                            {
-                               "DELETE FROM umbracoRedirectUrl WHERE contentId = @Id",
                                "DELETE FROM cmsTask WHERE nodeId = @Id",
                                "DELETE FROM umbracoUser2NodeNotify WHERE nodeId = @Id",
                                "DELETE FROM umbracoUser2NodePermission WHERE nodeId = @Id",
@@ -243,8 +241,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, true);
-
+                    ProcessQuery, "Path", Direction.Ascending);
+                
                 var xmlItems = (from descendant in descendants
                                 let xml = serializer(descendant)
                                 select new ContentXmlDto { NodeId = descendant.Id, Xml = xml.ToDataString() }).ToArray();
@@ -768,11 +766,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>
         public IEnumerable<IContent> GetPagedResultsByQuery(IQuery<IContent> query, long pageIndex, int pageSize, out long totalRecords,
-            string orderBy, Direction orderDirection, bool orderBySystemField, string filter = "")
+            string orderBy, Direction orderDirection, string filter = "")
         {
 
             //NOTE: This uses the GetBaseQuery method but that does not take into account the required 'newest' field which is 
@@ -791,7 +788,7 @@ namespace Umbraco.Core.Persistence.Repositories
 
             return GetPagedResultsByQuery<DocumentDto, Content>(query, pageIndex, pageSize, out totalRecords,
                 new Tuple<string, string>("cmsDocument", "nodeId"),
-                ProcessQuery, orderBy, orderDirection, orderBySystemField,
+                ProcessQuery, orderBy, orderDirection,
                 filterCallback);
 
         }

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

@@ -914,7 +914,7 @@ AND umbracoNode.id <> @id",
                     //check for default templates                    
                     bool? isDefaultTemplate = Convert.ToBoolean(ct.dtIsDefault);
                     int? templateId = ct.dtTemplateId;
-                    if (currDefaultTemplate == -1 && isDefaultTemplate.HasValue && isDefaultTemplate.Value && templateId.HasValue)
+                    if (currDefaultTemplate == -1 && isDefaultTemplate.HasValue && templateId.HasValue)
                     {
                         currDefaultTemplate = templateId.Value;
                     }
@@ -1212,19 +1212,5 @@ AND umbracoNode.id <> @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/Interfaces/IContentRepository.cs

@@ -84,10 +84,9 @@ 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, bool orderBySystemField, string filter = "");
+            string orderBy, Direction orderDirection, string filter = "");
     }
 }

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

@@ -32,13 +32,5 @@ namespace Umbraco.Core.Persistence.Repositories
         /// </param>
         /// <returns></returns>
         IEnumerable<string> GetAllContentTypeAliases(params Guid[] objectTypes);
-
-        /// <summary>
-        /// Derives a unique alias from an existing alias.
-        /// </summary>
-        /// <param name="alias">The original alias.</param>
-        /// <returns>The original alias with a number appended to it, so that it is unique.</returns>
-        /// /// <remarks>Unique accross all content, media and member types.</remarks>
-        string GetUniqueAlias(string alias);
     }
 }

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

@@ -9,7 +9,7 @@ namespace Umbraco.Core.Persistence.Repositories
 {
     public interface IMediaRepository : IRepositoryVersionable<int, IMedia>, IRecycleBinRepository<IMedia>, IDeleteMediaFilesRepository
     {
-
+        
         /// <summary>
         /// Used to add/update published xml for the media item
         /// </summary>
@@ -33,10 +33,9 @@ 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="IMedia"/> objects</returns>
         IEnumerable<IMedia> GetPagedResultsByQuery(IQuery<IMedia> query, long pageIndex, int pageSize, out long totalRecords,
-            string orderBy, Direction orderDirection, bool orderBySystemField, string filter = "");
+            string orderBy, Direction orderDirection, string filter = "");
     }
 }

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

@@ -15,13 +15,5 @@ namespace Umbraco.Core.Persistence.Repositories
         IEnumerable<IMediaType> GetByQuery(IQuery<PropertyType> query);
 
         IEnumerable<MoveEventInfo<IMediaType>> Move(IMediaType toMove, EntityContainer container);
-
-        /// <summary>
-        /// Derives a unique alias from an existing alias.
-        /// </summary>
-        /// <param name="alias">The original alias.</param>
-        /// <returns>The original alias with a number appended to it, so that it is unique.</returns>
-        /// <remarks>Unique accross all content, media and member types.</remarks>
-        string GetUniqueAlias(string alias);
     }
 }

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

@@ -44,17 +44,16 @@ namespace Umbraco.Core.Persistence.Repositories
         /// <summary>
         /// Gets paged member results
         /// </summary>
-        /// <param name="query">The query.</param>
-        /// <param name="pageIndex">Index of the page.</param>
-        /// <param name="pageSize">Size of the page.</param>
-        /// <param name="totalRecords">The total records.</param>
-        /// <param name="orderBy">The order by column</param>
-        /// <param name="orderDirection">The order direction.</param>
-        /// <param name="orderBySystemField">Flag to indicate when ordering by system field</param>
-        /// <param name="filter">Search query</param>
+        /// <param name="query"></param>
+        /// <param name="pageIndex"></param>
+        /// <param name="pageSize"></param>
+        /// <param name="totalRecords"></param>
+        /// <param name="orderBy"></param>
+        /// <param name="orderDirection"></param>
+        /// <param name="filter"></param>
         /// <returns></returns>
         IEnumerable<IMember> GetPagedResultsByQuery(IQuery<IMember> query, long pageIndex, int pageSize, out long totalRecords,
-            string orderBy, Direction orderDirection, bool orderBySystemField, string filter = "");
+            string orderBy, Direction orderDirection, string filter = "");
 
         //IEnumerable<IMember> GetPagedResultsByQuery<TDto>(
         //    Sql sql, int pageIndex, int pageSize, out int totalRecords,

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

@@ -1,17 +0,0 @@
-using System.Collections.Generic;
-using Umbraco.Core.Models;
-
-namespace Umbraco.Core.Persistence.Repositories
-{
-    public interface IRedirectUrlRepository : IRepositoryQueryable<int, IRedirectUrl>
-    {
-        IRedirectUrl Get(string url, int contentId);
-        void Delete(int id);
-        void DeleteAll();
-        void DeleteContentUrls(int contentId);
-        IRedirectUrl GetMostRecentUrl(string url);
-        IEnumerable<RedirectUrl> GetContentUrls(int contentId);
-        IEnumerable<RedirectUrl> GetAllUrls(long pageIndex, int pageSize, out long total);
-        IEnumerable<RedirectUrl> GetAllUrls(int rootContentId, long pageIndex, int pageSize, out long total);
-    }
-}

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

@@ -232,7 +232,7 @@ namespace Umbraco.Core.Persistence.Repositories
             var processed = 0;
             do
             {
-                var descendants = GetPagedResultsByQuery(query, pageIndex, pageSize, out total, "Path", Direction.Ascending, true);
+                var descendants = GetPagedResultsByQuery(query, pageIndex, pageSize, out total, "Path", Direction.Ascending);
 
                 var xmlItems = (from descendant in descendants
                                 let xml = serializer(descendant)
@@ -442,11 +442,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="IMedia"/> objects</returns>
         public IEnumerable<IMedia> GetPagedResultsByQuery(IQuery<IMedia> query, long pageIndex, int pageSize, out long totalRecords,
-            string orderBy, Direction orderDirection, bool orderBySystemField, string filter = "")
+            string orderBy, Direction orderDirection, string filter = "")
         {
             var args = new List<object>();
             var sbWhere = new StringBuilder();
@@ -460,7 +459,7 @@ namespace Umbraco.Core.Persistence.Repositories
 
             return GetPagedResultsByQuery<ContentVersionDto, Models.Media>(query, pageIndex, pageSize, out totalRecords,
                 new Tuple<string, string>("cmsContentVersion", "contentId"),
-                ProcessQuery, orderBy, orderDirection, orderBySystemField,
+                ProcessQuery, orderBy, orderDirection,
                 filterCallback);
 
         }
@@ -469,7 +468,7 @@ namespace Umbraco.Core.Persistence.Repositories
         {
             //NOTE: This doesn't allow properties to be part of the query
             var dtos = Database.Fetch<ContentVersionDto, ContentDto, NodeDto>(sql);
-
+            
             var ids = dtos.Select(x => x.ContentDto.ContentTypeId).ToArray();
 
             //content types

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

@@ -74,7 +74,7 @@ namespace Umbraco.Core.Persistence.Repositories
             }
 
             return ProcessQuery(sql);
-
+            
         }
 
         protected override IEnumerable<IMember> PerformGetByQuery(IQuery<IMember> query)
@@ -95,7 +95,7 @@ namespace Umbraco.Core.Persistence.Repositories
                 baseQuery.Append(new Sql("WHERE umbracoNode.id IN (" + sql.SQL + ")", sql.Arguments))
                     .OrderBy<NodeDto>(x => x.SortOrder);
 
-                return ProcessQuery(baseQuery);
+                return ProcessQuery(baseQuery);    
             }
             else
             {
@@ -103,7 +103,7 @@ namespace Umbraco.Core.Persistence.Repositories
                 var sql = translator.Translate()
                     .OrderBy<NodeDto>(x => x.SortOrder);
 
-                return ProcessQuery(sql);
+                return ProcessQuery(sql);    
             }
 
         }
@@ -118,7 +118,7 @@ namespace Umbraco.Core.Persistence.Repositories
             sql.Select(isCount ? "COUNT(*)" : "*")
                 .From<MemberDto>()
                 .InnerJoin<ContentVersionDto>()
-                .On<ContentVersionDto, MemberDto>(left => left.NodeId, right => right.NodeId)
+                .On<ContentVersionDto, MemberDto>(left => left.NodeId, right => right.NodeId)                
                 .InnerJoin<ContentDto>()
                 .On<ContentVersionDto, ContentDto>(left => left.NodeId, right => right.NodeId)
                 //We're joining the type so we can do a query against the member type - not sure if this adds much overhead or not?
@@ -269,7 +269,7 @@ namespace Umbraco.Core.Persistence.Repositories
             //Ensure that strings don't contain characters that are invalid in XML
             entity.SanitizeEntityPropertiesForXmlStorage();
 
-            var dirtyEntity = (ICanBeDirty)entity;
+            var dirtyEntity = (ICanBeDirty) entity;
 
             //Look up parent to get and set the correct Path and update SortOrder if ParentId has changed
             if (dirtyEntity.IsPropertyDirty("ParentId"))
@@ -308,9 +308,9 @@ namespace Umbraco.Core.Persistence.Repositories
             //Updates the current version - cmsContentVersion
             //Assumes a Version guid exists and Version date (modified date) has been set/updated
             Database.Update(dto.ContentVersionDto);
-
+            
             //Updates the cmsMember entry if it has changed
-
+            
             //NOTE: these cols are the REAL column names in the db
             var changedCols = new List<string>();
 
@@ -330,13 +330,13 @@ namespace Umbraco.Core.Persistence.Repositories
             //only update the changed cols
             if (changedCols.Count > 0)
             {
-                Database.Update(dto, changedCols);
+                Database.Update(dto, changedCols);    
             }
 
             //TODO ContentType for the Member entity
 
             //Create the PropertyData for this version - cmsPropertyData
-            var propertyFactory = new PropertyFactory(entity.ContentType.CompositionPropertyTypes.ToArray(), entity.Version, entity.Id);
+            var propertyFactory = new PropertyFactory(entity.ContentType.CompositionPropertyTypes.ToArray(), entity.Version, entity.Id);            
             var keyDictionary = new Dictionary<int, int>();
 
             //Add Properties
@@ -447,7 +447,7 @@ namespace Umbraco.Core.Persistence.Repositories
             var processed = 0;
             do
             {
-                var descendants = GetPagedResultsByQuery(query, pageIndex, pageSize, out total, "Path", Direction.Ascending, true);
+                var descendants = GetPagedResultsByQuery(query, pageIndex, pageSize, out total, "Path", Direction.Ascending);
 
                 var xmlItems = (from descendant in descendants
                                 let xml = serializer(descendant)
@@ -559,7 +559,7 @@ namespace Umbraco.Core.Persistence.Repositories
             var grpQry = new Query<IMemberGroup>().Where(group => group.Name.Equals(groupName));
             var memberGroup = _memberGroupRepository.GetByQuery(grpQry).FirstOrDefault();
             if (memberGroup == null) return Enumerable.Empty<IMember>();
-
+            
             var subQuery = new Sql().Select("Member").From<Member2MemberGroupDto>().Where<Member2MemberGroupDto>(dto => dto.MemberGroup == memberGroup.Id);
 
             var sql = GetBaseQuery(false)
@@ -568,7 +568,7 @@ namespace Umbraco.Core.Persistence.Repositories
                 .Append(new Sql("WHERE umbracoNode.id IN (" + subQuery.SQL + ")", subQuery.Arguments))
                 .OrderByDescending<ContentVersionDto>(x => x.VersionDate)
                 .OrderBy<NodeDto>(x => x.SortOrder);
-
+            
             return ProcessQuery(sql);
 
         }
@@ -593,7 +593,7 @@ namespace Umbraco.Core.Persistence.Repositories
             //get the COUNT base query
             var fullSql = GetBaseQuery(true)
                 .Append(new Sql("WHERE umbracoNode.id IN (" + sql.SQL + ")", sql.Arguments));
-
+            
             return Database.ExecuteScalar<int>(fullSql);
         }
 
@@ -603,19 +603,18 @@ namespace Umbraco.Core.Persistence.Repositories
         /// <param name="query">
         /// The where clause, if this is null all records are queried
         /// </param>
-        /// <param name="pageIndex">Index of the page.</param>
-        /// <param name="pageSize">Size of the page.</param>
-        /// <param name="totalRecords">The total records.</param>
-        /// <param name="orderBy">The order by column</param>
-        /// <param name="orderDirection">The order direction.</param>
-        /// <param name="orderBySystemField">Flag to indicate when ordering by system field</param>
-        /// <param name="filter">Search query</param>
+        /// <param name="pageIndex"></param>
+        /// <param name="pageSize"></param>
+        /// <param name="totalRecords"></param>
+        /// <param name="orderBy"></param>
+        /// <param name="orderDirection"></param>
+        /// <param name="filter"></param>
         /// <returns></returns>
         /// <remarks>
         /// The query supplied will ONLY work with data specifically on the cmsMember table because we are using PetaPoco paging (SQL paging)
         /// </remarks>
         public IEnumerable<IMember> GetPagedResultsByQuery(IQuery<IMember> query, long pageIndex, int pageSize, out long totalRecords,
-            string orderBy, Direction orderDirection, bool orderBySystemField, string filter = "")
+            string orderBy, Direction orderDirection, string filter = "")
         {
             var args = new List<object>();
             var sbWhere = new StringBuilder();
@@ -626,14 +625,14 @@ namespace Umbraco.Core.Persistence.Repositories
                                 "OR (cmsMember.LoginName LIKE @0" + args.Count + "))");
                 args.Add("%" + filter + "%");
                 filterCallback = () => new Tuple<string, object[]>(sbWhere.ToString().Trim(), args.ToArray());
-            }
+            }           
 
             return GetPagedResultsByQuery<MemberDto, Member>(query, pageIndex, pageSize, out totalRecords,
                 new Tuple<string, string>("cmsMember", "nodeId"),
-                ProcessQuery, orderBy, orderDirection, orderBySystemField,
+                ProcessQuery, orderBy, orderDirection,
                 filterCallback);
         }
-
+        
         public void AddOrUpdateContentXml(IMember content, Func<IMember, XElement> xml)
         {
             _contentXmlRepository.AddOrUpdate(new ContentXmlEntity<IMember>(content, xml));
@@ -683,7 +682,7 @@ namespace Umbraco.Core.Persistence.Repositories
             var dtosWithContentTypes = dtos
                 //This select into and null check are required because we don't have a foreign damn key on the contentType column
                 // http://issues.umbraco.org/issue/U4-5503
-                .Select(x => new { dto = x, contentType = contentTypes.FirstOrDefault(ct => ct.Id == x.ContentVersionDto.ContentDto.ContentTypeId) })
+                .Select(x => new {dto = x, contentType = contentTypes.FirstOrDefault(ct => ct.Id == x.ContentVersionDto.ContentDto.ContentTypeId)})
                 .Where(x => x.contentType != null)
                 .ToArray();
 
@@ -695,12 +694,12 @@ namespace Umbraco.Core.Persistence.Repositories
                 d.dto.ContentVersionDto.ContentDto.NodeDto.CreateDate,
                 d.contentType));
 
-            var propertyData = GetPropertyCollection(sql, docDefs);
+            var propertyData = GetPropertyCollection(sql, docDefs); 
 
             return dtosWithContentTypes.Select(d => CreateMemberFromDto(
                         d.dto,
                         contentTypes.First(ct => ct.Id == d.dto.ContentVersionDto.ContentDto.ContentTypeId),
-                        propertyData[d.dto.NodeId]));
+                        propertyData[d.dto.NodeId])); 
         }
 
         /// <summary>

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

@@ -94,11 +94,11 @@ namespace Umbraco.Core.Persistence.Repositories
             }
 
             sql.Select("umbracoNode.*", "cmsContentType.*", "cmsPropertyType.id AS PropertyTypeId", "cmsPropertyType.Alias",
-                "cmsPropertyType.Name", "cmsPropertyType.Description", "cmsPropertyType.mandatory", "cmsPropertyType.UniqueID",
+                "cmsPropertyType.Name", "cmsPropertyType.Description", "cmsPropertyType.mandatory",
                 "cmsPropertyType.validationRegExp", "cmsPropertyType.dataTypeId", "cmsPropertyType.sortOrder AS PropertyTypeSortOrder",
                 "cmsPropertyType.propertyTypeGroupId AS PropertyTypesGroupId", "cmsMemberType.memberCanEdit", "cmsMemberType.viewOnProfile",
                 "cmsDataType.propertyEditorAlias", "cmsDataType.dbType", "cmsPropertyTypeGroup.id AS PropertyTypeGroupId", 
-                "cmsPropertyTypeGroup.text AS PropertyGroupName", "cmsPropertyTypeGroup.uniqueID AS PropertyGroupUniqueID",
+                "cmsPropertyTypeGroup.text AS PropertyGroupName",
                 "cmsPropertyTypeGroup.sortorder AS PropertyGroupSortOrder", "cmsPropertyTypeGroup.contenttypeNodeId")
                 .From<NodeDto>()
                 .InnerJoin<ContentTypeDto>().On<ContentTypeDto, NodeDto>(left => left.NodeId, right => right.NodeId)

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

@@ -1,193 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using Umbraco.Core.Logging;
-using Umbraco.Core.Models;
-using Umbraco.Core.Models.Rdbms;
-using Umbraco.Core.Persistence.Querying;
-using Umbraco.Core.Persistence.SqlSyntax;
-using Umbraco.Core.Persistence.UnitOfWork;
-
-namespace Umbraco.Core.Persistence.Repositories
-{
-    internal class RedirectUrlRepository : PetaPocoRepositoryBase<int, IRedirectUrl>, IRedirectUrlRepository
-    {
-        public RedirectUrlRepository(IDatabaseUnitOfWork work, CacheHelper cache, ILogger logger, ISqlSyntaxProvider sqlSyntax) 
-            : base(work, cache, logger, sqlSyntax)
-        { }
-
-        protected override int PerformCount(IQuery<IRedirectUrl> query)
-        {
-            throw new NotSupportedException("This repository does not support this method.");
-        }
-
-        protected override bool PerformExists(int id)
-        {
-            return PerformGet(id) != null;
-        }
-
-        protected override IRedirectUrl PerformGet(int id)
-        {
-            var sql = GetBaseQuery(false).Where<RedirectUrlDto>(x => x.Id == id);
-            var dto = Database.Fetch<RedirectUrlDto>(sql).FirstOrDefault();
-            return dto == null ? null : Map(dto);
-        }
-
-        protected override IEnumerable<IRedirectUrl> PerformGetAll(params int[] ids)
-        {
-            if (ids.Length > 2000)
-                throw new NotSupportedException("This repository does not support more than 2000 ids.");
-            var sql = GetBaseQuery(false).WhereIn<RedirectUrlDto>(x => x.Id, ids);
-            var dtos = Database.Fetch<RedirectUrlDto>(sql);
-            return dtos.WhereNotNull().Select(Map);
-        }
-
-        protected override IEnumerable<IRedirectUrl> PerformGetByQuery(IQuery<IRedirectUrl> query)
-        {
-            throw new NotSupportedException("This repository does not support this method.");
-        }
-
-        protected override Sql GetBaseQuery(bool isCount)
-        {
-            var sql = new Sql();
-            sql.Select(isCount ? "COUNT(*)" : "*").From<RedirectUrlDto>(SqlSyntax);
-            return sql;
-        }
-
-        protected override string GetBaseWhereClause()
-        {
-            return "id = @Id";
-        }
-
-        protected override IEnumerable<string> GetDeleteClauses()
-        {
-            var list = new List<string>
-                {
-                    "DELETE FROM umbracoRedirectUrl WHERE id = @Id"
-                };
-            return list;
-        }
-
-        protected override Guid NodeObjectTypeId
-        {
-            get { throw new NotImplementedException(); }
-        }
-
-        protected override void PersistNewItem(IRedirectUrl entity)
-        {
-            var dto = Map(entity);
-            Database.Insert(dto);
-            entity.Id = dto.Id;
-        }
-
-        protected override void PersistUpdatedItem(IRedirectUrl entity)
-        {
-            var dto = Map(entity);
-            Database.Update(dto);
-        }
-
-        private static RedirectUrlDto Map(IRedirectUrl redirectUrl)
-        {
-            if (redirectUrl == null) return null;
-
-            return new RedirectUrlDto
-            {
-                Id = redirectUrl.Id,
-                ContentId = redirectUrl.ContentId,
-                CreateDateUtc = redirectUrl.CreateDateUtc,
-                Url = redirectUrl.Url
-            };
-        }
-
-        private static IRedirectUrl Map(RedirectUrlDto dto)
-        {
-            if (dto == null) return null;
-
-            return new RedirectUrl
-            {
-                Id = dto.Id,
-                ContentId = dto.ContentId,
-                CreateDateUtc = dto.CreateDateUtc,
-                Url = dto.Url
-            };
-        }
-
-        public IRedirectUrl Get(string url, int contentId)
-        {
-            var sql = GetBaseQuery(false).Where<RedirectUrlDto>(x => x.Url == url && x.ContentId == contentId);
-            var dto = Database.Fetch<RedirectUrlDto>(sql).FirstOrDefault();
-            return dto == null ? null : Map(dto);
-        }
-
-        public void DeleteAll()
-        {
-            Database.Execute("DELETE FROM umbracoRedirectUrl");
-        }
-
-        public void DeleteContentUrls(int contentId)
-        {
-            Database.Execute("DELETE FROM umbracoRedirectUrl WHERE contentId=@contentId", new { contentId });
-        }
-
-        public void Delete(int id)
-        {
-            Database.Delete<RedirectUrlDto>(id);
-        }
-
-        public IRedirectUrl GetMostRecentUrl(string url)
-        {
-            var dtos = Database.Fetch<RedirectUrlDto>("SELECT * FROM umbracoRedirectUrl WHERE url=@url ORDER BY createDateUtc DESC;",
-                new { url });
-            var dto = dtos.FirstOrDefault();
-            return dto == null ? null : Map(dto);
-        }
-
-        public IEnumerable<RedirectUrl> GetContentUrls(int contentId)
-        {
-            var dtos = Database.Fetch<RedirectUrlDto>("SELECT * FROM umbracoRedirectUrl WHERE contentId=@id ORDER BY createDateUtc DESC;",
-                new { id = contentId });
-            return dtos.Select(x => new RedirectUrl
-            {
-                Id = x.Id,
-                ContentId = x.ContentId,
-                CreateDateUtc = x.CreateDateUtc,
-                Url = x.Url
-            });
-        }
-
-        public IEnumerable<RedirectUrl> GetAllUrls(long pageIndex, int pageSize, out long total)
-        {
-            var sql = GetBaseQuery(false).OrderByDescending<RedirectUrlDto>(x => x.CreateDateUtc, SqlSyntax);
-            var result = Database.Page<RedirectUrlDto>(pageIndex + 1, pageSize, sql);
-            total = Convert.ToInt32(result.TotalItems);
-
-            var rules = result.Items.Select(x => new RedirectUrl
-            {
-                Id = x.Id,
-                ContentId = x.ContentId,
-                CreateDateUtc = x.CreateDateUtc,
-                Url = x.Url
-            });
-            return rules;
-        }
-
-        public IEnumerable<RedirectUrl> GetAllUrls(int rootContentId, long pageIndex, int pageSize, out long total)
-        {
-            var sql = GetBaseQuery(false)
-                .InnerJoin<NodeDto>(SqlSyntax).On<NodeDto, RedirectUrlDto>(SqlSyntax, left => left.NodeId, right => right.ContentId)
-                .Where("umbracoNode.path LIKE @path", new { path = "%," + rootContentId + ",%" })
-                .OrderByDescending<RedirectUrlDto>(x => x.CreateDateUtc, SqlSyntax);
-            var result = Database.Page<RedirectUrlDto>(pageIndex + 1, pageSize, sql);
-            total = Convert.ToInt32(result.TotalItems);
-
-            var rules = result.Items.Select(x => new RedirectUrl
-            {
-                Id = x.Id,
-                ContentId = x.ContentId,
-                CreateDateUtc = x.CreateDateUtc,
-                Url = x.Url
-            });
-            return rules;
-        }
-    }
-}

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

@@ -25,7 +25,7 @@ namespace Umbraco.Core.Persistence.Repositories
 
         protected override int PerformCount(IQuery<IServerRegistration> query)
         {
-            throw new NotSupportedException("This repository does not support this method.");
+            throw new NotSupportedException("This repository does not support this method");
         }
 
         protected override bool PerformExists(int id)
@@ -55,7 +55,7 @@ namespace Umbraco.Core.Persistence.Repositories
 
         protected override IEnumerable<IServerRegistration> PerformGetByQuery(IQuery<IServerRegistration> query)
         {
-            throw new NotSupportedException("This repository does not support this method.");
+            throw new NotSupportedException("This repository does not support this method");
         }
 
         protected override Sql GetBaseQuery(bool isCount)

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

@@ -25,8 +25,6 @@ using Umbraco.Core.IO;
 
 namespace Umbraco.Core.Persistence.Repositories
 {
-    using SqlSyntax;
-
     internal abstract class VersionableRepositoryBase<TId, TEntity> : PetaPocoRepositoryBase<TId, TEntity>
         where TEntity : class, IAggregateRoot
     {
@@ -63,11 +61,11 @@ namespace Umbraco.Core.Persistence.Repositories
         public virtual void DeleteVersion(Guid versionId)
         {
             var dto = Database.FirstOrDefault<ContentVersionDto>("WHERE versionId = @VersionId", new { VersionId = versionId });
-            if (dto == null) return;
+            if(dto == null) return;
 
             //Ensure that the lastest version is not deleted
             var latestVersionDto = Database.FirstOrDefault<ContentVersionDto>("WHERE ContentId = @Id ORDER BY VersionDate DESC", new { Id = dto.NodeId });
-            if (latestVersionDto.VersionId == dto.VersionId)
+            if(latestVersionDto.VersionId == dto.VersionId)
                 return;
 
             using (var transaction = Database.GetTransaction())
@@ -85,7 +83,7 @@ namespace Umbraco.Core.Persistence.Repositories
             var list =
                 Database.Fetch<ContentVersionDto>(
                     "WHERE versionId <> @VersionId AND (ContentId = @Id AND VersionDate < @VersionDate)",
-                    new { VersionId = latestVersionDto.VersionId, Id = id, VersionDate = versionDate });
+                    new {VersionId = latestVersionDto.VersionId, Id = id, VersionDate = versionDate});
             if (list.Any() == false) return;
 
             using (var transaction = Database.GetTransaction())
@@ -246,68 +244,25 @@ namespace Umbraco.Core.Persistence.Repositories
             return filteredSql;
         }
 
-        private Sql GetSortedSqlForPagedResults(Sql sql, Direction orderDirection, string orderBy, bool orderBySystemField)
+        private Sql GetSortedSqlForPagedResults(Sql sql, Direction orderDirection, string orderBy)
         {
-
             //copy to var so that the original isn't changed
             var sortedSql = new Sql(sql.SQL, sql.Arguments);
-
-            if (orderBySystemField)
+            // Apply order according to parameters
+            if (string.IsNullOrEmpty(orderBy) == false)
             {
-                // Apply order according to parameters
-                if (string.IsNullOrEmpty(orderBy) == false)
+                var orderByParams = new[] { GetDatabaseFieldNameForOrderBy(orderBy) };
+                if (orderDirection == Direction.Ascending)
                 {
-                    var orderByParams = new[] { GetDatabaseFieldNameForOrderBy(orderBy) };
-                    if (orderDirection == Direction.Ascending)
-                    {
-                        sortedSql.OrderBy(orderByParams);
-                    }
-                    else
-                    {
-                        sortedSql.OrderByDescending(orderByParams);
-                    }
+                    sortedSql.OrderBy(orderByParams);
                 }
-            }
-            else
-            {
-                // Sorting by a custom field, so set-up sub-query for ORDER BY clause to pull through valie
-                // from most recent content version for the given order by field
-                var sortedInt = string.Format(SqlSyntax.ConvertIntegerToOrderableString, "dataInt");
-                var sortedDate = string.Format(SqlSyntax.ConvertDateToOrderableString, "dataDate");
-                var sortedString = string.Format("COALESCE({0},'')", "dataNvarchar");
-                var sortedDecimal = string.Format(SqlSyntax.ConvertDecimalToOrderableString, "dataDecimal");
-
-                var innerJoinTempTable = string.Format(@"INNER JOIN (
-                 	                SELECT CASE
-                 		                WHEN dataInt Is Not Null THEN {0}
-                                        WHEN dataDecimal Is Not Null THEN {1}
-                                        WHEN dataDate Is Not Null THEN {2}
-                                        ELSE {3}
-                 	                END AS CustomPropVal,
-                                    cd.nodeId AS CustomPropValContentId
-                 	                FROM cmsDocument cd
-                                    INNER JOIN cmsPropertyData cpd ON cpd.contentNodeId = cd.nodeId AND cpd.versionId = cd.versionId                    
-                                    INNER JOIN cmsPropertyType cpt ON cpt.Id = cpd.propertytypeId
-                			        WHERE cpt.Alias = @{4} AND cd.newest = 1) AS CustomPropData
-                                    ON CustomPropData.CustomPropValContentId = umbracoNode.id
-                ", sortedInt, sortedDecimal, sortedDate, sortedString, sortedSql.Arguments.Length);
-
-                //insert this just above the LEFT OUTER JOIN
-                var newSql = sortedSql.SQL.Insert(sortedSql.SQL.IndexOf("LEFT OUTER JOIN"), innerJoinTempTable);
-                var newArgs = sortedSql.Arguments.ToList();
-                newArgs.Add(orderBy);
-
-                sortedSql = new Sql(newSql, newArgs.ToArray());
-
-                sortedSql.OrderBy("CustomPropData.CustomPropVal");
-                if (orderDirection == Direction.Descending)
+                else
                 {
-                    sortedSql.Append(" DESC");
-                }                
+                    sortedSql.OrderByDescending(orderByParams);
+                }
+                return sortedSql;
             }
-
             return sortedSql;
-            
         }
 
         /// <summary>
@@ -324,15 +279,13 @@ namespace Umbraco.Core.Persistence.Repositories
         /// <param name="processQuery">A callback to process the query result</param>
         /// <param name="orderBy">The order by column</param>
         /// <param name="orderDirection">The order direction.</param>
-        /// <param name="orderBySystemField">Flag to indicate when ordering by system field</param>
         /// <returns></returns>
         /// <exception cref="System.ArgumentNullException">orderBy</exception>
         protected IEnumerable<TEntity> GetPagedResultsByQuery<TDto, TContentBase>(IQuery<TEntity> query, long pageIndex, int pageSize, out long totalRecords,
             Tuple<string, string> nodeIdSelect,
             Func<Sql, IEnumerable<TEntity>> processQuery,
-            string orderBy,
+            string orderBy, 
             Direction orderDirection,
-            bool orderBySystemField,
             Func<Tuple<string, object[]>> defaultFilter = null)
             where TContentBase : class, IAggregateRoot, TEntity
         {
@@ -344,18 +297,18 @@ namespace Umbraco.Core.Persistence.Repositories
             if (query == null) query = new Query<TEntity>();
             var translator = new SqlTranslator<TEntity>(sqlBase, query);
             var sqlQuery = translator.Translate();
-
+            
             // Note we can't do multi-page for several DTOs like we can multi-fetch and are doing in PerformGetByQuery, 
             // but actually given we are doing a Get on each one (again as in PerformGetByQuery), we only need the node Id.
             // So we'll modify the SQL.
             var sqlNodeIds = new Sql(
-                sqlQuery.SQL.Replace("SELECT *", string.Format("SELECT {0}.{1}", nodeIdSelect.Item1, nodeIdSelect.Item2)),
+                sqlQuery.SQL.Replace("SELECT *", string.Format("SELECT {0}.{1}",nodeIdSelect.Item1, nodeIdSelect.Item2)), 
                 sqlQuery.Arguments);
-
+            
             //get sorted and filtered sql
             var sqlNodeIdsWithSort = GetSortedSqlForPagedResults(
                 GetFilteredSqlForPagedResults(sqlNodeIds, defaultFilter),
-                orderDirection, orderBy, orderBySystemField);
+                orderDirection, orderBy);
 
             // Get page of results and total count
             IEnumerable<TEntity> result;
@@ -371,7 +324,7 @@ namespace Umbraco.Core.Persistence.Repositories
                 var args = sqlNodeIdsWithSort.Arguments;
                 string sqlStringCount, sqlStringPage;
                 Database.BuildPageQueries<TDto>(pageIndex * pageSize, pageSize, sqlNodeIdsWithSort.SQL, ref args, out sqlStringCount, out sqlStringPage);
-
+                
                 //if this is for sql server, the sqlPage will start with a SELECT * but we don't want that, we only want to return the nodeId                
                 sqlStringPage = sqlStringPage
                     .Replace("SELECT *",
@@ -380,7 +333,7 @@ namespace Umbraco.Core.Persistence.Repositories
                         "SELECT " + nodeIdSelect.Item2);
 
                 //We need to make this an inner join on the paged query
-                var splitQuery = sqlQuery.SQL.Split(new[] { "WHERE " }, StringSplitOptions.None);
+                var splitQuery = sqlQuery.SQL.Split(new[] {"WHERE "}, StringSplitOptions.None);
                 var withInnerJoinSql = new Sql(splitQuery[0])
                     .Append("INNER JOIN (")
                     //join the paged query with the paged query arguments
@@ -392,9 +345,23 @@ namespace Umbraco.Core.Persistence.Repositories
 
                 //get sorted and filtered sql
                 var fullQuery = GetSortedSqlForPagedResults(
-                    GetFilteredSqlForPagedResults(withInnerJoinSql, defaultFilter),
-                    orderDirection, orderBy, orderBySystemField);
-                return processQuery(fullQuery);
+                    GetFilteredSqlForPagedResults(withInnerJoinSql, defaultFilter),                     
+                    orderDirection, orderBy);
+                
+                var content = processQuery(fullQuery)
+                    .Cast<TContentBase>()
+                    .AsQueryable();
+
+                // Now we need to ensure this result is also ordered by the same order by clause
+                var orderByProperty = GetEntityPropertyNameForOrderBy(orderBy);
+                if (orderDirection == Direction.Ascending)
+                {
+                    result = content.OrderBy(orderByProperty);
+                }
+                else
+                {
+                    result = content.OrderByDescending(orderByProperty);
+                }
             }
             else
             {
@@ -427,9 +394,9 @@ INNER JOIN
 	(" + string.Format(parsedOriginalSql, "cmsContent.nodeId, cmsContentVersion.VersionId") + @") as docData
 ON cmsPropertyData.versionId = docData.VersionId AND cmsPropertyData.contentNodeId = docData.nodeId
 LEFT OUTER JOIN cmsDataTypePreValues
-ON cmsPropertyType.dataTypeId = cmsDataTypePreValues.datatypeNodeId", docSql.Arguments);
+ON cmsPropertyType.dataTypeId = cmsDataTypePreValues.datatypeNodeId", docSql.Arguments); 
 
-            var allPropertyData = Database.Fetch<PropertyDataDto>(propSql);
+            var allPropertyData = Database.Fetch<PropertyDataDto>(propSql); 
 
             //This is a lazy access call to get all prevalue data for the data types that make up all of these properties which we use
             // below if any property requires tag support
@@ -447,7 +414,7 @@ WHERE EXISTS(
     ON cmsPropertyType.contentTypeId = docData.contentType
     WHERE a.id = b.id)", docSql.Arguments);
 
-                return Database.Fetch<DataTypePreValueDto>(preValsSql);
+                return Database.Fetch<DataTypePreValueDto>(preValsSql); 
             });
 
             var result = new Dictionary<int, PropertyCollection>();
@@ -465,8 +432,8 @@ WHERE EXISTS(
                     var propertyDataDtos = allPropertyData.Where(x => x.NodeId == def.Id).Distinct();
 
                     var propertyFactory = new PropertyFactory(compositionProperties, def.Version, def.Id, def.CreateDate, def.VersionDate);
-                    var properties = propertyFactory.BuildEntity(propertyDataDtos.ToArray()).ToArray();
-
+                    var properties = propertyFactory.BuildEntity(propertyDataDtos.ToArray()).ToArray();                    
+                    
                     var newProperties = properties.Where(x => x.HasIdentity == false && x.PropertyType.HasIdentity);
 
                     foreach (var property in newProperties)
@@ -514,7 +481,7 @@ WHERE EXISTS(
                         Logger.Warn<VersionableRepositoryBase<TId, TEntity>>("The query returned multiple property sets for document definition " + def.Id + ", " + def.Composition.Name);
                     }
                     result[def.Id] = new PropertyCollection(properties);
-                }
+                }                
             }
 
             return result;
@@ -554,9 +521,6 @@ WHERE EXISTS(
                 case "OWNER":
                     //TODO: This isn't going to work very nicely because it's going to order by ID, not by letter
                     return "umbracoNode.nodeUser";
-                // Members only
-                case "USERNAME":
-                    return "cmsMember.LoginName";
                 default:
                     //ensure invalid SQL cannot be submitted
                     return Regex.Replace(orderBy, @"[^\w\.,`\[\]@-]", "");

src/Umbraco.Core/Persistence/RepositoryFactory.cs

@@ -333,14 +333,5 @@ namespace Umbraco.Core.Persistence
                 _logger, _sqlSyntax,
                 containerObjectType);
         }
-
-        public IRedirectUrlRepository CreateRedirectUrlRepository(IDatabaseUnitOfWork uow)
-        {
-            return new RedirectUrlRepository(
-                uow,
-                _cacheHelper,
-                _logger,
-                _sqlSyntax);
-        }
     }
 }

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

@@ -69,10 +69,6 @@ namespace Umbraco.Core.Persistence.SqlSyntax
         bool SupportsClustered();
         bool SupportsIdentityInsert();
         bool? SupportsCaseInsensitiveQueries(Database db);
-        
-        string ConvertIntegerToOrderableString { get; }
-        string ConvertDateToOrderableString { get; }
-        string ConvertDecimalToOrderableString { get; }
 
         IEnumerable<string> GetTablesInSchema(Database db);
         IEnumerable<ColumnInfo> GetColumnsInSchema(Database db);

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

@@ -18,7 +18,7 @@ namespace Umbraco.Core.Persistence.SqlSyntax
         public MySqlSyntaxProvider(ILogger logger)
         {
             _logger = logger;
-
+            
             AutoIncrementDefinition = "AUTO_INCREMENT";
             IntColumnDefinition = "int(11)";
             BoolColumnDefinition = "tinyint(1)";
@@ -26,7 +26,7 @@ namespace Umbraco.Core.Persistence.SqlSyntax
             TimeColumnDefinition = "time";
             DecimalColumnDefinition = "decimal(38,6)";
             GuidColumnDefinition = "char(36)";
-
+            
             DefaultValueFormat = "DEFAULT {0}";
 
             InitColumnTypeMap();
@@ -326,13 +326,13 @@ ORDER BY TABLE_NAME, INDEX_NAME",
             {
                 case SystemMethods.NewGuid:
                     return null; // NOT SUPPORTED!
-                                 //return "NEWID()";                
+                    //return "NEWID()";                
                 case SystemMethods.CurrentDateTime:
                     return "CURRENT_TIMESTAMP";
-                    //case SystemMethods.NewSequentialId:
-                    //    return "NEWSEQUENTIALID()";
-                    //case SystemMethods.CurrentUTCDateTime:
-                    //    return "GETUTCDATE()";
+                //case SystemMethods.NewSequentialId:
+                //    return "NEWSEQUENTIALID()";
+                //case SystemMethods.CurrentUTCDateTime:
+                //    return "GETUTCDATE()";
             }
 
             return null;
@@ -360,9 +360,6 @@ ORDER BY TABLE_NAME, INDEX_NAME",
         public override string DropIndex { get { return "DROP INDEX {0} ON {1}"; } }
 
         public override string RenameColumn { get { return "ALTER TABLE {0} CHANGE {1} {2}"; } }
-        public override string ConvertIntegerToOrderableString { get { return "LPAD(FORMAT({0}, 0), 8, '0')"; } }
-        public override string ConvertDateToOrderableString { get { return "DATE_FORMAT({0}, '%Y%m%d')"; } }
-        public override string ConvertDecimalToOrderableString { get { return "LPAD(FORMAT({0}, 9), 20, '0')"; } }
 
         public override bool? SupportsCaseInsensitiveQueries(Database db)
         {

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

@@ -208,6 +208,7 @@ ORDER BY TABLE_NAME, INDEX_NAME");
         
 
         public override string DropIndex { get { return "DROP INDEX {1}.{0}"; } }
+
         
     }
 }

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

@@ -322,7 +322,7 @@ namespace Umbraco.Core.Persistence.SqlSyntax
                                  GetQuotedColumnName(foreignKey.ForeignColumns.First()),
                                  GetQuotedTableName(foreignKey.PrimaryTable),
                                  GetQuotedColumnName(foreignKey.PrimaryColumns.First()),
-                                 FormatCascade("DELETE", foreignKey.OnDelete),
+                                 FormatCascade("DELETE", foreignKey.OnDelete), 
                                  FormatCascade("UPDATE", foreignKey.OnUpdate));
         }
 
@@ -331,7 +331,7 @@ namespace Umbraco.Core.Persistence.SqlSyntax
             var sb = new StringBuilder();
             foreach (var column in columns)
             {
-                sb.Append(Format(column) + ",\n");
+                sb.Append(Format(column) +",\n");
             }
             return sb.ToString().TrimEnd(",\n");
         }
@@ -431,11 +431,11 @@ namespace Umbraco.Core.Persistence.SqlSyntax
                 return GetSpecialDbType(column.DbType);
             }
 
-            Type type = column.Type.HasValue
+            Type type = column.Type.HasValue 
                 ? DbTypeMap.ColumnDbTypeMap.First(x => x.Value == column.Type.Value).Key
                 : column.PropertyType;
 
-            if (type == typeof(string))
+            if (type == typeof (string))
             {
                 var valueOrDefault = column.Size != default(int) ? column.Size : DefaultStringLength;
                 return string.Format(StringLengthColumnDefinitionFormat, valueOrDefault);
@@ -536,9 +536,5 @@ namespace Umbraco.Core.Persistence.SqlSyntax
         public virtual string CreateConstraint { get { return "ALTER TABLE {0} ADD CONSTRAINT {1} {2} ({3})"; } }
         public virtual string DeleteConstraint { get { return "ALTER TABLE {0} DROP CONSTRAINT {1}"; } }
         public virtual string CreateForeignKeyConstraint { get { return "ALTER TABLE {0} ADD CONSTRAINT {1} FOREIGN KEY ({2}) REFERENCES {3} ({4}){5}{6}"; } }
-
-        public virtual string ConvertIntegerToOrderableString { get { return "REPLACE(STR({0}, 8), SPACE(1), '0')"; } }
-        public virtual string ConvertDateToOrderableString { get { return "CONVERT(nvarchar, {0}, 102)"; } }
-        public virtual string ConvertDecimalToOrderableString { get { return "REPLACE(STR({0}, 20, 9), SPACE(1), '0')"; } }
     }
 }

src/Umbraco.Core/Persistence/UmbracoDatabase.cs

@@ -3,7 +3,6 @@ using System.Collections.Generic;
 using System.Data;
 using System.Data.Common;
 using System.Linq;
-using System.Text;
 using StackExchange.Profiling;
 using Umbraco.Core.Logging;
 
@@ -129,25 +128,15 @@ namespace Umbraco.Core.Persistence
             // if no timeout is specified, and the connection has a longer timeout, use it
             if (OneTimeCommandTimeout == 0 && CommandTimeout == 0 && cmd.Connection.ConnectionTimeout > 30)
                 cmd.CommandTimeout = cmd.Connection.ConnectionTimeout;
-
-            if (EnableSqlTrace)
-            {
-                var sb = new StringBuilder();
-                sb.Append(cmd.CommandText);
-                foreach (DbParameter p in cmd.Parameters)
-                {
-                    sb.Append(" - ");
-                    sb.Append(p.Value);
-                }
-                
-                _logger.Debug<UmbracoDatabase>(sb.ToString());
-            }
-
             base.OnExecutingCommand(cmd);
         }
 
         public override void OnExecutedCommand(IDbCommand cmd)
         {
+            if (EnableSqlTrace)
+            {
+                _logger.Debug<UmbracoDatabase>(cmd.CommandText);
+            }
             if (_enableCount)
             {
                 SqlCount++;

src/Umbraco.Core/PropertyEditors/PropertyEditorAttribute.cs

@@ -19,7 +19,7 @@ namespace Umbraco.Core.PropertyEditors
             EditorView = editorView;
 
             //defaults
-            ValueType = PropertyEditorValueTypes.String;
+            ValueType = "string";
             Icon = Constants.Icons.PropertyEditor;
             Group = "common";
         }
@@ -33,7 +33,7 @@ namespace Umbraco.Core.PropertyEditors
             Name = name;
 
             //defaults
-            ValueType = PropertyEditorValueTypes.String;
+            ValueType = "string";
             Icon = Constants.Icons.PropertyEditor;
             Group = "common";
         }

src/Umbraco.Core/PropertyEditors/PropertyEditorValueTypes.cs

@@ -1,34 +0,0 @@
-using System;
-
-namespace Umbraco.Core.PropertyEditors
-{
-    public static class PropertyEditorValueTypes
-    {
-        // mapped to DataTypeDatabaseType in DataTypeService.OverrideDatabaseTypeIfProvidedInPreValues
-        // BUT what about those that are not mapped?
-        //
-        // also mapped to DataTypeDatabaseType in PropertyValueEditor
-        // and this time the "+" are mapped
-
-        public const string Date = "DATE"; // +Date
-
-        public const string DateTime = "DATETIME"; // Date
-
-        public const string Decimal = "DECIMAL"; // Decimal
-
-        public const string Integer = "INT"; // Integer
-
-        [Obsolete("Use Integer.", false)]
-        public const string IntegerAlternative = "INTEGER"; // +Integer
-
-        public const string Json = "JSON"; // +NText
-
-        public const string Text = "TEXT"; // NText
-
-        public const string Time = "TIME"; // +Date
-
-        public const string String = "STRING"; // NVarchar
-
-        public const string Xml = "XML"; // +NText
-    }
-}

src/Umbraco.Core/PropertyEditors/PropertyValueEditor.cs

@@ -25,7 +25,7 @@ namespace Umbraco.Core.PropertyEditors
         /// </summary>
         public PropertyValueEditor()
         {
-            ValueType = PropertyEditorValueTypes.String;
+            ValueType = "string";
             //set a default for validators
             Validators = new List<IPropertyValidator>();
         }
@@ -123,35 +123,30 @@ namespace Umbraco.Core.PropertyEditors
         }
 
         /// <summary>
-        /// Returns the true DataTypeDatabaseType from the string representation ValueType.
+        /// Returns the true DataTypeDatabaseType from the string representation ValueType
         /// </summary>
         /// <returns></returns>
         public DataTypeDatabaseType GetDatabaseType()
         {
-            return GetDatabaseType(ValueType);
-        }
-
-        public static DataTypeDatabaseType GetDatabaseType(string valueType)
-        {
-            switch (valueType.ToUpperInvariant())
+            switch (ValueType.ToUpper(CultureInfo.InvariantCulture))
             {
-                case PropertyEditorValueTypes.Integer:
-                case PropertyEditorValueTypes.IntegerAlternative:
+                case "INT":
+                case "INTEGER":
                     return DataTypeDatabaseType.Integer;
-                case PropertyEditorValueTypes.Decimal:
+                case "DECIMAL":
                     return DataTypeDatabaseType.Decimal;
-                case PropertyEditorValueTypes.String:
+                case "STRING":
                     return DataTypeDatabaseType.Nvarchar;
-                case PropertyEditorValueTypes.Text:
-                case PropertyEditorValueTypes.Json:
-                case PropertyEditorValueTypes.Xml:
+                case "TEXT":
+                case "JSON":
+                case "XML":
                     return DataTypeDatabaseType.Ntext;
-                case PropertyEditorValueTypes.DateTime:
-                case PropertyEditorValueTypes.Date:
-                case PropertyEditorValueTypes.Time:
+                case "DATETIME":
+                case "DATE":
+                case "TIME":
                     return DataTypeDatabaseType.Date;
                 default:
-                    throw new ArgumentException("Not a valid value type.", "valueType");
+                    throw new FormatException("The ValueType does not match a known value type");
             }
         }
 
@@ -243,7 +238,7 @@ namespace Umbraco.Core.PropertyEditors
         public virtual object ConvertEditorToDb(ContentPropertyData editorValue, object currentValue)
         {
             //if it's json but it's empty json, then return null
-            if (ValueType.InvariantEquals(PropertyEditorValueTypes.Json) && editorValue.Value != null && editorValue.Value.ToString().DetectIsEmptyJson())
+            if (ValueType.InvariantEquals("JSON") && editorValue.Value != null && editorValue.Value.ToString().DetectIsEmptyJson())
             {
                 return null;
             }

src/Umbraco.Core/PropertyEditors/RequiredManifestValueValidator.cs

@@ -22,7 +22,7 @@ namespace Umbraco.Core.PropertyEditors
             {
                 var asString = value.ToString();
 
-                if (editor.ValueEditor.ValueType.InvariantEquals(PropertyEditorValueTypes.Json))
+                if (editor.ValueEditor.ValueType.InvariantEquals("JSON"))
                 {
                     if (asString.DetectIsEmptyJson())
                     {

src/Umbraco.Core/PropertyEditors/ValueConverters/DecimalValueConverter.cs

@@ -1,5 +1,4 @@
-using System.Globalization;
-using Umbraco.Core.Models.PublishedContent;
+using Umbraco.Core.Models.PublishedContent;
 
 namespace Umbraco.Core.PropertyEditors.ValueConverters
 {
@@ -21,7 +20,7 @@ namespace Umbraco.Core.PropertyEditors.ValueConverters
             if (sourceString != null)
             {
                 decimal d;
-                return (decimal.TryParse(sourceString, NumberStyles.AllowDecimalPoint, CultureInfo.InvariantCulture,  out d)) ? d : 0M;
+                return (decimal.TryParse(sourceString, out d)) ? d : 0M;
             }
 
             // in the database an a decimal is an a decimal 

src/Umbraco.Core/PropertyEditors/ValueConverters/JsonValueConverter.cs

@@ -26,7 +26,7 @@ namespace Umbraco.Core.PropertyEditors.ValueConverters
         {
             var propertyEditor = PropertyEditorResolver.Current.GetByAlias(propertyType.PropertyEditorAlias);
             if (propertyEditor == null) return false;
-            return propertyEditor.ValueEditor.ValueType.InvariantEquals(PropertyEditorValueTypes.Json);
+            return propertyEditor.ValueEditor.ValueType.InvariantEquals("json");
         }
 
         public override object ConvertDataToSource(PublishedPropertyType propertyType, object source, bool preview)

src/Umbraco.Core/PropertyEditors/ValueConverters/MultipleTextStringValueConverter.cs

@@ -35,9 +35,6 @@ namespace Umbraco.Core.PropertyEditors.ValueConverters
             // as xml in the database, it's always been new line delimited. Will ask Stephen about this.
             // In the meantime, we'll do this xml check, see if it parses and if not just continue with 
             // splitting by newline
-            //
-            //   RS: SD/Stephan Please consider post before deciding to remove 
-            //// https://our.umbraco.org/forum/contributing-to-umbraco-cms/76989-keep-the-xml-values-in-the-multipletextstringvalueconverter
             var values = new List<string>();
             var pos = sourceString.IndexOf("<value>", StringComparison.Ordinal);
             while (pos >= 0)

src/Umbraco.Core/Security/AuthenticationExtensions.cs

@@ -103,18 +103,10 @@ namespace Umbraco.Core.Security
             var backOfficeIdentity = http.User.Identity as UmbracoBackOfficeIdentity;
             if (backOfficeIdentity != null) return backOfficeIdentity;
 
-            //Check if there's more than one identity assigned and see if it's a UmbracoBackOfficeIdentity and use that
-            var claimsPrincipal = http.User as ClaimsPrincipal;
-            if (claimsPrincipal != null)
-            {
-                backOfficeIdentity = claimsPrincipal.Identities.OfType<UmbracoBackOfficeIdentity>().FirstOrDefault();
-                if (backOfficeIdentity != null) return backOfficeIdentity;
-            }
-
             //Otherwise convert to a UmbracoBackOfficeIdentity if it's auth'd and has the back office session            
             var claimsIdentity = http.User.Identity as ClaimsIdentity;
             if (claimsIdentity != null && claimsIdentity.IsAuthenticated)
-            {                
+            {
                 try
                 {
                     return UmbracoBackOfficeIdentity.FromClaimsIdentity(claimsIdentity);

src/Umbraco.Core/Security/BackOfficeUserManager.cs

@@ -118,8 +118,6 @@ namespace Umbraco.Core.Security
             //custom identity factory for creating the identity object for which we auth against in the back office
             manager.ClaimsIdentityFactory = new BackOfficeClaimsIdentityFactory();
 
-            manager.EmailService = new EmailService();
-
             //NOTE: Not implementing these, if people need custom 2 factor auth, they'll need to implement their own UserStore to suport it
 
             //// Register two factor authentication providers. This application uses Phone and Emails as a step of receiving a code for verifying the user
@@ -134,6 +132,7 @@ namespace Umbraco.Core.Security
             //    BodyFormat = "Your security code is: {0}"
             //});
 
+            //manager.EmailService = new EmailService();
             //manager.SmsService = new SmsService();            
         }
 

src/Umbraco.Core/Security/EmailService.cs

@@ -1,26 +0,0 @@
-using System.Net.Mail;
-using System.Threading.Tasks;
-using Microsoft.AspNet.Identity;
-
-namespace Umbraco.Core.Security
-{
-    public class EmailService : IIdentityMessageService
-    {
-        public async Task SendAsync(IdentityMessage message)
-        {
-            using (var client = new SmtpClient())
-            using (var mailMessage = new MailMessage())
-            {
-                mailMessage.Body = message.Body;
-                mailMessage.To.Add(message.Destination);
-                mailMessage.Subject = message.Subject;
-
-                //TODO: This check could be nicer but that is the way it is currently
-                mailMessage.IsBodyHtml = message.Body.IsNullOrWhiteSpace() == false 
-                    && message.Body.Contains("<") && message.Body.Contains("/>");
-
-                await client.SendMailAsync(mailMessage);
-            }
-        }
-    }
-}

src/Umbraco.Core/Services/ContentService.cs

@@ -231,7 +231,7 @@ namespace Umbraco.Core.Services
         public IContent CreateContentWithIdentity(string name, int parentId, string contentTypeAlias, int userId = 0)
         {
             var contentType = FindContentTypeByAlias(contentTypeAlias);
-            var content = new Content(name, parentId, contentType);
+            var content = new Content(name, parentId, contentType);            
 
             //NOTE: I really hate the notion of these Creating/Created events - they are so inconsistent, I've only just found
             // out that in these 'WithIdentity' methods, the Saving/Saved events were not fired, wtf. Anyways, they're added now.
@@ -487,10 +487,22 @@ namespace Umbraco.Core.Services
         public IEnumerable<IContent> GetPagedChildren(int id, int pageIndex, int pageSize, out int totalChildren,
             string orderBy, Direction orderDirection, string filter = "")
         {
-            long total;
-            var result = GetPagedChildren(id, Convert.ToInt64(pageIndex), pageSize, out total, orderBy, orderDirection, true, filter);
-            totalChildren = Convert.ToInt32(total);
-            return result;
+            Mandate.ParameterCondition(pageIndex >= 0, "pageIndex");
+            Mandate.ParameterCondition(pageSize > 0, "pageSize");
+            using (var repository = RepositoryFactory.CreateContentRepository(UowProvider.GetUnitOfWork()))
+            {
+
+                var query = Query<IContent>.Builder;
+                //if the id is System Root, then just get all
+                if (id != Constants.System.Root)
+                {
+                    query.Where(x => x.ParentId == id);
+                }
+                long total;
+                var contents = repository.GetPagedResultsByQuery(query, pageIndex, pageSize, out total, orderBy, orderDirection, filter);
+                totalChildren = Convert.ToInt32(total);
+                return contents;
+            }
         }
 
         /// <summary>
@@ -506,24 +518,6 @@ namespace Umbraco.Core.Services
         /// <returns>An Enumerable list of <see cref="IContent"/> objects</returns>
         public IEnumerable<IContent> GetPagedChildren(int id, long pageIndex, int pageSize, out long totalChildren,
             string orderBy, Direction orderDirection, string filter = "")
-        {
-            return GetPagedChildren(id, pageIndex, pageSize, out totalChildren, orderBy, orderDirection, true, filter);
-        }
-
-        /// <summary>
-        /// Gets a collection of <see cref="IContent"/> objects by Parent Id
-        /// </summary>
-        /// <param name="id">Id of the Parent to retrieve Children from</param>
-        /// <param name="pageIndex">Page index (zero based)</param>
-        /// <param name="pageSize">Page size</param>
-        /// <param name="totalChildren">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> GetPagedChildren(int id, long pageIndex, int pageSize, out long totalChildren,
-            string orderBy, Direction orderDirection, bool orderBySystemField, string filter)
         {
             Mandate.ParameterCondition(pageIndex >= 0, "pageIndex");
             Mandate.ParameterCondition(pageSize > 0, "pageSize");
@@ -536,7 +530,7 @@ namespace Umbraco.Core.Services
                 {
                     query.Where(x => x.ParentId == id);
                 }
-                var contents = repository.GetPagedResultsByQuery(query, pageIndex, pageSize, out totalChildren, orderBy, orderDirection, orderBySystemField, filter);
+                var contents = repository.GetPagedResultsByQuery(query, pageIndex, pageSize, out totalChildren, orderBy, orderDirection, filter);
 
                 return contents;
             }
@@ -545,42 +539,6 @@ namespace Umbraco.Core.Services
         [Obsolete("Use the overload with 'long' parameter types instead")]
         [EditorBrowsable(EditorBrowsableState.Never)]
         public IEnumerable<IContent> GetPagedDescendants(int id, int pageIndex, int pageSize, out int totalChildren, string orderBy = "Path", Direction orderDirection = Direction.Ascending, string filter = "")
-        {
-            long total;
-            var result = GetPagedDescendants(id, Convert.ToInt64(pageIndex), pageSize, out total, orderBy, orderDirection, true, filter);
-            totalChildren = Convert.ToInt32(total);
-            return result;
-        }
-
-        /// <summary>
-        /// Gets a collection of <see cref="IContent"/> objects by Parent Id
-        /// </summary>
-        /// <param name="id">Id of the Parent to retrieve Descendants from</param>
-        /// <param name="pageIndex">Page number</param>
-        /// <param name="pageSize">Page size</param>
-        /// <param name="totalChildren">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="filter">Search text filter</param>
-        /// <returns>An Enumerable list of <see cref="IContent"/> objects</returns> 
-        public IEnumerable<IContent> GetPagedDescendants(int id, long pageIndex, int pageSize, out long totalChildren, string orderBy = "Path", Direction orderDirection = Direction.Ascending, string filter = "")
-        {
-            return GetPagedDescendants(id, pageIndex, pageSize, out totalChildren, orderBy, orderDirection, true, filter);
-        }
-
-        /// <summary>
-        /// Gets a collection of <see cref="IContent"/> objects by Parent Id
-        /// </summary>
-        /// <param name="id">Id of the Parent to retrieve Descendants from</param>
-        /// <param name="pageIndex">Page number</param>
-        /// <param name="pageSize">Page size</param>
-        /// <param name="totalChildren">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> GetPagedDescendants(int id, long pageIndex, int pageSize, out long totalChildren, string orderBy, Direction orderDirection, bool orderBySystemField, string filter)
         {
             Mandate.ParameterCondition(pageIndex >= 0, "pageIndex");
             Mandate.ParameterCondition(pageSize > 0, "pageSize");
@@ -593,7 +551,38 @@ namespace Umbraco.Core.Services
                 {
                     query.Where(x => x.Path.SqlContains(string.Format(",{0},", id), TextColumnType.NVarchar));
                 }
-                var contents = repository.GetPagedResultsByQuery(query, pageIndex, pageSize, out totalChildren, orderBy, orderDirection, orderBySystemField, filter);
+                long total;
+                var contents = repository.GetPagedResultsByQuery(query, pageIndex, pageSize, out total, orderBy, orderDirection, filter);
+                totalChildren = Convert.ToInt32(total);
+                return contents;
+            }
+        }
+
+        /// <summary>
+        /// Gets a collection of <see cref="IContent"/> objects by Parent Id
+        /// </summary>
+        /// <param name="id">Id of the Parent to retrieve Descendants from</param>
+        /// <param name="pageIndex">Page number</param>
+        /// <param name="pageSize">Page size</param>
+        /// <param name="totalChildren">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="filter">Search text filter</param>
+        /// <returns>An Enumerable list of <see cref="IContent"/> objects</returns>
+        public IEnumerable<IContent> GetPagedDescendants(int id, long pageIndex, int pageSize, out long totalChildren, string orderBy = "Path", Direction orderDirection = Direction.Ascending, string filter = "")
+        {
+            Mandate.ParameterCondition(pageIndex >= 0, "pageIndex");
+            Mandate.ParameterCondition(pageSize > 0, "pageSize");
+            using (var repository = RepositoryFactory.CreateContentRepository(UowProvider.GetUnitOfWork()))
+            {
+
+                var query = Query<IContent>.Builder;
+                //if the id is System Root, then just get all
+                if (id != Constants.System.Root)
+                {
+                    query.Where(x => x.Path.SqlContains(string.Format(",{0},", id), TextColumnType.NVarchar));
+                }
+                var contents = repository.GetPagedResultsByQuery(query, pageIndex, pageSize, out totalChildren, orderBy, orderDirection, filter);
 
                 return contents;
             }
@@ -917,7 +906,7 @@ namespace Umbraco.Core.Services
             {
                 var originalPath = content.Path;
 
-                if (Trashing.IsRaisedEventCancelled(
+                if (Trashing.IsRaisedEventCancelled(                  
                   new MoveEventArgs<IContent>(evtMsgs, new MoveEventInfo<IContent>(content, originalPath, Constants.System.RecycleBinContent)),
                   this))
                 {
@@ -1033,7 +1022,7 @@ namespace Umbraco.Core.Services
         /// <returns>True if unpublishing succeeded, otherwise False</returns>
         public bool UnPublish(IContent content, int userId = 0)
         {
-            return ((IContentServiceOperations)this).UnPublish(content, userId).Success;
+            return ((IContentServiceOperations) this).UnPublish(content, userId).Success;
         }
 
         /// <summary>
@@ -1154,7 +1143,7 @@ namespace Umbraco.Core.Services
 
             using (new WriteLock(Locker))
             {
-                if (Deleting.IsRaisedEventCancelled(
+                if (Deleting.IsRaisedEventCancelled(                  
                   new DeleteEventArgs<IContent>(content, evtMsgs),
                   this))
                 {
@@ -1179,10 +1168,10 @@ namespace Umbraco.Core.Services
                 {
                     repository.Delete(content);
                     uow.Commit();
-
+                    
                     var args = new DeleteEventArgs<IContent>(content, false, evtMsgs);
                     Deleted.RaiseEvent(args, this);
-
+                    
                     //remove any flagged media files
                     repository.DeleteMediaFiles(args.MediaFilesToDelete);
                 }
@@ -1361,7 +1350,7 @@ namespace Umbraco.Core.Services
         /// <param name="userId">Optional Id of the User deleting the Content</param>
         public void MoveToRecycleBin(IContent content, int userId = 0)
         {
-            ((IContentServiceOperations)this).MoveToRecycleBin(content, userId);
+            ((IContentServiceOperations) this).MoveToRecycleBin(content, userId);
         }
 
         /// <summary>
@@ -1665,7 +1654,7 @@ namespace Umbraco.Core.Services
                 //TODO: This should not be an inner operation, but if we do this, it cannot raise events and cannot be cancellable!
                 _publishingStrategy.PublishingFinalized(shouldBePublished, false);
             }
-
+            
 
             Audit(AuditType.Sort, "Sorting content performed by user", userId, 0);
 
@@ -1913,13 +1902,13 @@ namespace Umbraco.Core.Services
                 content = newest;
 
             var evtMsgs = EventMessagesFactory.Get();
-
+               
             var published = content.Published ? content : GetPublishedVersion(content.Id); // get the published version
             if (published == null)
             {
                 return Attempt.Succeed(new UnPublishStatus(content, UnPublishedStatusType.SuccessAlreadyUnPublished, evtMsgs)); // already unpublished
             }
-
+            
             var unpublished = _publishingStrategy.UnPublish(content, userId);
             if (unpublished == false) return Attempt.Fail(new UnPublishStatus(content, UnPublishedStatusType.FailedCancelledByEvent, evtMsgs));
 
@@ -2057,7 +2046,7 @@ namespace Umbraco.Core.Services
 
             if (raiseEvents)
             {
-                if (Saving.IsRaisedEventCancelled(
+                if (Saving.IsRaisedEventCancelled(                  
                   new SaveEventArgs<IContent>(content, evtMsgs),
                   this))
                 {

src/Umbraco.Core/Services/ContentTypeService.cs

@@ -794,7 +794,7 @@ namespace Umbraco.Core.Services
 
                 //TODO: This needs to change, if we are deleting a content type, we should just delete the data,
                 // this method will recursively go lookup every content item, check if any of it's descendants are
-                // of a different type, move them to the recycle bin, then permanently delete the content items.
+                // of a different type, move them to the recycle bin, then permanently delete the content items. 
                 // The main problem with this is that for every content item being deleted, events are raised...
                 // which we need for many things like keeping caches in sync, but we can surely do this MUCH better.
 
@@ -1067,92 +1067,6 @@ namespace Umbraco.Core.Services
                 new OperationStatus<MoveOperationStatusType>(MoveOperationStatusType.Success, evtMsgs));
         }
 
-        public Attempt<OperationStatus<IMediaType, MoveOperationStatusType>> CopyMediaType(IMediaType toCopy, int containerId)
-        {
-            var evtMsgs = EventMessagesFactory.Get();
-
-            IMediaType copy;
-            var uow = UowProvider.GetUnitOfWork();
-            using (var containerRepository = RepositoryFactory.CreateEntityContainerRepository(uow, Constants.ObjectTypes.MediaTypeContainerGuid))
-            using (var repository = RepositoryFactory.CreateMediaTypeRepository(uow))
-            {
-                try
-                {
-                    if (containerId > 0)
-                    {
-                        var container = containerRepository.Get(containerId);
-                        if (container == null)
-                            throw new DataOperationException<MoveOperationStatusType>(MoveOperationStatusType.FailedParentNotFound);
-                    }
-                    var alias = repository.GetUniqueAlias(toCopy.Alias);
-                    copy = toCopy.DeepCloneWithResetIdentities(alias);
-                    copy.Name = copy.Name + " (copy)"; // might not be unique
-
-                    // if it has a parent, and the parent is a content type, unplug composition
-                    // all other compositions remain in place in the copied content type
-                    if (copy.ParentId > 0)
-                    {
-                        var parent = repository.Get(copy.ParentId);
-                        if (parent != null)
-                            copy.RemoveContentType(parent.Alias);
-                    }
-
-                    copy.ParentId = containerId;
-                    repository.AddOrUpdate(copy);
-                }
-                catch (DataOperationException<MoveOperationStatusType> ex)
-                {
-                    return Attempt.Fail(new OperationStatus<IMediaType, MoveOperationStatusType>(null, ex.Operation, evtMsgs));
-                }
-                uow.Commit();
-            }
-
-            return Attempt.Succeed(new OperationStatus<IMediaType, MoveOperationStatusType>(copy, MoveOperationStatusType.Success, evtMsgs));
-        }
-
-        public Attempt<OperationStatus<IContentType, MoveOperationStatusType>> CopyContentType(IContentType toCopy, int containerId)
-        {
-            var evtMsgs = EventMessagesFactory.Get();
-
-            IContentType copy;
-            var uow = UowProvider.GetUnitOfWork();
-            using (var containerRepository = RepositoryFactory.CreateEntityContainerRepository(uow, Constants.ObjectTypes.DocumentTypeContainerGuid))
-            using (var repository = RepositoryFactory.CreateContentTypeRepository(uow))
-            {
-                try
-                {
-                    if (containerId > 0)
-                    {
-                        var container = containerRepository.Get(containerId);
-                        if (container == null)
-                            throw new DataOperationException<MoveOperationStatusType>(MoveOperationStatusType.FailedParentNotFound);
-                    }
-                    var alias = repository.GetUniqueAlias(toCopy.Alias);
-                    copy = toCopy.DeepCloneWithResetIdentities(alias);
-                    copy.Name = copy.Name + " (copy)"; // might not be unique
-
-                    // if it has a parent, and the parent is a content type, unplug composition
-                    // all other compositions remain in place in the copied content type
-                    if (copy.ParentId > 0)
-                    {
-                        var parent = repository.Get(copy.ParentId);
-                        if (parent != null)
-                            copy.RemoveContentType(parent.Alias);
-                    }
-
-                    copy.ParentId = containerId;
-                    repository.AddOrUpdate(copy);
-                }
-                catch (DataOperationException<MoveOperationStatusType> ex)
-                {
-                    return Attempt.Fail(new OperationStatus<IContentType, MoveOperationStatusType>(null, ex.Operation, evtMsgs));
-                }
-                uow.Commit();
-            }
-
-            return Attempt.Succeed(new OperationStatus<IContentType, MoveOperationStatusType>(copy, MoveOperationStatusType.Success, evtMsgs));
-        }
-
         /// <summary>
         /// Saves a single <see cref="IMediaType"/> object
         /// </summary>

src/Umbraco.Core/Services/DataTypeService.cs

@@ -504,10 +504,6 @@ namespace Umbraco.Core.Services
             if (Saving.IsRaisedEventCancelled(new SaveEventArgs<IDataTypeDefinition>(dataTypeDefinition), this))
                 return;
 
-            // if preValues contain the data type, override the data type definition accordingly
-            if (values != null && values.ContainsKey(Constants.PropertyEditors.PreValueKeys.DataValueType))
-                dataTypeDefinition.DatabaseType = PropertyValueEditor.GetDatabaseType(values[Constants.PropertyEditors.PreValueKeys.DataValueType].Value);
-
             var uow = UowProvider.GetUnitOfWork();
             using (var repository = RepositoryFactory.CreateDataTypeDefinitionRepository(uow))
             {
@@ -527,6 +523,7 @@ namespace Umbraco.Core.Services
             Audit(AuditType.Save, string.Format("Save DataTypeDefinition performed by user"), userId, dataTypeDefinition.Id);
         }
 
+
         /// <summary>
         /// Deletes an <see cref="IDataTypeDefinition"/>
         /// </summary>

src/Umbraco.Core/Services/EntityXmlSerializer.cs

@@ -267,15 +267,11 @@ namespace Umbraco.Core.Services
                 structure.Add(new XElement("MediaType", allowedType.Alias));
             }
 
-            var genericProperties = new XElement("GenericProperties"); // actually, all of them
+            var genericProperties = new XElement("GenericProperties");
             foreach (var propertyType in mediaType.PropertyTypes)
             {
                 var definition = dataTypeService.GetDataTypeDefinitionById(propertyType.DataTypeDefinitionId);
-
-                var propertyGroup = propertyType.PropertyGroupId == null // true generic property
-                    ? null
-                    : mediaType.PropertyGroups.FirstOrDefault(x => x.Id == propertyType.PropertyGroupId.Value);
-
+                var propertyGroup = mediaType.PropertyGroups.FirstOrDefault(x => x.Id == propertyType.PropertyGroupId.Value);
                 var genericProperty = new XElement("GenericProperty",
                                                    new XElement("Name", propertyType.Name),
                                                    new XElement("Alias", propertyType.Alias),
@@ -385,14 +381,14 @@ namespace Umbraco.Core.Services
                 structure.Add(new XElement("DocumentType", allowedType.Alias));
             }
 
-            var genericProperties = new XElement("GenericProperties"); // actually, all of them
+            var genericProperties = new XElement("GenericProperties");
             foreach (var propertyType in contentType.PropertyTypes)
             {
                 var definition = dataTypeService.GetDataTypeDefinitionById(propertyType.DataTypeDefinitionId);
 
-                var propertyGroup = propertyType.PropertyGroupId == null // true generic property
-                    ? null
-                    : contentType.PropertyGroups.FirstOrDefault(x => x.Id == propertyType.PropertyGroupId.Value);
+                var propertyGroup = propertyType.PropertyGroupId == null
+                                                ? null
+                                                : contentType.PropertyGroups.FirstOrDefault(x => x.Id == propertyType.PropertyGroupId.Value);
 
                 var genericProperty = new XElement("GenericProperty",
                                                    new XElement("Name", propertyType.Name),

src/Umbraco.Core/Services/IContentService.cs

@@ -219,21 +219,6 @@ namespace Umbraco.Core.Services
         IEnumerable<IContent> GetPagedChildren(int id, long pageIndex, int pageSize, out long totalRecords,
             string orderBy = "SortOrder", Direction orderDirection = Direction.Ascending, string filter = "");
 
-        /// <summary>
-        /// Gets a collection of <see cref="IContent"/> objects by Parent Id
-        /// </summary>
-        /// <param name="id">Id of the Parent to retrieve Children from</param>
-        /// <param name="pageIndex">Page number</param>
-        /// <param name="pageSize">Page size</param>
-        /// <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> GetPagedChildren(int id, long pageIndex, int pageSize, out long totalRecords,
-            string orderBy, Direction orderDirection, bool orderBySystemField, string filter);
-
         [Obsolete("Use the overload with 'long' parameter types instead")]
         [EditorBrowsable(EditorBrowsableState.Never)]
         IEnumerable<IContent> GetPagedDescendants(int id, int pageIndex, int pageSize, out int totalRecords,
@@ -252,22 +237,7 @@ namespace Umbraco.Core.Services
         /// <returns>An Enumerable list of <see cref="IContent"/> objects</returns>
         IEnumerable<IContent> GetPagedDescendants(int id, long pageIndex, int pageSize, out long totalRecords,
             string orderBy = "Path", Direction orderDirection = Direction.Ascending, string filter = "");
-
-        /// <summary>
-        /// Gets a collection of <see cref="IContent"/> objects by Parent Id
-        /// </summary>
-        /// <param name="id">Id of the Parent to retrieve Descendants from</param>
-        /// <param name="pageIndex">Page number</param>
-        /// <param name="pageSize">Page size</param>
-        /// <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> GetPagedDescendants(int id, long pageIndex, int pageSize, out long totalRecords,
-            string orderBy, Direction orderDirection, bool orderBySystemField, string filter);
-
+        
         /// <summary>
         /// Gets a collection of an <see cref="IContent"/> objects versions by its Id
         /// </summary>
@@ -298,7 +268,7 @@ namespace Umbraco.Core.Services
         /// </summary>
         /// <returns>An Enumerable list of <see cref="IContent"/> objects</returns>
         IEnumerable<IContent> GetContentInRecycleBin();
-
+        
         /// <summary>
         /// Saves a single <see cref="IContent"/> object
         /// </summary>
@@ -497,7 +467,7 @@ namespace Umbraco.Core.Services
         /// <param name="raiseEvents">Optional boolean indicating whether or not to raise save events.</param>
         /// <returns>True if publishing succeeded, otherwise False</returns>
         Attempt<PublishStatus> SaveAndPublishWithStatus(IContent content, int userId = 0, bool raiseEvents = true);
-
+        
         /// <summary>
         /// Permanently deletes an <see cref="IContent"/> object.
         /// </summary>

src/Umbraco.Core/Services/IContentTypeService.cs

@@ -291,7 +291,5 @@ namespace Umbraco.Core.Services
 
         Attempt<OperationStatus<MoveOperationStatusType>> MoveMediaType(IMediaType toMove, int containerId);
         Attempt<OperationStatus<MoveOperationStatusType>> MoveContentType(IContentType toMove, int containerId);
-        Attempt<OperationStatus<IMediaType, MoveOperationStatusType>> CopyMediaType(IMediaType toCopy, int containerId);
-        Attempt<OperationStatus<IContentType, MoveOperationStatusType>> CopyContentType(IContentType toCopy, int containerId);
     }
 }

src/Umbraco.Core/Services/IMediaService.cs

@@ -137,21 +137,6 @@ namespace Umbraco.Core.Services
         IEnumerable<IMedia> GetPagedChildren(int id, long pageIndex, int pageSize, out long totalRecords,
             string orderBy = "SortOrder", Direction orderDirection = Direction.Ascending, string filter = "");
 
-        /// <summary>
-        /// Gets a collection of <see cref="IMedia"/> objects by Parent Id
-        /// </summary>
-        /// <param name="id">Id of the Parent to retrieve Children from</param>
-        /// <param name="pageIndex">Page number</param>
-        /// <param name="pageSize">Page size</param>
-        /// <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<IMedia> GetPagedChildren(int id, long pageIndex, int pageSize, out long totalRecords,
-            string orderBy, Direction orderDirection, bool orderBySystemField, string filter);
-
         [Obsolete("Use the overload with 'long' parameter types instead")]
         [EditorBrowsable(EditorBrowsableState.Never)]
         IEnumerable<IMedia> GetPagedDescendants(int id, int pageIndex, int pageSize, out int totalRecords,
@@ -171,21 +156,6 @@ namespace Umbraco.Core.Services
         IEnumerable<IMedia> GetPagedDescendants(int id, long pageIndex, int pageSize, out long totalRecords,
             string orderBy = "Path", Direction orderDirection = Direction.Ascending, string filter = "");
 
-        /// <summary>
-        /// Gets a collection of <see cref="IMedia"/> objects by Parent Id
-        /// </summary>
-        /// <param name="id">Id of the Parent to retrieve Descendants from</param>
-        /// <param name="pageIndex">Page number</param>
-        /// <param name="pageSize">Page size</param>
-        /// <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<IMedia> GetPagedDescendants(int id, long pageIndex, int pageSize, out long totalRecords,
-            string orderBy, Direction orderDirection, bool orderBySystemField, string filter);
-
         /// <summary>
         /// Gets descendants of a <see cref="IMedia"/> object by its Id
         /// </summary>
@@ -250,7 +220,7 @@ namespace Umbraco.Core.Services
         /// <param name="media">The <see cref="IMedia"/> to delete</param>
         /// <param name="userId">Id of the User deleting the Media</param>
         void Delete(IMedia media, int userId = 0);
-
+        
         /// <summary>
         /// Saves a single <see cref="IMedia"/> object
         /// </summary>

src/Umbraco.Core/Services/IMemberService.cs

@@ -34,30 +34,14 @@ namespace Umbraco.Core.Services
         /// <param name="pageIndex">Current page index</param>
         /// <param name="pageSize">Size of the page</param>
         /// <param name="totalRecords">Total number of records found (out)</param>
-        /// <param name="orderBy">Field to order by</param>
-        /// <param name="orderDirection">Direction to order by</param>
+        /// <param name="orderBy"></param>
+        /// <param name="orderDirection"></param>
         /// <param name="memberTypeAlias"></param>
-        /// <param name="filter">Search text filter</param>
+        /// <param name="filter"></param>
         /// <returns><see cref="IEnumerable{T}"/></returns>
         IEnumerable<IMember> GetAll(long pageIndex, int pageSize, out long totalRecords,
             string orderBy, Direction orderDirection, string memberTypeAlias = null, string filter = "");
-
-        /// <summary>
-        /// Gets a list of paged <see cref="IMember"/> objects
-        /// </summary>
-        /// <remarks>An <see cref="IMember"/> can be of type <see cref="IMember"/> </remarks>
-        /// <param name="pageIndex">Current page index</param>
-        /// <param name="pageSize">Size of the page</param>
-        /// <param name="totalRecords">Total number of records found (out)</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="memberTypeAlias"></param>
-        /// <param name="filter">Search text filter</param>
-        /// <returns><see cref="IEnumerable{T}"/></returns>
-        IEnumerable<IMember> GetAll(long pageIndex, int pageSize, out long totalRecords,
-            string orderBy, Direction orderDirection, bool orderBySystemField, string memberTypeAlias, string filter);
-
+        
         /// <summary>
         /// Creates an <see cref="IMember"/> object without persisting it
         /// </summary>
@@ -107,7 +91,7 @@ namespace Umbraco.Core.Services
         /// <param name="memberType">MemberType the Member should be based on</param>
         /// <returns><see cref="IMember"/></returns>
         IMember CreateMemberWithIdentity(string username, string email, string name, IMemberType memberType);
-
+        
         /// <summary>
         /// This is simply a helper method which essentially just wraps the MembershipProvider's ChangePassword method
         /// </summary>
@@ -131,7 +115,7 @@ namespace Umbraco.Core.Services
         /// <param name="id">Id of the Member</param>
         /// <returns><c>True</c> if the Member exists otherwise <c>False</c></returns>
         bool Exists(int id);
-
+        
         /// <summary>
         /// Gets a Member by the unique key
         /// </summary>
@@ -176,7 +160,7 @@ namespace Umbraco.Core.Services
         /// <param name="ids">Optional list of Member Ids</param>
         /// <returns><see cref="IEnumerable{IMember}"/></returns>
         IEnumerable<IMember> GetAllMembers(params int[] ids);
-
+        
         /// <summary>
         /// Delete Members of the specified MemberType id
         /// </summary>

src/Umbraco.Core/Services/IRedirectUrlService.cs

@@ -1,26 +0,0 @@
-using System.Collections.Generic;
-using Umbraco.Core.Models;
-
-namespace Umbraco.Core.Services
-{
-    public interface IRedirectUrlService : IService
-    {
-        void Register(string url, int contentId);
-
-        void DeleteContentRedirectUrls(int contentId);
-
-        void Delete(IRedirectUrl redirectUrl);
-
-        void Delete(int id);
-
-        void DeleteAll();
-
-        IRedirectUrl GetMostRecentRedirectUrl(string url);
-
-        IEnumerable<IRedirectUrl> GetContentRedirectUrls(int contentId);
-
-        IEnumerable<IRedirectUrl> GetAllRedirectUrls(long pageIndex, int pageSize, out long total);
-
-        IEnumerable<IRedirectUrl> GetAllRedirectUrls(int rootContentId, long pageIndex, int pageSize, out long total);
-    }
-}

src/Umbraco.Core/Services/MediaService.cs

@@ -35,7 +35,7 @@ namespace Umbraco.Core.Services
         private readonly EntityXmlSerializer _entitySerializer = new EntityXmlSerializer();
         private readonly IDataTypeService _dataTypeService;
         private readonly IUserService _userService;
-
+        
         public MediaService(IDatabaseUnitOfWorkProvider provider, RepositoryFactory repositoryFactory, ILogger logger, IEventMessagesFactory eventMessagesFactory, IDataTypeService dataTypeService, IUserService userService)
             : base(provider, repositoryFactory, logger, eventMessagesFactory)
         {
@@ -397,10 +397,19 @@ namespace Umbraco.Core.Services
         public IEnumerable<IMedia> GetPagedChildren(int id, int pageIndex, int pageSize, out int totalChildren,
             string orderBy, Direction orderDirection, string filter = "")
         {
-            long total;
-            var result = GetPagedChildren(id, Convert.ToInt64(pageIndex), pageSize, out total, orderBy, orderDirection, true, filter);
-            totalChildren = Convert.ToInt32(total);
-            return result;
+            Mandate.ParameterCondition(pageIndex >= 0, "pageIndex");
+            Mandate.ParameterCondition(pageSize > 0, "pageSize");
+            using (var repository = RepositoryFactory.CreateMediaRepository(UowProvider.GetUnitOfWork()))
+            {
+                var query = Query<IMedia>.Builder;
+                query.Where(x => x.ParentId == id);
+                
+                long total;
+                var medias = repository.GetPagedResultsByQuery(query, pageIndex, pageSize, out total, orderBy, orderDirection, filter);
+
+                totalChildren = Convert.ToInt32(total);
+                return medias;
+            }
         }
 
         /// <summary>
@@ -415,25 +424,7 @@ namespace Umbraco.Core.Services
         /// <param name="filter">Search text filter</param>
         /// <returns>An Enumerable list of <see cref="IContent"/> objects</returns>
         public IEnumerable<IMedia> GetPagedChildren(int id, long pageIndex, int pageSize, out long totalChildren,
-            string orderBy, Direction orderDirection, string filter = "")
-        {
-            return GetPagedChildren(id, pageIndex, pageSize, out totalChildren, orderBy, orderDirection, true, filter);
-        }
-
-        /// <summary>
-        /// Gets a collection of <see cref="IMedia"/> objects by Parent Id
-        /// </summary>
-        /// <param name="id">Id of the Parent to retrieve Children from</param>
-        /// <param name="pageIndex">Page index (zero based)</param>
-        /// <param name="pageSize">Page size</param>
-        /// <param name="totalChildren">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<IMedia> GetPagedChildren(int id, long pageIndex, int pageSize, out long totalChildren,
-            string orderBy, Direction orderDirection, bool orderBySystemField, string filter)
+           string orderBy, Direction orderDirection, string filter = "")
         {
             Mandate.ParameterCondition(pageIndex >= 0, "pageIndex");
             Mandate.ParameterCondition(pageSize > 0, "pageSize");
@@ -441,8 +432,8 @@ namespace Umbraco.Core.Services
             {
                 var query = Query<IMedia>.Builder;
                 query.Where(x => x.ParentId == id);
-
-                var medias = repository.GetPagedResultsByQuery(query, pageIndex, pageSize, out totalChildren, orderBy, orderDirection, orderBySystemField, filter);
+                
+                var medias = repository.GetPagedResultsByQuery(query, pageIndex, pageSize, out totalChildren, orderBy, orderDirection, filter);
 
                 return medias;
             }
@@ -452,10 +443,22 @@ namespace Umbraco.Core.Services
         [EditorBrowsable(EditorBrowsableState.Never)]
         public IEnumerable<IMedia> GetPagedDescendants(int id, int pageIndex, int pageSize, out int totalChildren, string orderBy = "Path", Direction orderDirection = Direction.Ascending, string filter = "")
         {
-            long total;
-            var result = GetPagedDescendants(id, Convert.ToInt64(pageIndex), pageSize, out total, orderBy, orderDirection, true, filter);
-            totalChildren = Convert.ToInt32(total);
-            return result;
+            Mandate.ParameterCondition(pageIndex >= 0, "pageIndex");
+            Mandate.ParameterCondition(pageSize > 0, "pageSize");
+            using (var repository = RepositoryFactory.CreateMediaRepository(UowProvider.GetUnitOfWork()))
+            {
+
+                var query = Query<IMedia>.Builder;
+                //if the id is -1, then just get all
+                if (id != -1)
+                {
+                    query.Where(x => x.Path.SqlContains(string.Format(",{0},", id), TextColumnType.NVarchar));
+                }
+                long total;
+                var contents = repository.GetPagedResultsByQuery(query, pageIndex, pageSize, out total, orderBy, orderDirection, filter);
+                totalChildren = Convert.ToInt32(total);
+                return contents;
+            }
         }
 
         /// <summary>
@@ -470,23 +473,6 @@ namespace Umbraco.Core.Services
         /// <param name="filter">Search text filter</param>
         /// <returns>An Enumerable list of <see cref="IContent"/> objects</returns>
         public IEnumerable<IMedia> GetPagedDescendants(int id, long pageIndex, int pageSize, out long totalChildren, string orderBy = "Path", Direction orderDirection = Direction.Ascending, string filter = "")
-        {
-            return GetPagedDescendants(id, pageIndex, pageSize, out totalChildren, orderBy, orderDirection, true, filter);
-        }
-
-        /// <summary>
-        /// Gets a collection of <see cref="IContent"/> objects by Parent Id
-        /// </summary>
-        /// <param name="id">Id of the Parent to retrieve Descendants from</param>
-        /// <param name="pageIndex">Page number</param>
-        /// <param name="pageSize">Page size</param>
-        /// <param name="totalChildren">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<IMedia> GetPagedDescendants(int id, long pageIndex, int pageSize, out long totalChildren, string orderBy, Direction orderDirection, bool orderBySystemField, string filter)
         {
             Mandate.ParameterCondition(pageIndex >= 0, "pageIndex");
             Mandate.ParameterCondition(pageSize > 0, "pageSize");
@@ -499,7 +485,7 @@ namespace Umbraco.Core.Services
                 {
                     query.Where(x => x.Path.SqlContains(string.Format(",{0},", id), TextColumnType.NVarchar));
                 }
-                var contents = repository.GetPagedResultsByQuery(query, pageIndex, pageSize, out totalChildren, orderBy, orderDirection, orderBySystemField, filter);
+                var contents = repository.GetPagedResultsByQuery(query, pageIndex, pageSize, out totalChildren, orderBy, orderDirection, filter);
 
                 return contents;
             }
@@ -741,7 +727,7 @@ namespace Umbraco.Core.Services
         /// <param name="userId">Id of the User deleting the Media</param>
         public void MoveToRecycleBin(IMedia media, int userId = 0)
         {
-            ((IMediaServiceOperations)this).MoveToRecycleBin(media, userId);
+            ((IMediaServiceOperations) this).MoveToRecycleBin(media, userId);
         }
 
         /// <summary>
@@ -758,7 +744,7 @@ namespace Umbraco.Core.Services
             //TODO: IT would be much nicer to mass delete all in one trans in the repo level!
             var evtMsgs = EventMessagesFactory.Get();
 
-            if (Deleting.IsRaisedEventCancelled(
+            if (Deleting.IsRaisedEventCancelled(                
                 new DeleteEventArgs<IMedia>(media, evtMsgs), this))
             {
                 return OperationStatus.Cancelled(evtMsgs);
@@ -1039,7 +1025,7 @@ namespace Umbraco.Core.Services
             ((IMediaServiceOperations)this).Delete(media, userId);
         }
 
-
+        
 
         /// <summary>
         /// Permanently deletes versions from an <see cref="IMedia"/> object prior to a specific date.
@@ -1095,7 +1081,7 @@ namespace Umbraco.Core.Services
 
             Audit(AuditType.Delete, "Delete Media by version performed by user", userId, -1);
         }
-
+    
         /// <summary>
         /// Saves a single <see cref="IMedia"/> object
         /// </summary>
@@ -1104,7 +1090,7 @@ namespace Umbraco.Core.Services
         /// <param name="raiseEvents">Optional boolean indicating whether or not to raise events.</param>
         public void Save(IMedia media, int userId = 0, bool raiseEvents = true)
         {
-            ((IMediaServiceOperations)this).Save(media, userId, raiseEvents);
+            ((IMediaServiceOperations)this).Save (media, userId, raiseEvents);
         }
 
         /// <summary>