From d152cf076fa8138b706367a14f9dd58c9c33bea6 Mon Sep 17 00:00:00 2001
From: Kenn Jacobsen <post@kennjacobsen.dk>
Date: Sat, 6 Jul 2019 08:32:04 +0200
Subject: [PATCH 01/14] Ensure correct icon for file types in search results

(cherry picked from commit e9eecb2031bc50f58d1d971ae58f2b12aad38ff8)
---
 src/Umbraco.Web/Search/UmbracoTreeSearcher.cs | 14 +-------------
 1 file changed, 1 insertion(+), 13 deletions(-)

diff --git a/src/Umbraco.Web/Search/UmbracoTreeSearcher.cs b/src/Umbraco.Web/Search/UmbracoTreeSearcher.cs
index 9cfa29985b..543499d054 100644
--- a/src/Umbraco.Web/Search/UmbracoTreeSearcher.cs
+++ b/src/Umbraco.Web/Search/UmbracoTreeSearcher.cs
@@ -301,19 +301,7 @@ namespace Umbraco.Web.Search
         /// <param name="results"></param>
         /// <returns></returns>
         private IEnumerable<SearchResultItem> MediaFromSearchResults(IEnumerable<SearchResult> results)
-        {
-            var mapped = Mapper.Map<IEnumerable<SearchResultItem>>(results).ToArray();
-            //add additional data
-            foreach (var m in mapped)
-            {
-                //if no icon could be mapped, it will be set to document, so change it to picture
-                if (m.Icon == "icon-document")
-                {
-                    m.Icon = "icon-picture";
-                }
-            }
-            return mapped;
-        }
+            => Mapper.Map<IEnumerable<SearchResultItem>>(results).ToArray();
 
         /// <summary>
         /// Returns a collection of entities for content based on search results

From 4c5365de1c60178f44bf132872cd54d883fb8c50 Mon Sep 17 00:00:00 2001
From: Kenn Jacobsen <post@kennjacobsen.dk>
Date: Wed, 3 Jul 2019 12:33:03 +0200
Subject: [PATCH 02/14] Make sure Nested Content blueprints are listed in
 defined sort order

(cherry picked from commit 204a9c9d5386a9230e321504bf2e519fd26eee55)
---
 .../common/overlays/itempicker/itempicker.controller.js      | 5 +++++
 .../src/views/common/overlays/itempicker/itempicker.html     | 2 +-
 .../nestedcontent/nestedcontent.controller.js                | 1 +
 3 files changed, 7 insertions(+), 1 deletion(-)

diff --git a/src/Umbraco.Web.UI.Client/src/views/common/overlays/itempicker/itempicker.controller.js b/src/Umbraco.Web.UI.Client/src/views/common/overlays/itempicker/itempicker.controller.js
index a848c0ae90..aa6fa8d42c 100644
--- a/src/Umbraco.Web.UI.Client/src/views/common/overlays/itempicker/itempicker.controller.js
+++ b/src/Umbraco.Web.UI.Client/src/views/common/overlays/itempicker/itempicker.controller.js
@@ -4,6 +4,11 @@ function ItemPickerOverlay($scope, localizationService) {
         $scope.model.title = localizationService.localize("defaultdialogs_selectItem");
     }
 
+    
+    if (!$scope.model.orderBy) {
+        $scope.model.orderBy = "name";
+    }
+
     $scope.model.hideSubmitButton = true;
 
     $scope.selectItem = function(item) {
diff --git a/src/Umbraco.Web.UI.Client/src/views/common/overlays/itempicker/itempicker.html b/src/Umbraco.Web.UI.Client/src/views/common/overlays/itempicker/itempicker.html
index aac4830d52..328344ea84 100644
--- a/src/Umbraco.Web.UI.Client/src/views/common/overlays/itempicker/itempicker.html
+++ b/src/Umbraco.Web.UI.Client/src/views/common/overlays/itempicker/itempicker.html
@@ -12,7 +12,7 @@
     </div>
 
     <ul class="umb-card-grid">
-        <li ng-repeat="availableItem in model.availableItems | compareArrays:model.selectedItems:'alias' | orderBy:'name' | filter:searchTerm"
+        <li ng-repeat="availableItem in model.availableItems | compareArrays:model.selectedItems:'alias' | orderBy:model.orderBy | filter:searchTerm"
             ng-click="selectItem(availableItem)"
             class="-three-in-row">
             <a class="umb-card-grid-item" href="" title="{{ availableItem.name }}">
diff --git a/src/Umbraco.Web.UI.Client/src/views/propertyeditors/nestedcontent/nestedcontent.controller.js b/src/Umbraco.Web.UI.Client/src/views/propertyeditors/nestedcontent/nestedcontent.controller.js
index 0dcfc99238..51df8d3b56 100644
--- a/src/Umbraco.Web.UI.Client/src/views/propertyeditors/nestedcontent/nestedcontent.controller.js
+++ b/src/Umbraco.Web.UI.Client/src/views/propertyeditors/nestedcontent/nestedcontent.controller.js
@@ -142,6 +142,7 @@ angular.module("umbraco").controller("Umbraco.PropertyEditors.NestedContent.Prop
                 show: false,
                 style: {},
                 filter: $scope.scaffolds.length > 15 ? true : false,
+                orderBy: "$index",
                 view: "itempicker",
                 event: $event,
                 submit: function(model) {                    

From c6e32019c618df66b7760478f2977b913fbca383 Mon Sep 17 00:00:00 2001
From: Kenn Jacobsen <post@kennjacobsen.dk>
Date: Thu, 29 Aug 2019 13:41:34 +0200
Subject: [PATCH 03/14] V7: Add confirmation when deleting content and media
 (#6004)

(cherry picked from commit 3f8dffee3fa22a0e36506724165cf02790f2fee0)
---
 .../content/content.delete.controller.js      |  2 +-
 .../src/views/content/delete.html             | 22 ++++++++++++++-----
 .../src/views/media/delete.html               | 21 +++++++++++++-----
 .../views/media/media.delete.controller.js    |  3 +--
 src/Umbraco.Web.UI/umbraco/config/lang/da.xml |  1 +
 src/Umbraco.Web.UI/umbraco/config/lang/en.xml |  1 +
 .../umbraco/config/lang/en_us.xml             |  1 +
 7 files changed, 37 insertions(+), 14 deletions(-)

diff --git a/src/Umbraco.Web.UI.Client/src/views/content/content.delete.controller.js b/src/Umbraco.Web.UI.Client/src/views/content/content.delete.controller.js
index 917e4c024a..b12d809aaa 100644
--- a/src/Umbraco.Web.UI.Client/src/views/content/content.delete.controller.js
+++ b/src/Umbraco.Web.UI.Client/src/views/content/content.delete.controller.js
@@ -50,7 +50,7 @@ function ContentDeleteController($scope, contentResource, treeService, navigatio
                 $location.path(location);
             }
 
-            navigationService.hideMenu();
+            $scope.success = true;
         }, function(err) {
 
             $scope.currentNode.loading = false;
diff --git a/src/Umbraco.Web.UI.Client/src/views/content/delete.html b/src/Umbraco.Web.UI.Client/src/views/content/delete.html
index f3bdb0d121..1eb0363c34 100644
--- a/src/Umbraco.Web.UI.Client/src/views/content/delete.html
+++ b/src/Umbraco.Web.UI.Client/src/views/content/delete.html
@@ -1,12 +1,22 @@
 <div class="umb-dialog umb-pane" ng-controller="Umbraco.Editors.Content.DeleteController">
     <div class="umb-dialog-body" auto-scale="90">
-        
-        <p class="umb-abstract">
-            <localize key="defaultdialogs_confirmdelete">Are you sure you want to delete</localize> <strong>{{currentNode.name}}</strong> ?
-        </p>
 
-        <umb-confirm on-confirm="performDelete" on-cancel="cancel">    
-        </umb-confirm>
+        <div ng-show="success">
+            <div class="alert alert-success">
+                <strong>{{currentNode.name}}</strong>
+                <localize key="actions_wasDeleted">was deleted</localize>
+            </div>
+            <button class="btn btn-primary" ng-click="nav.hideDialog()">Ok</button>
+        </div>
+
+        <div ng-hide="success">
+            <p class="umb-abstract">
+                <localize key="defaultdialogs_confirmdelete">Are you sure you want to delete</localize> <strong>{{currentNode.name}}</strong> ?
+            </p>
+
+            <umb-confirm on-confirm="performDelete" on-cancel="cancel">    
+            </umb-confirm>
+        </div>
 
     </div>
 </div>
diff --git a/src/Umbraco.Web.UI.Client/src/views/media/delete.html b/src/Umbraco.Web.UI.Client/src/views/media/delete.html
index 3c9716eb3f..9fca0c9222 100644
--- a/src/Umbraco.Web.UI.Client/src/views/media/delete.html
+++ b/src/Umbraco.Web.UI.Client/src/views/media/delete.html
@@ -1,10 +1,21 @@
 <div class="umb-dialog umb-pane" ng-controller="Umbraco.Editors.Media.DeleteController">
     <div class="umb-dialog-body" auto-scale="90">
-        
-        <p class="umb-abstract">
-            <localize key="defaultdialogs_confirmdelete">Are you sure you want to delete</localize> <strong>{{currentNode.name}}</strong> ?
-        </p>
 
-        <umb-confirm on-confirm="performDelete" on-cancel="cancel"></umb-confirm>
+        <div ng-show="success">
+            <div class="alert alert-success">
+                <strong>{{currentNode.name}}</strong>
+                <localize key="actions_wasDeleted">was deleted</localize>
+            </div>
+            <button class="btn btn-primary" ng-click="nav.hideDialog()">Ok</button>
+        </div>
+
+        <div ng-hide="success">
+            <p class="umb-abstract">
+                <localize key="defaultdialogs_confirmdelete">Are you sure you want to delete</localize> <strong>{{currentNode.name}}</strong> ?
+            </p>
+
+            <umb-confirm on-confirm="performDelete" on-cancel="cancel"></umb-confirm>
+        </div>
+
     </div>
 </div>
diff --git a/src/Umbraco.Web.UI.Client/src/views/media/media.delete.controller.js b/src/Umbraco.Web.UI.Client/src/views/media/media.delete.controller.js
index 6ff35ab9cb..c3b3e0c116 100644
--- a/src/Umbraco.Web.UI.Client/src/views/media/media.delete.controller.js
+++ b/src/Umbraco.Web.UI.Client/src/views/media/media.delete.controller.js
@@ -50,8 +50,7 @@ function MediaDeleteController($scope, mediaResource, treeService, navigationSer
                 $location.path(location);
             }
 
-            navigationService.hideMenu();
-
+            $scope.success = true;
         }, function (err) {
 
             $scope.currentNode.loading = false;
diff --git a/src/Umbraco.Web.UI/umbraco/config/lang/da.xml b/src/Umbraco.Web.UI/umbraco/config/lang/da.xml
index 3223478dd7..b0b8dc67e1 100644
--- a/src/Umbraco.Web.UI/umbraco/config/lang/da.xml
+++ b/src/Umbraco.Web.UI/umbraco/config/lang/da.xml
@@ -37,6 +37,7 @@
     <key alias="toInTheTreeStructureBelow">til i træstrukturen nedenfor</key>
     <key alias="wasMovedTo">blev flyttet til</key>
     <key alias="wasCopiedTo">blev kopieret til</key>
+    <key alias="wasDeleted">blev slettet</key>
     <key alias="rights">Rettigheder</key>
     <key alias="rollback">Fortryd ændringer</key>
     <key alias="sendtopublish">Send til udgivelse</key>
diff --git a/src/Umbraco.Web.UI/umbraco/config/lang/en.xml b/src/Umbraco.Web.UI/umbraco/config/lang/en.xml
index 53a58bd7b1..a3f098d20f 100644
--- a/src/Umbraco.Web.UI/umbraco/config/lang/en.xml
+++ b/src/Umbraco.Web.UI/umbraco/config/lang/en.xml
@@ -38,6 +38,7 @@
         <key alias="toInTheTreeStructureBelow">to in the tree structure below</key>
         <key alias="wasMovedTo">was moved to</key>
         <key alias="wasCopiedTo">was copied to</key>
+        <key alias="wasDeleted">was deleted</key>
         <key alias="rights">Permissions</key>
         <key alias="rollback">Rollback</key>
         <key alias="sendtopublish">Send To Publish</key>
diff --git a/src/Umbraco.Web.UI/umbraco/config/lang/en_us.xml b/src/Umbraco.Web.UI/umbraco/config/lang/en_us.xml
index a2b7e6d040..3e947f3589 100644
--- a/src/Umbraco.Web.UI/umbraco/config/lang/en_us.xml
+++ b/src/Umbraco.Web.UI/umbraco/config/lang/en_us.xml
@@ -38,6 +38,7 @@
         <key alias="toInTheTreeStructureBelow">to in the tree structure below</key>
         <key alias="wasMovedTo">was moved to</key>
         <key alias="wasCopiedTo">was copied to</key>
+        <key alias="wasDeleted">was deleted</key>
         <key alias="rights">Permissions</key>
         <key alias="rollback">Rollback</key>
         <key alias="sendtopublish">Send To Publish</key>

From 90c99eda17b4783947552e7baefc7bc4e4e2149c Mon Sep 17 00:00:00 2001
From: Sebastiaan Janssen <sebastiaan@umbraco.com>
Date: Thu, 29 Aug 2019 15:00:32 +0200
Subject: [PATCH 04/14] Bump version to 7.15.3

---
 src/SolutionInfo.cs                              | 4 ++--
 src/Umbraco.Core/Configuration/UmbracoVersion.cs | 2 +-
 src/Umbraco.Web.UI/Umbraco.Web.UI.csproj         | 4 ++--
 3 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/src/SolutionInfo.cs b/src/SolutionInfo.cs
index ffaec90fa7..97ebd98e8c 100644
--- a/src/SolutionInfo.cs
+++ b/src/SolutionInfo.cs
@@ -11,5 +11,5 @@ using System.Resources;
 
 [assembly: AssemblyVersion("1.0.*")]
 
-[assembly: AssemblyFileVersion("7.15.2")]
-[assembly: AssemblyInformationalVersion("7.15.2")]
+[assembly: AssemblyFileVersion("7.15.3")]
+[assembly: AssemblyInformationalVersion("7.15.3")]
diff --git a/src/Umbraco.Core/Configuration/UmbracoVersion.cs b/src/Umbraco.Core/Configuration/UmbracoVersion.cs
index b02e199313..8c8755577a 100644
--- a/src/Umbraco.Core/Configuration/UmbracoVersion.cs
+++ b/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.15.2");
+        private static readonly Version Version = new Version("7.15.3");
 
         /// <summary>
         /// Gets the current version of Umbraco.
diff --git a/src/Umbraco.Web.UI/Umbraco.Web.UI.csproj b/src/Umbraco.Web.UI/Umbraco.Web.UI.csproj
index 4eddca0b8d..76d2765672 100644
--- a/src/Umbraco.Web.UI/Umbraco.Web.UI.csproj
+++ b/src/Umbraco.Web.UI/Umbraco.Web.UI.csproj
@@ -1028,9 +1028,9 @@ xcopy "$(ProjectDir)"..\packages\SqlServerCE.4.0.0.1\x86\*.* "$(TargetDir)x86\"
         <WebProjectProperties>
           <UseIIS>True</UseIIS>
           <AutoAssignPort>True</AutoAssignPort>
-          <DevelopmentServerPort>7152</DevelopmentServerPort>
+          <DevelopmentServerPort>7153</DevelopmentServerPort>
           <DevelopmentServerVPath>/</DevelopmentServerVPath>
-          <IISUrl>http://localhost:7152</IISUrl>
+          <IISUrl>http://localhost:7153</IISUrl>
           <NTLMAuthentication>False</NTLMAuthentication>
           <UseCustomServer>False</UseCustomServer>
           <CustomServerUrl>

From d3f3c74e10770d839c4c025e329219bf1d3a89e3 Mon Sep 17 00:00:00 2001
From: Sebastiaan Janssen <sebastiaan@umbraco.com>
Date: Thu, 5 Sep 2019 11:47:13 +0200
Subject: [PATCH 05/14] Fix #6283 Save Member resets password

---
 .../src/views/member/member.edit.controller.js                  | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/Umbraco.Web.UI.Client/src/views/member/member.edit.controller.js b/src/Umbraco.Web.UI.Client/src/views/member/member.edit.controller.js
index eb99e46a1f..8d54597791 100644
--- a/src/Umbraco.Web.UI.Client/src/views/member/member.edit.controller.js
+++ b/src/Umbraco.Web.UI.Client/src/views/member/member.edit.controller.js
@@ -133,7 +133,7 @@ function MemberEditController($scope, $routeParams, $location, $q, $window, appS
 
             //anytime a user is changing a member's password without the oldPassword, we are in effect resetting it so we need to set that flag here
             var passwordProp = _.find(contentEditingHelper.getAllProps($scope.content), function (e) { return e.alias === '_umb_password' });
-            if (passwordProp && passwordProp.value && !passwordProp.value.reset) {
+            if (passwordProp && passwordProp.value && (typeof passwordProp.value.reset !== 'undefined') && !passwordProp.value.reset) {
                 //so if the admin is not explicitly resetting the password, flag it for resetting if a new password is being entered
                 passwordProp.value.reset = !passwordProp.value.oldPassword && passwordProp.config.allowManuallyChangingPassword;
             }

From 39972049bb7c1c3297f556beaaa9811763bcf1bc Mon Sep 17 00:00:00 2001
From: Mark Bowser <mark@proworks.com>
Date: Tue, 3 Sep 2019 16:10:01 -0700
Subject: [PATCH 06/14] Apply focus to URL input on embed overlay open. Issue
 #6276

(cherry picked from commit a58a2e8aa9b7c13beefbec8c5d00c9649cada6d1)
---
 .../src/views/common/overlays/embed/embed.html                  | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/Umbraco.Web.UI.Client/src/views/common/overlays/embed/embed.html b/src/Umbraco.Web.UI.Client/src/views/common/overlays/embed/embed.html
index 6a829e6be4..6aadbced7b 100644
--- a/src/Umbraco.Web.UI.Client/src/views/common/overlays/embed/embed.html
+++ b/src/Umbraco.Web.UI.Client/src/views/common/overlays/embed/embed.html
@@ -1,7 +1,7 @@
 <form ng-controller="Umbraco.Overlays.EmbedOverlay as vm">
 
    <umb-control-group label="@general_url">
-       <input id="url" class="umb-editor input-block-level" type="text" style="margin-bottom: 10px;" ng-model="model.embed.url" ng-keyup="$event.keyCode == 13 ? vm.showPreview() : null" required />
+       <input id="url" class="umb-editor input-block-level" type="text" style="margin-bottom: 10px;" ng-model="model.embed.url" ng-keyup="$event.keyCode == 13 ? vm.showPreview() : null" focus-when="{{true}}" required />
        <input type="button" ng-click="vm.showPreview()" class="btn" value="@general_retrieve" localize="value" />
    </umb-control-group>
 

From f0fb371b2c6e2048042e884da6b059403aa805c7 Mon Sep 17 00:00:00 2001
From: Elitsa Marinovska <21998037+elit0451@users.noreply.github.com>
Date: Tue, 10 Sep 2019 13:54:35 +0200
Subject: [PATCH 07/14] Revert "V7/bug/6283 save member resets password"

---
 .../src/common/resources/entity.resource.js   |    2 +-
 .../linkpicker/linkpicker.controller.js       |    7 +-
 .../views/member/member.edit.controller.js    |    2 +-
 src/Umbraco.Web/Editors/EntityController.cs   |   11 +-
 src/Umbraco.Web/Properties/Settings.settings  |    3 +
 .../Properties/Settings1.Designer.cs          |   12 +-
 src/Umbraco.Web/Umbraco.Web.csproj            |   22 +
 src/Umbraco.Web/UmbracoHelper.cs              |   33 -
 .../org.umbraco.our/Reference.cs              | 1046 +++++++++++++++++
 .../org.umbraco.our/Reference.map             |    7 +
 .../org.umbraco.our/repository.disco          |    6 +
 .../org.umbraco.our/repository.wsdl           |  995 ++++++++++++++++
 12 files changed, 2097 insertions(+), 49 deletions(-)
 create mode 100644 src/Umbraco.Web/Web References/org.umbraco.our/Reference.cs
 create mode 100644 src/Umbraco.Web/Web References/org.umbraco.our/Reference.map
 create mode 100644 src/Umbraco.Web/Web References/org.umbraco.our/repository.disco
 create mode 100644 src/Umbraco.Web/Web References/org.umbraco.our/repository.wsdl

diff --git a/src/Umbraco.Web.UI.Client/src/common/resources/entity.resource.js b/src/Umbraco.Web.UI.Client/src/common/resources/entity.resource.js
index 7c1e232383..4e164cacf6 100644
--- a/src/Umbraco.Web.UI.Client/src/common/resources/entity.resource.js
+++ b/src/Umbraco.Web.UI.Client/src/common/resources/entity.resource.js
@@ -172,7 +172,7 @@ function entityResource($q, $http, umbRequestHelper) {
                     umbRequestHelper.getApiUrl(
                         "entityApiBaseUrl",
                         "GetUrlAndAnchors",
-                        [{ id: id }])),
+                        { id: id })),
                 'Failed to retrieve url and anchors data for id ' + id);
         },
 
diff --git a/src/Umbraco.Web.UI.Client/src/views/common/overlays/linkpicker/linkpicker.controller.js b/src/Umbraco.Web.UI.Client/src/views/common/overlays/linkpicker/linkpicker.controller.js
index ddf8ac8f98..f1241c1976 100644
--- a/src/Umbraco.Web.UI.Client/src/views/common/overlays/linkpicker/linkpicker.controller.js
+++ b/src/Umbraco.Web.UI.Client/src/views/common/overlays/linkpicker/linkpicker.controller.js
@@ -33,23 +33,24 @@ angular.module("umbraco").controller("Umbraco.Overlays.LinkPickerController",
         if (dialogOptions.currentTarget) {
             // clone the current target so we don't accidentally update the caller's model while manipulating $scope.model.target
             $scope.model.target = angular.copy(dialogOptions.currentTarget);
-            // if we have a node ID, we fetch the current node to build the form data
+            //if we have a node ID, we fetch the current node to build the form data
             if ($scope.model.target.id || $scope.model.target.udi) {
 
-                // will be either a udi or an int
+                //will be either a udi or an int
                 var id = $scope.model.target.udi ? $scope.model.target.udi : $scope.model.target.id;
 
                 // is it a content link?
                 if (!$scope.model.target.isMedia) {
                     // get the content path
                     entityResource.getPath(id, "Document").then(function (path) {
-                        // now sync the tree to this path
+                        //now sync the tree to this path
                         $scope.dialogTreeEventHandler.syncTree({
                             path: path,
                             tree: "content"
                         });
                     });
 
+
                     entityResource.getUrlAndAnchors(id).then(function(resp){
                         $scope.anchorValues = resp.anchorValues;
                         $scope.model.target.url = resp.url;
diff --git a/src/Umbraco.Web.UI.Client/src/views/member/member.edit.controller.js b/src/Umbraco.Web.UI.Client/src/views/member/member.edit.controller.js
index 8d54597791..eb99e46a1f 100644
--- a/src/Umbraco.Web.UI.Client/src/views/member/member.edit.controller.js
+++ b/src/Umbraco.Web.UI.Client/src/views/member/member.edit.controller.js
@@ -133,7 +133,7 @@ function MemberEditController($scope, $routeParams, $location, $q, $window, appS
 
             //anytime a user is changing a member's password without the oldPassword, we are in effect resetting it so we need to set that flag here
             var passwordProp = _.find(contentEditingHelper.getAllProps($scope.content), function (e) { return e.alias === '_umb_password' });
-            if (passwordProp && passwordProp.value && (typeof passwordProp.value.reset !== 'undefined') && !passwordProp.value.reset) {
+            if (passwordProp && passwordProp.value && !passwordProp.value.reset) {
                 //so if the admin is not explicitly resetting the password, flag it for resetting if a new password is being entered
                 passwordProp.value.reset = !passwordProp.value.oldPassword && passwordProp.config.allowManuallyChangingPassword;
             }
diff --git a/src/Umbraco.Web/Editors/EntityController.cs b/src/Umbraco.Web/Editors/EntityController.cs
index ada0206545..85d5b607b6 100644
--- a/src/Umbraco.Web/Editors/EntityController.cs
+++ b/src/Umbraco.Web/Editors/EntityController.cs
@@ -56,7 +56,6 @@ namespace Umbraco.Web.Editors
                     //id is passed in eventually we'll probably want to support GUID + Udi too
                     new ParameterSwapControllerActionSelector.ParameterSwapInfo("GetPagedChildren", "id", typeof(int), typeof(string)),
                     new ParameterSwapControllerActionSelector.ParameterSwapInfo("GetPath", "id", typeof(int), typeof(Guid), typeof(Udi)),
-                    new ParameterSwapControllerActionSelector.ParameterSwapInfo("GetUrlAndAnchors", "id", typeof(int), typeof(Guid), typeof(Udi)),
                     new ParameterSwapControllerActionSelector.ParameterSwapInfo("GetById", "id", typeof(int), typeof(Guid), typeof(Udi)),
                     new ParameterSwapControllerActionSelector.ParameterSwapInfo("GetByIds", "ids", typeof(int[]), typeof(Guid[]), typeof(Udi[]))));
             }
@@ -282,17 +281,9 @@ namespace Umbraco.Web.Editors
                 publishedContentExists: i => Umbraco.TypedContent(i) != null);
         }
 
-        [HttpGet]
-        public UrlAndAnchors GetUrlAndAnchors(Udi id)
-        {
-            var nodeId = Umbraco.GetIdForUdi(id);
-            var url = Umbraco.Url(nodeId);
-            var anchorValues = Services.ContentService.GetAnchorValuesFromRTEs(nodeId);
-            return new UrlAndAnchors(url, anchorValues);
-        }
 
         [HttpGet]
-        public UrlAndAnchors GetUrlAndAnchors(int id)
+        public UrlAndAnchors GetUrlAndAnchors([FromUri]int id)
         {
             var url = Umbraco.Url(id);
             var anchorValues = Services.ContentService.GetAnchorValuesFromRTEs(id);
diff --git a/src/Umbraco.Web/Properties/Settings.settings b/src/Umbraco.Web/Properties/Settings.settings
index a7b911ae3b..da9e6f69c0 100644
--- a/src/Umbraco.Web/Properties/Settings.settings
+++ b/src/Umbraco.Web/Properties/Settings.settings
@@ -11,5 +11,8 @@
     <Setting Name="test" Type="System.String" Scope="Application">
       <Value Profile="(Default)">Somthing</Value>
     </Setting>
+    <Setting Name="umbraco_org_umbraco_our_Repository" Type="(Web Service URL)" Scope="Application">
+      <Value Profile="(Default)">https://our.umbraco.com/umbraco/webservices/api/repository.asmx</Value>
+    </Setting>
   </Settings>
 </SettingsFile>
\ No newline at end of file
diff --git a/src/Umbraco.Web/Properties/Settings1.Designer.cs b/src/Umbraco.Web/Properties/Settings1.Designer.cs
index 3847901f20..e7028f28df 100644
--- a/src/Umbraco.Web/Properties/Settings1.Designer.cs
+++ b/src/Umbraco.Web/Properties/Settings1.Designer.cs
@@ -12,7 +12,7 @@ namespace Umbraco.Web.Properties {
     
     
     [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
-    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.VisualStudio.Editors.SettingsDesigner.SettingsSingleFileGenerator", "16.2.0.0")]
+    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.VisualStudio.Editors.SettingsDesigner.SettingsSingleFileGenerator", "15.8.0.0")]
     internal sealed partial class Settings : global::System.Configuration.ApplicationSettingsBase {
         
         private static Settings defaultInstance = ((Settings)(global::System.Configuration.ApplicationSettingsBase.Synchronized(new Settings())));
@@ -50,5 +50,15 @@ namespace Umbraco.Web.Properties {
                 return ((string)(this["test"]));
             }
         }
+        
+        [global::System.Configuration.ApplicationScopedSettingAttribute()]
+        [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
+        [global::System.Configuration.SpecialSettingAttribute(global::System.Configuration.SpecialSetting.WebServiceUrl)]
+        [global::System.Configuration.DefaultSettingValueAttribute("https://our.umbraco.com/umbraco/webservices/api/repository.asmx")]
+        public string umbraco_org_umbraco_our_Repository {
+            get {
+                return ((string)(this["umbraco_org_umbraco_our_Repository"]));
+            }
+        }
     }
 }
diff --git a/src/Umbraco.Web/Umbraco.Web.csproj b/src/Umbraco.Web/Umbraco.Web.csproj
index 2624959e16..01524e5962 100644
--- a/src/Umbraco.Web/Umbraco.Web.csproj
+++ b/src/Umbraco.Web/Umbraco.Web.csproj
@@ -814,6 +814,11 @@
     <Compile Include="umbraco.presentation\umbraco\Trees\loadPackager.cs" />
     <Compile Include="PublishedCache\XmlPublishedCache\XmlCacheFilePersister.cs" />
     <Compile Include="UmbracoComponentRenderer.cs" />
+    <Compile Include="Web References\org.umbraco.our\Reference.cs">
+      <AutoGen>True</AutoGen>
+      <DesignTime>True</DesignTime>
+      <DependentUpon>Reference.map</DependentUpon>
+    </Compile>
     <Compile Include="WebApi\AngularJsonMediaTypeFormatter.cs" />
     <Compile Include="WebApi\AngularJsonOnlyConfigurationAttribute.cs" />
     <Compile Include="WebApi\Binders\BlueprintItemBinder.cs" />
@@ -1825,6 +1830,11 @@
       <Link>Mvc\web.config</Link>
     </None>
     <None Include="packages.config" />
+    <None Include="Web References\org.umbraco.our\Reference.map">
+      <Generator>MSDiscoCodeGenerator</Generator>
+      <LastGenOutput>Reference.cs</LastGenOutput>
+    </None>
+    <None Include="Web References\org.umbraco.our\repository.disco" />
     <EmbeddedResource Include="UI\JavaScript\Main.js" />
     <EmbeddedResource Include="UI\JavaScript\JsInitialize.js" />
     <EmbeddedResource Include="UI\JavaScript\ServerVariables.js" />
@@ -1875,6 +1885,7 @@
     <Content Include="umbraco.presentation\umbraco\members\ViewMembers.aspx" />
     <Content Include="umbraco.presentation\umbraco\plugins\tinymce3\tinymce3tinymceCompress.aspx" />
     <None Include="app.config" />
+    <None Include="Web References\org.umbraco.our\repository.wsdl" />
     <None Include="Web References\org.umbraco.update\UpgradeResult.datasource">
       <DependentUpon>Reference.map</DependentUpon>
     </None>
@@ -1968,6 +1979,17 @@
     <WebReferences Include="Web References\" />
   </ItemGroup>
   <ItemGroup>
+    <WebReferenceUrl Include="https://our.umbraco.com/umbraco/webservices/api/repository.asmx">
+      <UrlBehavior>Dynamic</UrlBehavior>
+      <RelPath>Web References\org.umbraco.our\</RelPath>
+      <UpdateFromURL>https://our.umbraco.com/umbraco/webservices/api/repository.asmx</UpdateFromURL>
+      <ServiceLocationURL>
+      </ServiceLocationURL>
+      <CachedDynamicPropName>
+      </CachedDynamicPropName>
+      <CachedAppSettingsObjectName>Settings</CachedAppSettingsObjectName>
+      <CachedSettingsPropName>umbraco_org_umbraco_our_Repository</CachedSettingsPropName>
+    </WebReferenceUrl>
     <WebReferenceUrl Include="http://update.umbraco.org/checkforupgrade.asmx">
       <UrlBehavior>Dynamic</UrlBehavior>
       <RelPath>Web References\org.umbraco.update\</RelPath>
diff --git a/src/Umbraco.Web/UmbracoHelper.cs b/src/Umbraco.Web/UmbracoHelper.cs
index 199cdd4ef3..5320b6085a 100644
--- a/src/Umbraco.Web/UmbracoHelper.cs
+++ b/src/Umbraco.Web/UmbracoHelper.cs
@@ -492,18 +492,6 @@ namespace Umbraco.Web
             return Url(nodeId);
         }
 
-        /// <summary>
-        /// Returns a string with a friendly url from a node.
-        /// IE.: Instead of having /482 (id) as an url, you can have
-        /// /screenshots/developer/macros (spoken url)
-        /// </summary>
-        /// <param name="guid">Identifier for the node that should be returned</param>
-        /// <returns>String with a friendly url from a node</returns>
-        public string NiceUrl(Guid guid)
-        {
-            return Url(guid);
-        }
-
         /// <summary>
         /// Gets the url of a content identified by its identifier.
         /// </summary>
@@ -514,16 +502,6 @@ namespace Umbraco.Web
             return UrlProvider.GetUrl(contentId);
         }
 
-        /// <summary>
-        /// Gets the url of a content identified by its identifier.
-        /// </summary>
-        /// <param name="contentGuid">The content identifier.</param>
-        /// <returns>The url for the content.</returns>
-        public string Url(Guid contentGuid)
-        {
-            return UrlProvider.GetUrl(contentGuid);
-        }
-
         /// <summary>
         /// Gets the url of a content identified by its identifier, in a specified mode.
         /// </summary>
@@ -535,17 +513,6 @@ namespace Umbraco.Web
             return UrlProvider.GetUrl(contentId, mode);
         }
 
-        /// <summary>
-        /// Gets the url of a content identified by its identifier, in a specified mode.
-        /// </summary>
-        /// <param name="contentGuid">The content identifier.</param>
-        /// <param name="mode">The mode.</param>
-        /// <returns>The url for the content.</returns>
-        public string Url(Guid contentGuid, UrlProviderMode mode)
-        {
-            return UrlProvider.GetUrl(contentGuid, mode);
-        }
-
         /// <summary>
         /// This method will always add the domain to the path if the hostnames are set up correctly.
         /// </summary>
diff --git a/src/Umbraco.Web/Web References/org.umbraco.our/Reference.cs b/src/Umbraco.Web/Web References/org.umbraco.our/Reference.cs
new file mode 100644
index 0000000000..d0c8990660
--- /dev/null
+++ b/src/Umbraco.Web/Web References/org.umbraco.our/Reference.cs	
@@ -0,0 +1,1046 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by a tool.
+//     Runtime Version:4.0.30319.42000
+//
+//     Changes to this file may cause incorrect behavior and will be lost if
+//     the code is regenerated.
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// 
+// This source code was auto-generated by Microsoft.VSDesigner, Version 4.0.30319.42000.
+// 
+#pragma warning disable 1591
+
+namespace Umbraco.Web.org.umbraco.our {
+    using System;
+    using System.Web.Services;
+    using System.Diagnostics;
+    using System.Web.Services.Protocols;
+    using System.Xml.Serialization;
+    using System.ComponentModel;
+    
+    
+    /// <remarks/>
+    [System.CodeDom.Compiler.GeneratedCodeAttribute("System.Web.Services", "4.7.3056.0")]
+    [System.Diagnostics.DebuggerStepThroughAttribute()]
+    [System.ComponentModel.DesignerCategoryAttribute("code")]
+    [System.Web.Services.WebServiceBindingAttribute(Name="RepositorySoap", Namespace="http://packages.umbraco.org/webservices/")]
+    public partial class Repository : System.Web.Services.Protocols.SoapHttpClientProtocol {
+        
+        private System.Threading.SendOrPostCallback CategoriesOperationCompleted;
+        
+        private System.Threading.SendOrPostCallback ModulesOperationCompleted;
+        
+        private System.Threading.SendOrPostCallback ModulesCategorizedOperationCompleted;
+        
+        private System.Threading.SendOrPostCallback NitrosOperationCompleted;
+        
+        private System.Threading.SendOrPostCallback NitrosCategorizedOperationCompleted;
+        
+        private System.Threading.SendOrPostCallback authenticateOperationCompleted;
+        
+        private System.Threading.SendOrPostCallback fetchPackageOperationCompleted;
+        
+        private System.Threading.SendOrPostCallback fetchPackageByVersionOperationCompleted;
+        
+        private System.Threading.SendOrPostCallback fetchProtectedPackageOperationCompleted;
+        
+        private System.Threading.SendOrPostCallback SubmitPackageOperationCompleted;
+        
+        private System.Threading.SendOrPostCallback PackageByGuidOperationCompleted;
+        
+        private bool useDefaultCredentialsSetExplicitly;
+        
+        /// <remarks/>
+        public Repository() {
+            this.Url = global::Umbraco.Web.Properties.Settings.Default.umbraco_org_umbraco_our_Repository;
+            if ((this.IsLocalFileSystemWebService(this.Url) == true)) {
+                this.UseDefaultCredentials = true;
+                this.useDefaultCredentialsSetExplicitly = false;
+            }
+            else {
+                this.useDefaultCredentialsSetExplicitly = true;
+            }
+        }
+        
+        public new string Url {
+            get {
+                return base.Url;
+            }
+            set {
+                if ((((this.IsLocalFileSystemWebService(base.Url) == true) 
+                            && (this.useDefaultCredentialsSetExplicitly == false)) 
+                            && (this.IsLocalFileSystemWebService(value) == false))) {
+                    base.UseDefaultCredentials = false;
+                }
+                base.Url = value;
+            }
+        }
+        
+        public new bool UseDefaultCredentials {
+            get {
+                return base.UseDefaultCredentials;
+            }
+            set {
+                base.UseDefaultCredentials = value;
+                this.useDefaultCredentialsSetExplicitly = true;
+            }
+        }
+        
+        /// <remarks/>
+        public event CategoriesCompletedEventHandler CategoriesCompleted;
+        
+        /// <remarks/>
+        public event ModulesCompletedEventHandler ModulesCompleted;
+        
+        /// <remarks/>
+        public event ModulesCategorizedCompletedEventHandler ModulesCategorizedCompleted;
+        
+        /// <remarks/>
+        public event NitrosCompletedEventHandler NitrosCompleted;
+        
+        /// <remarks/>
+        public event NitrosCategorizedCompletedEventHandler NitrosCategorizedCompleted;
+        
+        /// <remarks/>
+        public event authenticateCompletedEventHandler authenticateCompleted;
+        
+        /// <remarks/>
+        public event fetchPackageCompletedEventHandler fetchPackageCompleted;
+        
+        /// <remarks/>
+        public event fetchPackageByVersionCompletedEventHandler fetchPackageByVersionCompleted;
+        
+        /// <remarks/>
+        public event fetchProtectedPackageCompletedEventHandler fetchProtectedPackageCompleted;
+        
+        /// <remarks/>
+        public event SubmitPackageCompletedEventHandler SubmitPackageCompleted;
+        
+        /// <remarks/>
+        public event PackageByGuidCompletedEventHandler PackageByGuidCompleted;
+        
+        /// <remarks/>
+        [System.Web.Services.Protocols.SoapDocumentMethodAttribute("http://packages.umbraco.org/webservices/Categories", RequestNamespace="http://packages.umbraco.org/webservices/", ResponseNamespace="http://packages.umbraco.org/webservices/", Use=System.Web.Services.Description.SoapBindingUse.Literal, ParameterStyle=System.Web.Services.Protocols.SoapParameterStyle.Wrapped)]
+        public Category[] Categories(string repositoryGuid) {
+            object[] results = this.Invoke("Categories", new object[] {
+                        repositoryGuid});
+            return ((Category[])(results[0]));
+        }
+        
+        /// <remarks/>
+        public void CategoriesAsync(string repositoryGuid) {
+            this.CategoriesAsync(repositoryGuid, null);
+        }
+        
+        /// <remarks/>
+        public void CategoriesAsync(string repositoryGuid, object userState) {
+            if ((this.CategoriesOperationCompleted == null)) {
+                this.CategoriesOperationCompleted = new System.Threading.SendOrPostCallback(this.OnCategoriesOperationCompleted);
+            }
+            this.InvokeAsync("Categories", new object[] {
+                        repositoryGuid}, this.CategoriesOperationCompleted, userState);
+        }
+        
+        private void OnCategoriesOperationCompleted(object arg) {
+            if ((this.CategoriesCompleted != null)) {
+                System.Web.Services.Protocols.InvokeCompletedEventArgs invokeArgs = ((System.Web.Services.Protocols.InvokeCompletedEventArgs)(arg));
+                this.CategoriesCompleted(this, new CategoriesCompletedEventArgs(invokeArgs.Results, invokeArgs.Error, invokeArgs.Cancelled, invokeArgs.UserState));
+            }
+        }
+        
+        /// <remarks/>
+        [System.Web.Services.Protocols.SoapDocumentMethodAttribute("http://packages.umbraco.org/webservices/Modules", RequestNamespace="http://packages.umbraco.org/webservices/", ResponseNamespace="http://packages.umbraco.org/webservices/", Use=System.Web.Services.Description.SoapBindingUse.Literal, ParameterStyle=System.Web.Services.Protocols.SoapParameterStyle.Wrapped)]
+        public Package[] Modules() {
+            object[] results = this.Invoke("Modules", new object[0]);
+            return ((Package[])(results[0]));
+        }
+        
+        /// <remarks/>
+        public void ModulesAsync() {
+            this.ModulesAsync(null);
+        }
+        
+        /// <remarks/>
+        public void ModulesAsync(object userState) {
+            if ((this.ModulesOperationCompleted == null)) {
+                this.ModulesOperationCompleted = new System.Threading.SendOrPostCallback(this.OnModulesOperationCompleted);
+            }
+            this.InvokeAsync("Modules", new object[0], this.ModulesOperationCompleted, userState);
+        }
+        
+        private void OnModulesOperationCompleted(object arg) {
+            if ((this.ModulesCompleted != null)) {
+                System.Web.Services.Protocols.InvokeCompletedEventArgs invokeArgs = ((System.Web.Services.Protocols.InvokeCompletedEventArgs)(arg));
+                this.ModulesCompleted(this, new ModulesCompletedEventArgs(invokeArgs.Results, invokeArgs.Error, invokeArgs.Cancelled, invokeArgs.UserState));
+            }
+        }
+        
+        /// <remarks/>
+        [System.Web.Services.Protocols.SoapDocumentMethodAttribute("http://packages.umbraco.org/webservices/ModulesCategorized", RequestNamespace="http://packages.umbraco.org/webservices/", ResponseNamespace="http://packages.umbraco.org/webservices/", Use=System.Web.Services.Description.SoapBindingUse.Literal, ParameterStyle=System.Web.Services.Protocols.SoapParameterStyle.Wrapped)]
+        public Category[] ModulesCategorized() {
+            object[] results = this.Invoke("ModulesCategorized", new object[0]);
+            return ((Category[])(results[0]));
+        }
+        
+        /// <remarks/>
+        public void ModulesCategorizedAsync() {
+            this.ModulesCategorizedAsync(null);
+        }
+        
+        /// <remarks/>
+        public void ModulesCategorizedAsync(object userState) {
+            if ((this.ModulesCategorizedOperationCompleted == null)) {
+                this.ModulesCategorizedOperationCompleted = new System.Threading.SendOrPostCallback(this.OnModulesCategorizedOperationCompleted);
+            }
+            this.InvokeAsync("ModulesCategorized", new object[0], this.ModulesCategorizedOperationCompleted, userState);
+        }
+        
+        private void OnModulesCategorizedOperationCompleted(object arg) {
+            if ((this.ModulesCategorizedCompleted != null)) {
+                System.Web.Services.Protocols.InvokeCompletedEventArgs invokeArgs = ((System.Web.Services.Protocols.InvokeCompletedEventArgs)(arg));
+                this.ModulesCategorizedCompleted(this, new ModulesCategorizedCompletedEventArgs(invokeArgs.Results, invokeArgs.Error, invokeArgs.Cancelled, invokeArgs.UserState));
+            }
+        }
+        
+        /// <remarks/>
+        [System.Web.Services.Protocols.SoapDocumentMethodAttribute("http://packages.umbraco.org/webservices/Nitros", RequestNamespace="http://packages.umbraco.org/webservices/", ResponseNamespace="http://packages.umbraco.org/webservices/", Use=System.Web.Services.Description.SoapBindingUse.Literal, ParameterStyle=System.Web.Services.Protocols.SoapParameterStyle.Wrapped)]
+        public Package[] Nitros() {
+            object[] results = this.Invoke("Nitros", new object[0]);
+            return ((Package[])(results[0]));
+        }
+        
+        /// <remarks/>
+        public void NitrosAsync() {
+            this.NitrosAsync(null);
+        }
+        
+        /// <remarks/>
+        public void NitrosAsync(object userState) {
+            if ((this.NitrosOperationCompleted == null)) {
+                this.NitrosOperationCompleted = new System.Threading.SendOrPostCallback(this.OnNitrosOperationCompleted);
+            }
+            this.InvokeAsync("Nitros", new object[0], this.NitrosOperationCompleted, userState);
+        }
+        
+        private void OnNitrosOperationCompleted(object arg) {
+            if ((this.NitrosCompleted != null)) {
+                System.Web.Services.Protocols.InvokeCompletedEventArgs invokeArgs = ((System.Web.Services.Protocols.InvokeCompletedEventArgs)(arg));
+                this.NitrosCompleted(this, new NitrosCompletedEventArgs(invokeArgs.Results, invokeArgs.Error, invokeArgs.Cancelled, invokeArgs.UserState));
+            }
+        }
+        
+        /// <remarks/>
+        [System.Web.Services.Protocols.SoapDocumentMethodAttribute("http://packages.umbraco.org/webservices/NitrosCategorized", RequestNamespace="http://packages.umbraco.org/webservices/", ResponseNamespace="http://packages.umbraco.org/webservices/", Use=System.Web.Services.Description.SoapBindingUse.Literal, ParameterStyle=System.Web.Services.Protocols.SoapParameterStyle.Wrapped)]
+        public Category[] NitrosCategorized() {
+            object[] results = this.Invoke("NitrosCategorized", new object[0]);
+            return ((Category[])(results[0]));
+        }
+        
+        /// <remarks/>
+        public void NitrosCategorizedAsync() {
+            this.NitrosCategorizedAsync(null);
+        }
+        
+        /// <remarks/>
+        public void NitrosCategorizedAsync(object userState) {
+            if ((this.NitrosCategorizedOperationCompleted == null)) {
+                this.NitrosCategorizedOperationCompleted = new System.Threading.SendOrPostCallback(this.OnNitrosCategorizedOperationCompleted);
+            }
+            this.InvokeAsync("NitrosCategorized", new object[0], this.NitrosCategorizedOperationCompleted, userState);
+        }
+        
+        private void OnNitrosCategorizedOperationCompleted(object arg) {
+            if ((this.NitrosCategorizedCompleted != null)) {
+                System.Web.Services.Protocols.InvokeCompletedEventArgs invokeArgs = ((System.Web.Services.Protocols.InvokeCompletedEventArgs)(arg));
+                this.NitrosCategorizedCompleted(this, new NitrosCategorizedCompletedEventArgs(invokeArgs.Results, invokeArgs.Error, invokeArgs.Cancelled, invokeArgs.UserState));
+            }
+        }
+        
+        /// <remarks/>
+        [System.Web.Services.Protocols.SoapDocumentMethodAttribute("http://packages.umbraco.org/webservices/authenticate", RequestNamespace="http://packages.umbraco.org/webservices/", ResponseNamespace="http://packages.umbraco.org/webservices/", Use=System.Web.Services.Description.SoapBindingUse.Literal, ParameterStyle=System.Web.Services.Protocols.SoapParameterStyle.Wrapped)]
+        public string authenticate(string email, string md5Password) {
+            object[] results = this.Invoke("authenticate", new object[] {
+                        email,
+                        md5Password});
+            return ((string)(results[0]));
+        }
+        
+        /// <remarks/>
+        public void authenticateAsync(string email, string md5Password) {
+            this.authenticateAsync(email, md5Password, null);
+        }
+        
+        /// <remarks/>
+        public void authenticateAsync(string email, string md5Password, object userState) {
+            if ((this.authenticateOperationCompleted == null)) {
+                this.authenticateOperationCompleted = new System.Threading.SendOrPostCallback(this.OnauthenticateOperationCompleted);
+            }
+            this.InvokeAsync("authenticate", new object[] {
+                        email,
+                        md5Password}, this.authenticateOperationCompleted, userState);
+        }
+        
+        private void OnauthenticateOperationCompleted(object arg) {
+            if ((this.authenticateCompleted != null)) {
+                System.Web.Services.Protocols.InvokeCompletedEventArgs invokeArgs = ((System.Web.Services.Protocols.InvokeCompletedEventArgs)(arg));
+                this.authenticateCompleted(this, new authenticateCompletedEventArgs(invokeArgs.Results, invokeArgs.Error, invokeArgs.Cancelled, invokeArgs.UserState));
+            }
+        }
+        
+        /// <remarks/>
+        [System.Web.Services.Protocols.SoapDocumentMethodAttribute("http://packages.umbraco.org/webservices/fetchPackage", RequestNamespace="http://packages.umbraco.org/webservices/", ResponseNamespace="http://packages.umbraco.org/webservices/", Use=System.Web.Services.Description.SoapBindingUse.Literal, ParameterStyle=System.Web.Services.Protocols.SoapParameterStyle.Wrapped)]
+        [return: System.Xml.Serialization.XmlElementAttribute(DataType="base64Binary")]
+        public byte[] fetchPackage(string packageGuid) {
+            object[] results = this.Invoke("fetchPackage", new object[] {
+                        packageGuid});
+            return ((byte[])(results[0]));
+        }
+        
+        /// <remarks/>
+        public void fetchPackageAsync(string packageGuid) {
+            this.fetchPackageAsync(packageGuid, null);
+        }
+        
+        /// <remarks/>
+        public void fetchPackageAsync(string packageGuid, object userState) {
+            if ((this.fetchPackageOperationCompleted == null)) {
+                this.fetchPackageOperationCompleted = new System.Threading.SendOrPostCallback(this.OnfetchPackageOperationCompleted);
+            }
+            this.InvokeAsync("fetchPackage", new object[] {
+                        packageGuid}, this.fetchPackageOperationCompleted, userState);
+        }
+        
+        private void OnfetchPackageOperationCompleted(object arg) {
+            if ((this.fetchPackageCompleted != null)) {
+                System.Web.Services.Protocols.InvokeCompletedEventArgs invokeArgs = ((System.Web.Services.Protocols.InvokeCompletedEventArgs)(arg));
+                this.fetchPackageCompleted(this, new fetchPackageCompletedEventArgs(invokeArgs.Results, invokeArgs.Error, invokeArgs.Cancelled, invokeArgs.UserState));
+            }
+        }
+        
+        /// <remarks/>
+        [System.Web.Services.Protocols.SoapDocumentMethodAttribute("http://packages.umbraco.org/webservices/fetchPackageByVersion", RequestNamespace="http://packages.umbraco.org/webservices/", ResponseNamespace="http://packages.umbraco.org/webservices/", Use=System.Web.Services.Description.SoapBindingUse.Literal, ParameterStyle=System.Web.Services.Protocols.SoapParameterStyle.Wrapped)]
+        [return: System.Xml.Serialization.XmlElementAttribute(DataType="base64Binary")]
+        public byte[] fetchPackageByVersion(string packageGuid, string repoVersion) {
+            object[] results = this.Invoke("fetchPackageByVersion", new object[] {
+                        packageGuid,
+                        repoVersion});
+            return ((byte[])(results[0]));
+        }
+        
+        /// <remarks/>
+        public void fetchPackageByVersionAsync(string packageGuid, string repoVersion) {
+            this.fetchPackageByVersionAsync(packageGuid, repoVersion, null);
+        }
+        
+        /// <remarks/>
+        public void fetchPackageByVersionAsync(string packageGuid, string repoVersion, object userState) {
+            if ((this.fetchPackageByVersionOperationCompleted == null)) {
+                this.fetchPackageByVersionOperationCompleted = new System.Threading.SendOrPostCallback(this.OnfetchPackageByVersionOperationCompleted);
+            }
+            this.InvokeAsync("fetchPackageByVersion", new object[] {
+                        packageGuid,
+                        repoVersion}, this.fetchPackageByVersionOperationCompleted, userState);
+        }
+        
+        private void OnfetchPackageByVersionOperationCompleted(object arg) {
+            if ((this.fetchPackageByVersionCompleted != null)) {
+                System.Web.Services.Protocols.InvokeCompletedEventArgs invokeArgs = ((System.Web.Services.Protocols.InvokeCompletedEventArgs)(arg));
+                this.fetchPackageByVersionCompleted(this, new fetchPackageByVersionCompletedEventArgs(invokeArgs.Results, invokeArgs.Error, invokeArgs.Cancelled, invokeArgs.UserState));
+            }
+        }
+        
+        /// <remarks/>
+        [System.Web.Services.Protocols.SoapDocumentMethodAttribute("http://packages.umbraco.org/webservices/fetchProtectedPackage", RequestNamespace="http://packages.umbraco.org/webservices/", ResponseNamespace="http://packages.umbraco.org/webservices/", Use=System.Web.Services.Description.SoapBindingUse.Literal, ParameterStyle=System.Web.Services.Protocols.SoapParameterStyle.Wrapped)]
+        [return: System.Xml.Serialization.XmlElementAttribute(DataType="base64Binary")]
+        public byte[] fetchProtectedPackage(string packageGuid, string memberKey) {
+            object[] results = this.Invoke("fetchProtectedPackage", new object[] {
+                        packageGuid,
+                        memberKey});
+            return ((byte[])(results[0]));
+        }
+        
+        /// <remarks/>
+        public void fetchProtectedPackageAsync(string packageGuid, string memberKey) {
+            this.fetchProtectedPackageAsync(packageGuid, memberKey, null);
+        }
+        
+        /// <remarks/>
+        public void fetchProtectedPackageAsync(string packageGuid, string memberKey, object userState) {
+            if ((this.fetchProtectedPackageOperationCompleted == null)) {
+                this.fetchProtectedPackageOperationCompleted = new System.Threading.SendOrPostCallback(this.OnfetchProtectedPackageOperationCompleted);
+            }
+            this.InvokeAsync("fetchProtectedPackage", new object[] {
+                        packageGuid,
+                        memberKey}, this.fetchProtectedPackageOperationCompleted, userState);
+        }
+        
+        private void OnfetchProtectedPackageOperationCompleted(object arg) {
+            if ((this.fetchProtectedPackageCompleted != null)) {
+                System.Web.Services.Protocols.InvokeCompletedEventArgs invokeArgs = ((System.Web.Services.Protocols.InvokeCompletedEventArgs)(arg));
+                this.fetchProtectedPackageCompleted(this, new fetchProtectedPackageCompletedEventArgs(invokeArgs.Results, invokeArgs.Error, invokeArgs.Cancelled, invokeArgs.UserState));
+            }
+        }
+        
+        /// <remarks/>
+        [System.Web.Services.Protocols.SoapDocumentMethodAttribute("http://packages.umbraco.org/webservices/SubmitPackage", RequestNamespace="http://packages.umbraco.org/webservices/", ResponseNamespace="http://packages.umbraco.org/webservices/", Use=System.Web.Services.Description.SoapBindingUse.Literal, ParameterStyle=System.Web.Services.Protocols.SoapParameterStyle.Wrapped)]
+        public SubmitStatus SubmitPackage(string repositoryGuid, string authorGuid, string packageGuid, [System.Xml.Serialization.XmlElementAttribute(DataType="base64Binary")] byte[] packageFile, [System.Xml.Serialization.XmlElementAttribute(DataType="base64Binary")] byte[] packageDoc, [System.Xml.Serialization.XmlElementAttribute(DataType="base64Binary")] byte[] packageThumbnail, string name, string author, string authorUrl, string description) {
+            object[] results = this.Invoke("SubmitPackage", new object[] {
+                        repositoryGuid,
+                        authorGuid,
+                        packageGuid,
+                        packageFile,
+                        packageDoc,
+                        packageThumbnail,
+                        name,
+                        author,
+                        authorUrl,
+                        description});
+            return ((SubmitStatus)(results[0]));
+        }
+        
+        /// <remarks/>
+        public void SubmitPackageAsync(string repositoryGuid, string authorGuid, string packageGuid, byte[] packageFile, byte[] packageDoc, byte[] packageThumbnail, string name, string author, string authorUrl, string description) {
+            this.SubmitPackageAsync(repositoryGuid, authorGuid, packageGuid, packageFile, packageDoc, packageThumbnail, name, author, authorUrl, description, null);
+        }
+        
+        /// <remarks/>
+        public void SubmitPackageAsync(string repositoryGuid, string authorGuid, string packageGuid, byte[] packageFile, byte[] packageDoc, byte[] packageThumbnail, string name, string author, string authorUrl, string description, object userState) {
+            if ((this.SubmitPackageOperationCompleted == null)) {
+                this.SubmitPackageOperationCompleted = new System.Threading.SendOrPostCallback(this.OnSubmitPackageOperationCompleted);
+            }
+            this.InvokeAsync("SubmitPackage", new object[] {
+                        repositoryGuid,
+                        authorGuid,
+                        packageGuid,
+                        packageFile,
+                        packageDoc,
+                        packageThumbnail,
+                        name,
+                        author,
+                        authorUrl,
+                        description}, this.SubmitPackageOperationCompleted, userState);
+        }
+        
+        private void OnSubmitPackageOperationCompleted(object arg) {
+            if ((this.SubmitPackageCompleted != null)) {
+                System.Web.Services.Protocols.InvokeCompletedEventArgs invokeArgs = ((System.Web.Services.Protocols.InvokeCompletedEventArgs)(arg));
+                this.SubmitPackageCompleted(this, new SubmitPackageCompletedEventArgs(invokeArgs.Results, invokeArgs.Error, invokeArgs.Cancelled, invokeArgs.UserState));
+            }
+        }
+        
+        /// <remarks/>
+        [System.Web.Services.Protocols.SoapDocumentMethodAttribute("http://packages.umbraco.org/webservices/PackageByGuid", RequestNamespace="http://packages.umbraco.org/webservices/", ResponseNamespace="http://packages.umbraco.org/webservices/", Use=System.Web.Services.Description.SoapBindingUse.Literal, ParameterStyle=System.Web.Services.Protocols.SoapParameterStyle.Wrapped)]
+        public Package PackageByGuid(string packageGuid) {
+            object[] results = this.Invoke("PackageByGuid", new object[] {
+                        packageGuid});
+            return ((Package)(results[0]));
+        }
+        
+        /// <remarks/>
+        public void PackageByGuidAsync(string packageGuid) {
+            this.PackageByGuidAsync(packageGuid, null);
+        }
+        
+        /// <remarks/>
+        public void PackageByGuidAsync(string packageGuid, object userState) {
+            if ((this.PackageByGuidOperationCompleted == null)) {
+                this.PackageByGuidOperationCompleted = new System.Threading.SendOrPostCallback(this.OnPackageByGuidOperationCompleted);
+            }
+            this.InvokeAsync("PackageByGuid", new object[] {
+                        packageGuid}, this.PackageByGuidOperationCompleted, userState);
+        }
+        
+        private void OnPackageByGuidOperationCompleted(object arg) {
+            if ((this.PackageByGuidCompleted != null)) {
+                System.Web.Services.Protocols.InvokeCompletedEventArgs invokeArgs = ((System.Web.Services.Protocols.InvokeCompletedEventArgs)(arg));
+                this.PackageByGuidCompleted(this, new PackageByGuidCompletedEventArgs(invokeArgs.Results, invokeArgs.Error, invokeArgs.Cancelled, invokeArgs.UserState));
+            }
+        }
+        
+        /// <remarks/>
+        public new void CancelAsync(object userState) {
+            base.CancelAsync(userState);
+        }
+        
+        private bool IsLocalFileSystemWebService(string url) {
+            if (((url == null) 
+                        || (url == string.Empty))) {
+                return false;
+            }
+            System.Uri wsUri = new System.Uri(url);
+            if (((wsUri.Port >= 1024) 
+                        && (string.Compare(wsUri.Host, "localHost", System.StringComparison.OrdinalIgnoreCase) == 0))) {
+                return true;
+            }
+            return false;
+        }
+    }
+    
+    /// <remarks/>
+    [System.CodeDom.Compiler.GeneratedCodeAttribute("System.Xml", "4.7.3056.0")]
+    [System.SerializableAttribute()]
+    [System.Diagnostics.DebuggerStepThroughAttribute()]
+    [System.ComponentModel.DesignerCategoryAttribute("code")]
+    [System.Xml.Serialization.XmlTypeAttribute(Namespace="http://packages.umbraco.org/webservices/")]
+    public partial class Category {
+        
+        private string textField;
+        
+        private string descriptionField;
+        
+        private string urlField;
+        
+        private int idField;
+        
+        private Package[] packagesField;
+        
+        /// <remarks/>
+        public string Text {
+            get {
+                return this.textField;
+            }
+            set {
+                this.textField = value;
+            }
+        }
+        
+        /// <remarks/>
+        public string Description {
+            get {
+                return this.descriptionField;
+            }
+            set {
+                this.descriptionField = value;
+            }
+        }
+        
+        /// <remarks/>
+        public string Url {
+            get {
+                return this.urlField;
+            }
+            set {
+                this.urlField = value;
+            }
+        }
+        
+        /// <remarks/>
+        public int Id {
+            get {
+                return this.idField;
+            }
+            set {
+                this.idField = value;
+            }
+        }
+        
+        /// <remarks/>
+        public Package[] Packages {
+            get {
+                return this.packagesField;
+            }
+            set {
+                this.packagesField = value;
+            }
+        }
+    }
+    
+    /// <remarks/>
+    [System.CodeDom.Compiler.GeneratedCodeAttribute("System.Xml", "4.7.3056.0")]
+    [System.SerializableAttribute()]
+    [System.Diagnostics.DebuggerStepThroughAttribute()]
+    [System.ComponentModel.DesignerCategoryAttribute("code")]
+    [System.Xml.Serialization.XmlTypeAttribute(Namespace="http://packages.umbraco.org/webservices/")]
+    public partial class Package {
+        
+        private System.Guid repoGuidField;
+        
+        private string textField;
+        
+        private string descriptionField;
+        
+        private string iconField;
+        
+        private string thumbnailField;
+        
+        private string documentationField;
+        
+        private string demoField;
+        
+        private bool acceptedField;
+        
+        private bool isModuleField;
+        
+        private bool editorsPickField;
+        
+        private bool protectedField;
+        
+        private bool hasUpgradeField;
+        
+        private string upgradeVersionField;
+        
+        private string upgradeReadMeField;
+        
+        private string urlField;
+        
+        /// <remarks/>
+        public System.Guid RepoGuid {
+            get {
+                return this.repoGuidField;
+            }
+            set {
+                this.repoGuidField = value;
+            }
+        }
+        
+        /// <remarks/>
+        public string Text {
+            get {
+                return this.textField;
+            }
+            set {
+                this.textField = value;
+            }
+        }
+        
+        /// <remarks/>
+        public string Description {
+            get {
+                return this.descriptionField;
+            }
+            set {
+                this.descriptionField = value;
+            }
+        }
+        
+        /// <remarks/>
+        public string Icon {
+            get {
+                return this.iconField;
+            }
+            set {
+                this.iconField = value;
+            }
+        }
+        
+        /// <remarks/>
+        public string Thumbnail {
+            get {
+                return this.thumbnailField;
+            }
+            set {
+                this.thumbnailField = value;
+            }
+        }
+        
+        /// <remarks/>
+        public string Documentation {
+            get {
+                return this.documentationField;
+            }
+            set {
+                this.documentationField = value;
+            }
+        }
+        
+        /// <remarks/>
+        public string Demo {
+            get {
+                return this.demoField;
+            }
+            set {
+                this.demoField = value;
+            }
+        }
+        
+        /// <remarks/>
+        public bool Accepted {
+            get {
+                return this.acceptedField;
+            }
+            set {
+                this.acceptedField = value;
+            }
+        }
+        
+        /// <remarks/>
+        public bool IsModule {
+            get {
+                return this.isModuleField;
+            }
+            set {
+                this.isModuleField = value;
+            }
+        }
+        
+        /// <remarks/>
+        public bool EditorsPick {
+            get {
+                return this.editorsPickField;
+            }
+            set {
+                this.editorsPickField = value;
+            }
+        }
+        
+        /// <remarks/>
+        public bool Protected {
+            get {
+                return this.protectedField;
+            }
+            set {
+                this.protectedField = value;
+            }
+        }
+        
+        /// <remarks/>
+        public bool HasUpgrade {
+            get {
+                return this.hasUpgradeField;
+            }
+            set {
+                this.hasUpgradeField = value;
+            }
+        }
+        
+        /// <remarks/>
+        public string UpgradeVersion {
+            get {
+                return this.upgradeVersionField;
+            }
+            set {
+                this.upgradeVersionField = value;
+            }
+        }
+        
+        /// <remarks/>
+        public string UpgradeReadMe {
+            get {
+                return this.upgradeReadMeField;
+            }
+            set {
+                this.upgradeReadMeField = value;
+            }
+        }
+        
+        /// <remarks/>
+        public string Url {
+            get {
+                return this.urlField;
+            }
+            set {
+                this.urlField = value;
+            }
+        }
+    }
+    
+    /// <remarks/>
+    [System.CodeDom.Compiler.GeneratedCodeAttribute("System.Xml", "4.7.3056.0")]
+    [System.SerializableAttribute()]
+    [System.Xml.Serialization.XmlTypeAttribute(Namespace="http://packages.umbraco.org/webservices/")]
+    public enum SubmitStatus {
+        
+        /// <remarks/>
+        Complete,
+        
+        /// <remarks/>
+        Exists,
+        
+        /// <remarks/>
+        NoAccess,
+        
+        /// <remarks/>
+        Error,
+    }
+    
+    /// <remarks/>
+    [System.CodeDom.Compiler.GeneratedCodeAttribute("System.Web.Services", "4.7.3056.0")]
+    public delegate void CategoriesCompletedEventHandler(object sender, CategoriesCompletedEventArgs e);
+    
+    /// <remarks/>
+    [System.CodeDom.Compiler.GeneratedCodeAttribute("System.Web.Services", "4.7.3056.0")]
+    [System.Diagnostics.DebuggerStepThroughAttribute()]
+    [System.ComponentModel.DesignerCategoryAttribute("code")]
+    public partial class CategoriesCompletedEventArgs : System.ComponentModel.AsyncCompletedEventArgs {
+        
+        private object[] results;
+        
+        internal CategoriesCompletedEventArgs(object[] results, System.Exception exception, bool cancelled, object userState) : 
+                base(exception, cancelled, userState) {
+            this.results = results;
+        }
+        
+        /// <remarks/>
+        public Category[] Result {
+            get {
+                this.RaiseExceptionIfNecessary();
+                return ((Category[])(this.results[0]));
+            }
+        }
+    }
+    
+    /// <remarks/>
+    [System.CodeDom.Compiler.GeneratedCodeAttribute("System.Web.Services", "4.7.3056.0")]
+    public delegate void ModulesCompletedEventHandler(object sender, ModulesCompletedEventArgs e);
+    
+    /// <remarks/>
+    [System.CodeDom.Compiler.GeneratedCodeAttribute("System.Web.Services", "4.7.3056.0")]
+    [System.Diagnostics.DebuggerStepThroughAttribute()]
+    [System.ComponentModel.DesignerCategoryAttribute("code")]
+    public partial class ModulesCompletedEventArgs : System.ComponentModel.AsyncCompletedEventArgs {
+        
+        private object[] results;
+        
+        internal ModulesCompletedEventArgs(object[] results, System.Exception exception, bool cancelled, object userState) : 
+                base(exception, cancelled, userState) {
+            this.results = results;
+        }
+        
+        /// <remarks/>
+        public Package[] Result {
+            get {
+                this.RaiseExceptionIfNecessary();
+                return ((Package[])(this.results[0]));
+            }
+        }
+    }
+    
+    /// <remarks/>
+    [System.CodeDom.Compiler.GeneratedCodeAttribute("System.Web.Services", "4.7.3056.0")]
+    public delegate void ModulesCategorizedCompletedEventHandler(object sender, ModulesCategorizedCompletedEventArgs e);
+    
+    /// <remarks/>
+    [System.CodeDom.Compiler.GeneratedCodeAttribute("System.Web.Services", "4.7.3056.0")]
+    [System.Diagnostics.DebuggerStepThroughAttribute()]
+    [System.ComponentModel.DesignerCategoryAttribute("code")]
+    public partial class ModulesCategorizedCompletedEventArgs : System.ComponentModel.AsyncCompletedEventArgs {
+        
+        private object[] results;
+        
+        internal ModulesCategorizedCompletedEventArgs(object[] results, System.Exception exception, bool cancelled, object userState) : 
+                base(exception, cancelled, userState) {
+            this.results = results;
+        }
+        
+        /// <remarks/>
+        public Category[] Result {
+            get {
+                this.RaiseExceptionIfNecessary();
+                return ((Category[])(this.results[0]));
+            }
+        }
+    }
+    
+    /// <remarks/>
+    [System.CodeDom.Compiler.GeneratedCodeAttribute("System.Web.Services", "4.7.3056.0")]
+    public delegate void NitrosCompletedEventHandler(object sender, NitrosCompletedEventArgs e);
+    
+    /// <remarks/>
+    [System.CodeDom.Compiler.GeneratedCodeAttribute("System.Web.Services", "4.7.3056.0")]
+    [System.Diagnostics.DebuggerStepThroughAttribute()]
+    [System.ComponentModel.DesignerCategoryAttribute("code")]
+    public partial class NitrosCompletedEventArgs : System.ComponentModel.AsyncCompletedEventArgs {
+        
+        private object[] results;
+        
+        internal NitrosCompletedEventArgs(object[] results, System.Exception exception, bool cancelled, object userState) : 
+                base(exception, cancelled, userState) {
+            this.results = results;
+        }
+        
+        /// <remarks/>
+        public Package[] Result {
+            get {
+                this.RaiseExceptionIfNecessary();
+                return ((Package[])(this.results[0]));
+            }
+        }
+    }
+    
+    /// <remarks/>
+    [System.CodeDom.Compiler.GeneratedCodeAttribute("System.Web.Services", "4.7.3056.0")]
+    public delegate void NitrosCategorizedCompletedEventHandler(object sender, NitrosCategorizedCompletedEventArgs e);
+    
+    /// <remarks/>
+    [System.CodeDom.Compiler.GeneratedCodeAttribute("System.Web.Services", "4.7.3056.0")]
+    [System.Diagnostics.DebuggerStepThroughAttribute()]
+    [System.ComponentModel.DesignerCategoryAttribute("code")]
+    public partial class NitrosCategorizedCompletedEventArgs : System.ComponentModel.AsyncCompletedEventArgs {
+        
+        private object[] results;
+        
+        internal NitrosCategorizedCompletedEventArgs(object[] results, System.Exception exception, bool cancelled, object userState) : 
+                base(exception, cancelled, userState) {
+            this.results = results;
+        }
+        
+        /// <remarks/>
+        public Category[] Result {
+            get {
+                this.RaiseExceptionIfNecessary();
+                return ((Category[])(this.results[0]));
+            }
+        }
+    }
+    
+    /// <remarks/>
+    [System.CodeDom.Compiler.GeneratedCodeAttribute("System.Web.Services", "4.7.3056.0")]
+    public delegate void authenticateCompletedEventHandler(object sender, authenticateCompletedEventArgs e);
+    
+    /// <remarks/>
+    [System.CodeDom.Compiler.GeneratedCodeAttribute("System.Web.Services", "4.7.3056.0")]
+    [System.Diagnostics.DebuggerStepThroughAttribute()]
+    [System.ComponentModel.DesignerCategoryAttribute("code")]
+    public partial class authenticateCompletedEventArgs : System.ComponentModel.AsyncCompletedEventArgs {
+        
+        private object[] results;
+        
+        internal authenticateCompletedEventArgs(object[] results, System.Exception exception, bool cancelled, object userState) : 
+                base(exception, cancelled, userState) {
+            this.results = results;
+        }
+        
+        /// <remarks/>
+        public string Result {
+            get {
+                this.RaiseExceptionIfNecessary();
+                return ((string)(this.results[0]));
+            }
+        }
+    }
+    
+    /// <remarks/>
+    [System.CodeDom.Compiler.GeneratedCodeAttribute("System.Web.Services", "4.7.3056.0")]
+    public delegate void fetchPackageCompletedEventHandler(object sender, fetchPackageCompletedEventArgs e);
+    
+    /// <remarks/>
+    [System.CodeDom.Compiler.GeneratedCodeAttribute("System.Web.Services", "4.7.3056.0")]
+    [System.Diagnostics.DebuggerStepThroughAttribute()]
+    [System.ComponentModel.DesignerCategoryAttribute("code")]
+    public partial class fetchPackageCompletedEventArgs : System.ComponentModel.AsyncCompletedEventArgs {
+        
+        private object[] results;
+        
+        internal fetchPackageCompletedEventArgs(object[] results, System.Exception exception, bool cancelled, object userState) : 
+                base(exception, cancelled, userState) {
+            this.results = results;
+        }
+        
+        /// <remarks/>
+        public byte[] Result {
+            get {
+                this.RaiseExceptionIfNecessary();
+                return ((byte[])(this.results[0]));
+            }
+        }
+    }
+    
+    /// <remarks/>
+    [System.CodeDom.Compiler.GeneratedCodeAttribute("System.Web.Services", "4.7.3056.0")]
+    public delegate void fetchPackageByVersionCompletedEventHandler(object sender, fetchPackageByVersionCompletedEventArgs e);
+    
+    /// <remarks/>
+    [System.CodeDom.Compiler.GeneratedCodeAttribute("System.Web.Services", "4.7.3056.0")]
+    [System.Diagnostics.DebuggerStepThroughAttribute()]
+    [System.ComponentModel.DesignerCategoryAttribute("code")]
+    public partial class fetchPackageByVersionCompletedEventArgs : System.ComponentModel.AsyncCompletedEventArgs {
+        
+        private object[] results;
+        
+        internal fetchPackageByVersionCompletedEventArgs(object[] results, System.Exception exception, bool cancelled, object userState) : 
+                base(exception, cancelled, userState) {
+            this.results = results;
+        }
+        
+        /// <remarks/>
+        public byte[] Result {
+            get {
+                this.RaiseExceptionIfNecessary();
+                return ((byte[])(this.results[0]));
+            }
+        }
+    }
+    
+    /// <remarks/>
+    [System.CodeDom.Compiler.GeneratedCodeAttribute("System.Web.Services", "4.7.3056.0")]
+    public delegate void fetchProtectedPackageCompletedEventHandler(object sender, fetchProtectedPackageCompletedEventArgs e);
+    
+    /// <remarks/>
+    [System.CodeDom.Compiler.GeneratedCodeAttribute("System.Web.Services", "4.7.3056.0")]
+    [System.Diagnostics.DebuggerStepThroughAttribute()]
+    [System.ComponentModel.DesignerCategoryAttribute("code")]
+    public partial class fetchProtectedPackageCompletedEventArgs : System.ComponentModel.AsyncCompletedEventArgs {
+        
+        private object[] results;
+        
+        internal fetchProtectedPackageCompletedEventArgs(object[] results, System.Exception exception, bool cancelled, object userState) : 
+                base(exception, cancelled, userState) {
+            this.results = results;
+        }
+        
+        /// <remarks/>
+        public byte[] Result {
+            get {
+                this.RaiseExceptionIfNecessary();
+                return ((byte[])(this.results[0]));
+            }
+        }
+    }
+    
+    /// <remarks/>
+    [System.CodeDom.Compiler.GeneratedCodeAttribute("System.Web.Services", "4.7.3056.0")]
+    public delegate void SubmitPackageCompletedEventHandler(object sender, SubmitPackageCompletedEventArgs e);
+    
+    /// <remarks/>
+    [System.CodeDom.Compiler.GeneratedCodeAttribute("System.Web.Services", "4.7.3056.0")]
+    [System.Diagnostics.DebuggerStepThroughAttribute()]
+    [System.ComponentModel.DesignerCategoryAttribute("code")]
+    public partial class SubmitPackageCompletedEventArgs : System.ComponentModel.AsyncCompletedEventArgs {
+        
+        private object[] results;
+        
+        internal SubmitPackageCompletedEventArgs(object[] results, System.Exception exception, bool cancelled, object userState) : 
+                base(exception, cancelled, userState) {
+            this.results = results;
+        }
+        
+        /// <remarks/>
+        public SubmitStatus Result {
+            get {
+                this.RaiseExceptionIfNecessary();
+                return ((SubmitStatus)(this.results[0]));
+            }
+        }
+    }
+    
+    /// <remarks/>
+    [System.CodeDom.Compiler.GeneratedCodeAttribute("System.Web.Services", "4.7.3056.0")]
+    public delegate void PackageByGuidCompletedEventHandler(object sender, PackageByGuidCompletedEventArgs e);
+    
+    /// <remarks/>
+    [System.CodeDom.Compiler.GeneratedCodeAttribute("System.Web.Services", "4.7.3056.0")]
+    [System.Diagnostics.DebuggerStepThroughAttribute()]
+    [System.ComponentModel.DesignerCategoryAttribute("code")]
+    public partial class PackageByGuidCompletedEventArgs : System.ComponentModel.AsyncCompletedEventArgs {
+        
+        private object[] results;
+        
+        internal PackageByGuidCompletedEventArgs(object[] results, System.Exception exception, bool cancelled, object userState) : 
+                base(exception, cancelled, userState) {
+            this.results = results;
+        }
+        
+        /// <remarks/>
+        public Package Result {
+            get {
+                this.RaiseExceptionIfNecessary();
+                return ((Package)(this.results[0]));
+            }
+        }
+    }
+}
+
+#pragma warning restore 1591
\ No newline at end of file
diff --git a/src/Umbraco.Web/Web References/org.umbraco.our/Reference.map b/src/Umbraco.Web/Web References/org.umbraco.our/Reference.map
new file mode 100644
index 0000000000..cd819c5591
--- /dev/null
+++ b/src/Umbraco.Web/Web References/org.umbraco.our/Reference.map	
@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="utf-8"?>
+<DiscoveryClientResultsFile xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema">
+  <Results>
+    <DiscoveryClientResult referenceType="System.Web.Services.Discovery.ContractReference" url="https://our.umbraco.com/umbraco/webservices/api/repository.asmx?wsdl" filename="repository.wsdl" />
+    <DiscoveryClientResult referenceType="System.Web.Services.Discovery.DiscoveryDocumentReference" url="https://our.umbraco.com/umbraco/webservices/api/repository.asmx?disco" filename="repository.disco" />
+  </Results>
+</DiscoveryClientResultsFile>
\ No newline at end of file
diff --git a/src/Umbraco.Web/Web References/org.umbraco.our/repository.disco b/src/Umbraco.Web/Web References/org.umbraco.our/repository.disco
new file mode 100644
index 0000000000..fcc65dea0c
--- /dev/null
+++ b/src/Umbraco.Web/Web References/org.umbraco.our/repository.disco	
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="utf-8"?>
+<discovery xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns="http://schemas.xmlsoap.org/disco/">
+  <contractRef ref="https://our.umbraco.com/umbraco/webservices/api/repository.asmx?wsdl" docRef="https://our.umbraco.com/umbraco/webservices/api/repository.asmx" xmlns="http://schemas.xmlsoap.org/disco/scl/" />
+  <soap address="https://our.umbraco.com/umbraco/webservices/api/repository.asmx" xmlns:q1="http://packages.umbraco.org/webservices/" binding="q1:RepositorySoap" xmlns="http://schemas.xmlsoap.org/disco/soap/" />
+  <soap address="https://our.umbraco.com/umbraco/webservices/api/repository.asmx" xmlns:q2="http://packages.umbraco.org/webservices/" binding="q2:RepositorySoap12" xmlns="http://schemas.xmlsoap.org/disco/soap/" />
+</discovery>
\ No newline at end of file
diff --git a/src/Umbraco.Web/Web References/org.umbraco.our/repository.wsdl b/src/Umbraco.Web/Web References/org.umbraco.our/repository.wsdl
new file mode 100644
index 0000000000..17d24e9c54
--- /dev/null
+++ b/src/Umbraco.Web/Web References/org.umbraco.our/repository.wsdl	
@@ -0,0 +1,995 @@
+<?xml version="1.0" encoding="utf-8"?>
+<wsdl:definitions xmlns:soap="http://schemas.xmlsoap.org/wsdl/soap/" xmlns:soapenc="http://schemas.xmlsoap.org/soap/encoding/" xmlns:tm="http://microsoft.com/wsdl/mime/textMatching/" xmlns:mime="http://schemas.xmlsoap.org/wsdl/mime/" xmlns:tns="http://packages.umbraco.org/webservices/" xmlns:s1="http://microsoft.com/wsdl/types/" xmlns:http="http://schemas.xmlsoap.org/wsdl/http/" xmlns:s="http://www.w3.org/2001/XMLSchema" xmlns:s2="http://packages.umbraco.org/webservices/AbstractTypes" xmlns:soap12="http://schemas.xmlsoap.org/wsdl/soap12/" targetNamespace="http://packages.umbraco.org/webservices/" xmlns:wsdl="http://schemas.xmlsoap.org/wsdl/">
+  <wsdl:types>
+    <s:schema elementFormDefault="qualified" targetNamespace="http://packages.umbraco.org/webservices/">
+      <s:import namespace="http://microsoft.com/wsdl/types/" />
+      <s:element name="Categories">
+        <s:complexType>
+          <s:sequence>
+            <s:element minOccurs="0" maxOccurs="1" name="repositoryGuid" type="s:string" />
+          </s:sequence>
+        </s:complexType>
+      </s:element>
+      <s:element name="CategoriesResponse">
+        <s:complexType>
+          <s:sequence>
+            <s:element minOccurs="0" maxOccurs="1" name="CategoriesResult" type="tns:ArrayOfCategory" />
+          </s:sequence>
+        </s:complexType>
+      </s:element>
+      <s:complexType name="ArrayOfCategory">
+        <s:sequence>
+          <s:element minOccurs="0" maxOccurs="unbounded" name="Category" nillable="true" type="tns:Category" />
+        </s:sequence>
+      </s:complexType>
+      <s:complexType name="Category">
+        <s:sequence>
+          <s:element minOccurs="0" maxOccurs="1" name="Text" type="s:string" />
+          <s:element minOccurs="0" maxOccurs="1" name="Description" type="s:string" />
+          <s:element minOccurs="0" maxOccurs="1" name="Url" type="s:string" />
+          <s:element minOccurs="1" maxOccurs="1" name="Id" type="s:int" />
+          <s:element minOccurs="0" maxOccurs="1" name="Packages" type="tns:ArrayOfPackage" />
+        </s:sequence>
+      </s:complexType>
+      <s:complexType name="ArrayOfPackage">
+        <s:sequence>
+          <s:element minOccurs="0" maxOccurs="unbounded" name="Package" nillable="true" type="tns:Package" />
+        </s:sequence>
+      </s:complexType>
+      <s:complexType name="Package">
+        <s:sequence>
+          <s:element minOccurs="1" maxOccurs="1" name="RepoGuid" type="s1:guid" />
+          <s:element minOccurs="0" maxOccurs="1" name="Text" type="s:string" />
+          <s:element minOccurs="0" maxOccurs="1" name="Description" type="s:string" />
+          <s:element minOccurs="0" maxOccurs="1" name="Icon" type="s:string" />
+          <s:element minOccurs="0" maxOccurs="1" name="Thumbnail" type="s:string" />
+          <s:element minOccurs="0" maxOccurs="1" name="Documentation" type="s:string" />
+          <s:element minOccurs="0" maxOccurs="1" name="Demo" type="s:string" />
+          <s:element minOccurs="1" maxOccurs="1" name="Accepted" type="s:boolean" />
+          <s:element minOccurs="1" maxOccurs="1" name="IsModule" type="s:boolean" />
+          <s:element minOccurs="1" maxOccurs="1" name="EditorsPick" type="s:boolean" />
+          <s:element minOccurs="1" maxOccurs="1" name="Protected" type="s:boolean" />
+          <s:element minOccurs="1" maxOccurs="1" name="HasUpgrade" type="s:boolean" />
+          <s:element minOccurs="0" maxOccurs="1" name="UpgradeVersion" type="s:string" />
+          <s:element minOccurs="0" maxOccurs="1" name="UpgradeReadMe" type="s:string" />
+          <s:element minOccurs="0" maxOccurs="1" name="Url" type="s:string" />
+        </s:sequence>
+      </s:complexType>
+      <s:element name="Modules">
+        <s:complexType />
+      </s:element>
+      <s:element name="ModulesResponse">
+        <s:complexType>
+          <s:sequence>
+            <s:element minOccurs="0" maxOccurs="1" name="ModulesResult" type="tns:ArrayOfPackage" />
+          </s:sequence>
+        </s:complexType>
+      </s:element>
+      <s:element name="ModulesCategorized">
+        <s:complexType />
+      </s:element>
+      <s:element name="ModulesCategorizedResponse">
+        <s:complexType>
+          <s:sequence>
+            <s:element minOccurs="0" maxOccurs="1" name="ModulesCategorizedResult" type="tns:ArrayOfCategory" />
+          </s:sequence>
+        </s:complexType>
+      </s:element>
+      <s:element name="Nitros">
+        <s:complexType />
+      </s:element>
+      <s:element name="NitrosResponse">
+        <s:complexType>
+          <s:sequence>
+            <s:element minOccurs="0" maxOccurs="1" name="NitrosResult" type="tns:ArrayOfPackage" />
+          </s:sequence>
+        </s:complexType>
+      </s:element>
+      <s:element name="NitrosCategorized">
+        <s:complexType />
+      </s:element>
+      <s:element name="NitrosCategorizedResponse">
+        <s:complexType>
+          <s:sequence>
+            <s:element minOccurs="0" maxOccurs="1" name="NitrosCategorizedResult" type="tns:ArrayOfCategory" />
+          </s:sequence>
+        </s:complexType>
+      </s:element>
+      <s:element name="authenticate">
+        <s:complexType>
+          <s:sequence>
+            <s:element minOccurs="0" maxOccurs="1" name="email" type="s:string" />
+            <s:element minOccurs="0" maxOccurs="1" name="md5Password" type="s:string" />
+          </s:sequence>
+        </s:complexType>
+      </s:element>
+      <s:element name="authenticateResponse">
+        <s:complexType>
+          <s:sequence>
+            <s:element minOccurs="0" maxOccurs="1" name="authenticateResult" type="s:string" />
+          </s:sequence>
+        </s:complexType>
+      </s:element>
+      <s:element name="fetchPackage">
+        <s:complexType>
+          <s:sequence>
+            <s:element minOccurs="0" maxOccurs="1" name="packageGuid" type="s:string" />
+          </s:sequence>
+        </s:complexType>
+      </s:element>
+      <s:element name="fetchPackageResponse">
+        <s:complexType>
+          <s:sequence>
+            <s:element minOccurs="0" maxOccurs="1" name="fetchPackageResult" type="s:base64Binary" />
+          </s:sequence>
+        </s:complexType>
+      </s:element>
+      <s:element name="fetchPackageByVersion">
+        <s:complexType>
+          <s:sequence>
+            <s:element minOccurs="0" maxOccurs="1" name="packageGuid" type="s:string" />
+            <s:element minOccurs="0" maxOccurs="1" name="repoVersion" type="s:string" />
+          </s:sequence>
+        </s:complexType>
+      </s:element>
+      <s:element name="fetchPackageByVersionResponse">
+        <s:complexType>
+          <s:sequence>
+            <s:element minOccurs="0" maxOccurs="1" name="fetchPackageByVersionResult" type="s:base64Binary" />
+          </s:sequence>
+        </s:complexType>
+      </s:element>
+      <s:element name="fetchProtectedPackage">
+        <s:complexType>
+          <s:sequence>
+            <s:element minOccurs="0" maxOccurs="1" name="packageGuid" type="s:string" />
+            <s:element minOccurs="0" maxOccurs="1" name="memberKey" type="s:string" />
+          </s:sequence>
+        </s:complexType>
+      </s:element>
+      <s:element name="fetchProtectedPackageResponse">
+        <s:complexType>
+          <s:sequence>
+            <s:element minOccurs="0" maxOccurs="1" name="fetchProtectedPackageResult" type="s:base64Binary" />
+          </s:sequence>
+        </s:complexType>
+      </s:element>
+      <s:element name="SubmitPackage">
+        <s:complexType>
+          <s:sequence>
+            <s:element minOccurs="0" maxOccurs="1" name="repositoryGuid" type="s:string" />
+            <s:element minOccurs="0" maxOccurs="1" name="authorGuid" type="s:string" />
+            <s:element minOccurs="0" maxOccurs="1" name="packageGuid" type="s:string" />
+            <s:element minOccurs="0" maxOccurs="1" name="packageFile" type="s:base64Binary" />
+            <s:element minOccurs="0" maxOccurs="1" name="packageDoc" type="s:base64Binary" />
+            <s:element minOccurs="0" maxOccurs="1" name="packageThumbnail" type="s:base64Binary" />
+            <s:element minOccurs="0" maxOccurs="1" name="name" type="s:string" />
+            <s:element minOccurs="0" maxOccurs="1" name="author" type="s:string" />
+            <s:element minOccurs="0" maxOccurs="1" name="authorUrl" type="s:string" />
+            <s:element minOccurs="0" maxOccurs="1" name="description" type="s:string" />
+          </s:sequence>
+        </s:complexType>
+      </s:element>
+      <s:element name="SubmitPackageResponse">
+        <s:complexType>
+          <s:sequence>
+            <s:element minOccurs="1" maxOccurs="1" name="SubmitPackageResult" type="tns:SubmitStatus" />
+          </s:sequence>
+        </s:complexType>
+      </s:element>
+      <s:simpleType name="SubmitStatus">
+        <s:restriction base="s:string">
+          <s:enumeration value="Complete" />
+          <s:enumeration value="Exists" />
+          <s:enumeration value="NoAccess" />
+          <s:enumeration value="Error" />
+        </s:restriction>
+      </s:simpleType>
+      <s:element name="PackageByGuid">
+        <s:complexType>
+          <s:sequence>
+            <s:element minOccurs="0" maxOccurs="1" name="packageGuid" type="s:string" />
+          </s:sequence>
+        </s:complexType>
+      </s:element>
+      <s:element name="PackageByGuidResponse">
+        <s:complexType>
+          <s:sequence>
+            <s:element minOccurs="0" maxOccurs="1" name="PackageByGuidResult" type="tns:Package" />
+          </s:sequence>
+        </s:complexType>
+      </s:element>
+      <s:element name="ArrayOfCategory" nillable="true" type="tns:ArrayOfCategory" />
+      <s:element name="ArrayOfPackage" nillable="true" type="tns:ArrayOfPackage" />
+      <s:element name="string" nillable="true" type="s:string" />
+      <s:element name="base64Binary" nillable="true" type="s:base64Binary" />
+      <s:element name="SubmitStatus" type="tns:SubmitStatus" />
+      <s:element name="Package" nillable="true" type="tns:Package" />
+    </s:schema>
+    <s:schema elementFormDefault="qualified" targetNamespace="http://microsoft.com/wsdl/types/">
+      <s:simpleType name="guid">
+        <s:restriction base="s:string">
+          <s:pattern value="[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}" />
+        </s:restriction>
+      </s:simpleType>
+    </s:schema>
+    <s:schema targetNamespace="http://packages.umbraco.org/webservices/AbstractTypes">
+      <s:import namespace="http://schemas.xmlsoap.org/soap/encoding/" />
+      <s:complexType name="StringArray">
+        <s:complexContent mixed="false">
+          <s:restriction base="soapenc:Array">
+            <s:sequence>
+              <s:element minOccurs="0" maxOccurs="unbounded" name="String" type="s:string" />
+            </s:sequence>
+          </s:restriction>
+        </s:complexContent>
+      </s:complexType>
+    </s:schema>
+  </wsdl:types>
+  <wsdl:message name="CategoriesSoapIn">
+    <wsdl:part name="parameters" element="tns:Categories" />
+  </wsdl:message>
+  <wsdl:message name="CategoriesSoapOut">
+    <wsdl:part name="parameters" element="tns:CategoriesResponse" />
+  </wsdl:message>
+  <wsdl:message name="ModulesSoapIn">
+    <wsdl:part name="parameters" element="tns:Modules" />
+  </wsdl:message>
+  <wsdl:message name="ModulesSoapOut">
+    <wsdl:part name="parameters" element="tns:ModulesResponse" />
+  </wsdl:message>
+  <wsdl:message name="ModulesCategorizedSoapIn">
+    <wsdl:part name="parameters" element="tns:ModulesCategorized" />
+  </wsdl:message>
+  <wsdl:message name="ModulesCategorizedSoapOut">
+    <wsdl:part name="parameters" element="tns:ModulesCategorizedResponse" />
+  </wsdl:message>
+  <wsdl:message name="NitrosSoapIn">
+    <wsdl:part name="parameters" element="tns:Nitros" />
+  </wsdl:message>
+  <wsdl:message name="NitrosSoapOut">
+    <wsdl:part name="parameters" element="tns:NitrosResponse" />
+  </wsdl:message>
+  <wsdl:message name="NitrosCategorizedSoapIn">
+    <wsdl:part name="parameters" element="tns:NitrosCategorized" />
+  </wsdl:message>
+  <wsdl:message name="NitrosCategorizedSoapOut">
+    <wsdl:part name="parameters" element="tns:NitrosCategorizedResponse" />
+  </wsdl:message>
+  <wsdl:message name="authenticateSoapIn">
+    <wsdl:part name="parameters" element="tns:authenticate" />
+  </wsdl:message>
+  <wsdl:message name="authenticateSoapOut">
+    <wsdl:part name="parameters" element="tns:authenticateResponse" />
+  </wsdl:message>
+  <wsdl:message name="fetchPackageSoapIn">
+    <wsdl:part name="parameters" element="tns:fetchPackage" />
+  </wsdl:message>
+  <wsdl:message name="fetchPackageSoapOut">
+    <wsdl:part name="parameters" element="tns:fetchPackageResponse" />
+  </wsdl:message>
+  <wsdl:message name="fetchPackageByVersionSoapIn">
+    <wsdl:part name="parameters" element="tns:fetchPackageByVersion" />
+  </wsdl:message>
+  <wsdl:message name="fetchPackageByVersionSoapOut">
+    <wsdl:part name="parameters" element="tns:fetchPackageByVersionResponse" />
+  </wsdl:message>
+  <wsdl:message name="fetchProtectedPackageSoapIn">
+    <wsdl:part name="parameters" element="tns:fetchProtectedPackage" />
+  </wsdl:message>
+  <wsdl:message name="fetchProtectedPackageSoapOut">
+    <wsdl:part name="parameters" element="tns:fetchProtectedPackageResponse" />
+  </wsdl:message>
+  <wsdl:message name="SubmitPackageSoapIn">
+    <wsdl:part name="parameters" element="tns:SubmitPackage" />
+  </wsdl:message>
+  <wsdl:message name="SubmitPackageSoapOut">
+    <wsdl:part name="parameters" element="tns:SubmitPackageResponse" />
+  </wsdl:message>
+  <wsdl:message name="PackageByGuidSoapIn">
+    <wsdl:part name="parameters" element="tns:PackageByGuid" />
+  </wsdl:message>
+  <wsdl:message name="PackageByGuidSoapOut">
+    <wsdl:part name="parameters" element="tns:PackageByGuidResponse" />
+  </wsdl:message>
+  <wsdl:message name="CategoriesHttpGetIn">
+    <wsdl:part name="repositoryGuid" type="s:string" />
+  </wsdl:message>
+  <wsdl:message name="CategoriesHttpGetOut">
+    <wsdl:part name="Body" element="tns:ArrayOfCategory" />
+  </wsdl:message>
+  <wsdl:message name="ModulesHttpGetIn" />
+  <wsdl:message name="ModulesHttpGetOut">
+    <wsdl:part name="Body" element="tns:ArrayOfPackage" />
+  </wsdl:message>
+  <wsdl:message name="ModulesCategorizedHttpGetIn" />
+  <wsdl:message name="ModulesCategorizedHttpGetOut">
+    <wsdl:part name="Body" element="tns:ArrayOfCategory" />
+  </wsdl:message>
+  <wsdl:message name="NitrosHttpGetIn" />
+  <wsdl:message name="NitrosHttpGetOut">
+    <wsdl:part name="Body" element="tns:ArrayOfPackage" />
+  </wsdl:message>
+  <wsdl:message name="NitrosCategorizedHttpGetIn" />
+  <wsdl:message name="NitrosCategorizedHttpGetOut">
+    <wsdl:part name="Body" element="tns:ArrayOfCategory" />
+  </wsdl:message>
+  <wsdl:message name="authenticateHttpGetIn">
+    <wsdl:part name="email" type="s:string" />
+    <wsdl:part name="md5Password" type="s:string" />
+  </wsdl:message>
+  <wsdl:message name="authenticateHttpGetOut">
+    <wsdl:part name="Body" element="tns:string" />
+  </wsdl:message>
+  <wsdl:message name="fetchPackageHttpGetIn">
+    <wsdl:part name="packageGuid" type="s:string" />
+  </wsdl:message>
+  <wsdl:message name="fetchPackageHttpGetOut">
+    <wsdl:part name="Body" element="tns:base64Binary" />
+  </wsdl:message>
+  <wsdl:message name="fetchPackageByVersionHttpGetIn">
+    <wsdl:part name="packageGuid" type="s:string" />
+    <wsdl:part name="repoVersion" type="s:string" />
+  </wsdl:message>
+  <wsdl:message name="fetchPackageByVersionHttpGetOut">
+    <wsdl:part name="Body" element="tns:base64Binary" />
+  </wsdl:message>
+  <wsdl:message name="fetchProtectedPackageHttpGetIn">
+    <wsdl:part name="packageGuid" type="s:string" />
+    <wsdl:part name="memberKey" type="s:string" />
+  </wsdl:message>
+  <wsdl:message name="fetchProtectedPackageHttpGetOut">
+    <wsdl:part name="Body" element="tns:base64Binary" />
+  </wsdl:message>
+  <wsdl:message name="SubmitPackageHttpGetIn">
+    <wsdl:part name="repositoryGuid" type="s:string" />
+    <wsdl:part name="authorGuid" type="s:string" />
+    <wsdl:part name="packageGuid" type="s:string" />
+    <wsdl:part name="packageFile" type="s2:StringArray" />
+    <wsdl:part name="packageDoc" type="s2:StringArray" />
+    <wsdl:part name="packageThumbnail" type="s2:StringArray" />
+    <wsdl:part name="name" type="s:string" />
+    <wsdl:part name="author" type="s:string" />
+    <wsdl:part name="authorUrl" type="s:string" />
+    <wsdl:part name="description" type="s:string" />
+  </wsdl:message>
+  <wsdl:message name="SubmitPackageHttpGetOut">
+    <wsdl:part name="Body" element="tns:SubmitStatus" />
+  </wsdl:message>
+  <wsdl:message name="PackageByGuidHttpGetIn">
+    <wsdl:part name="packageGuid" type="s:string" />
+  </wsdl:message>
+  <wsdl:message name="PackageByGuidHttpGetOut">
+    <wsdl:part name="Body" element="tns:Package" />
+  </wsdl:message>
+  <wsdl:message name="CategoriesHttpPostIn">
+    <wsdl:part name="repositoryGuid" type="s:string" />
+  </wsdl:message>
+  <wsdl:message name="CategoriesHttpPostOut">
+    <wsdl:part name="Body" element="tns:ArrayOfCategory" />
+  </wsdl:message>
+  <wsdl:message name="ModulesHttpPostIn" />
+  <wsdl:message name="ModulesHttpPostOut">
+    <wsdl:part name="Body" element="tns:ArrayOfPackage" />
+  </wsdl:message>
+  <wsdl:message name="ModulesCategorizedHttpPostIn" />
+  <wsdl:message name="ModulesCategorizedHttpPostOut">
+    <wsdl:part name="Body" element="tns:ArrayOfCategory" />
+  </wsdl:message>
+  <wsdl:message name="NitrosHttpPostIn" />
+  <wsdl:message name="NitrosHttpPostOut">
+    <wsdl:part name="Body" element="tns:ArrayOfPackage" />
+  </wsdl:message>
+  <wsdl:message name="NitrosCategorizedHttpPostIn" />
+  <wsdl:message name="NitrosCategorizedHttpPostOut">
+    <wsdl:part name="Body" element="tns:ArrayOfCategory" />
+  </wsdl:message>
+  <wsdl:message name="authenticateHttpPostIn">
+    <wsdl:part name="email" type="s:string" />
+    <wsdl:part name="md5Password" type="s:string" />
+  </wsdl:message>
+  <wsdl:message name="authenticateHttpPostOut">
+    <wsdl:part name="Body" element="tns:string" />
+  </wsdl:message>
+  <wsdl:message name="fetchPackageHttpPostIn">
+    <wsdl:part name="packageGuid" type="s:string" />
+  </wsdl:message>
+  <wsdl:message name="fetchPackageHttpPostOut">
+    <wsdl:part name="Body" element="tns:base64Binary" />
+  </wsdl:message>
+  <wsdl:message name="fetchPackageByVersionHttpPostIn">
+    <wsdl:part name="packageGuid" type="s:string" />
+    <wsdl:part name="repoVersion" type="s:string" />
+  </wsdl:message>
+  <wsdl:message name="fetchPackageByVersionHttpPostOut">
+    <wsdl:part name="Body" element="tns:base64Binary" />
+  </wsdl:message>
+  <wsdl:message name="fetchProtectedPackageHttpPostIn">
+    <wsdl:part name="packageGuid" type="s:string" />
+    <wsdl:part name="memberKey" type="s:string" />
+  </wsdl:message>
+  <wsdl:message name="fetchProtectedPackageHttpPostOut">
+    <wsdl:part name="Body" element="tns:base64Binary" />
+  </wsdl:message>
+  <wsdl:message name="SubmitPackageHttpPostIn">
+    <wsdl:part name="repositoryGuid" type="s:string" />
+    <wsdl:part name="authorGuid" type="s:string" />
+    <wsdl:part name="packageGuid" type="s:string" />
+    <wsdl:part name="packageFile" type="s2:StringArray" />
+    <wsdl:part name="packageDoc" type="s2:StringArray" />
+    <wsdl:part name="packageThumbnail" type="s2:StringArray" />
+    <wsdl:part name="name" type="s:string" />
+    <wsdl:part name="author" type="s:string" />
+    <wsdl:part name="authorUrl" type="s:string" />
+    <wsdl:part name="description" type="s:string" />
+  </wsdl:message>
+  <wsdl:message name="SubmitPackageHttpPostOut">
+    <wsdl:part name="Body" element="tns:SubmitStatus" />
+  </wsdl:message>
+  <wsdl:message name="PackageByGuidHttpPostIn">
+    <wsdl:part name="packageGuid" type="s:string" />
+  </wsdl:message>
+  <wsdl:message name="PackageByGuidHttpPostOut">
+    <wsdl:part name="Body" element="tns:Package" />
+  </wsdl:message>
+  <wsdl:portType name="RepositorySoap">
+    <wsdl:operation name="Categories">
+      <wsdl:input message="tns:CategoriesSoapIn" />
+      <wsdl:output message="tns:CategoriesSoapOut" />
+    </wsdl:operation>
+    <wsdl:operation name="Modules">
+      <wsdl:input message="tns:ModulesSoapIn" />
+      <wsdl:output message="tns:ModulesSoapOut" />
+    </wsdl:operation>
+    <wsdl:operation name="ModulesCategorized">
+      <wsdl:input message="tns:ModulesCategorizedSoapIn" />
+      <wsdl:output message="tns:ModulesCategorizedSoapOut" />
+    </wsdl:operation>
+    <wsdl:operation name="Nitros">
+      <wsdl:input message="tns:NitrosSoapIn" />
+      <wsdl:output message="tns:NitrosSoapOut" />
+    </wsdl:operation>
+    <wsdl:operation name="NitrosCategorized">
+      <wsdl:input message="tns:NitrosCategorizedSoapIn" />
+      <wsdl:output message="tns:NitrosCategorizedSoapOut" />
+    </wsdl:operation>
+    <wsdl:operation name="authenticate">
+      <wsdl:input message="tns:authenticateSoapIn" />
+      <wsdl:output message="tns:authenticateSoapOut" />
+    </wsdl:operation>
+    <wsdl:operation name="fetchPackage">
+      <wsdl:input message="tns:fetchPackageSoapIn" />
+      <wsdl:output message="tns:fetchPackageSoapOut" />
+    </wsdl:operation>
+    <wsdl:operation name="fetchPackageByVersion">
+      <wsdl:input message="tns:fetchPackageByVersionSoapIn" />
+      <wsdl:output message="tns:fetchPackageByVersionSoapOut" />
+    </wsdl:operation>
+    <wsdl:operation name="fetchProtectedPackage">
+      <wsdl:input message="tns:fetchProtectedPackageSoapIn" />
+      <wsdl:output message="tns:fetchProtectedPackageSoapOut" />
+    </wsdl:operation>
+    <wsdl:operation name="SubmitPackage">
+      <wsdl:input message="tns:SubmitPackageSoapIn" />
+      <wsdl:output message="tns:SubmitPackageSoapOut" />
+    </wsdl:operation>
+    <wsdl:operation name="PackageByGuid">
+      <wsdl:input message="tns:PackageByGuidSoapIn" />
+      <wsdl:output message="tns:PackageByGuidSoapOut" />
+    </wsdl:operation>
+  </wsdl:portType>
+  <wsdl:portType name="RepositoryHttpGet">
+    <wsdl:operation name="Categories">
+      <wsdl:input message="tns:CategoriesHttpGetIn" />
+      <wsdl:output message="tns:CategoriesHttpGetOut" />
+    </wsdl:operation>
+    <wsdl:operation name="Modules">
+      <wsdl:input message="tns:ModulesHttpGetIn" />
+      <wsdl:output message="tns:ModulesHttpGetOut" />
+    </wsdl:operation>
+    <wsdl:operation name="ModulesCategorized">
+      <wsdl:input message="tns:ModulesCategorizedHttpGetIn" />
+      <wsdl:output message="tns:ModulesCategorizedHttpGetOut" />
+    </wsdl:operation>
+    <wsdl:operation name="Nitros">
+      <wsdl:input message="tns:NitrosHttpGetIn" />
+      <wsdl:output message="tns:NitrosHttpGetOut" />
+    </wsdl:operation>
+    <wsdl:operation name="NitrosCategorized">
+      <wsdl:input message="tns:NitrosCategorizedHttpGetIn" />
+      <wsdl:output message="tns:NitrosCategorizedHttpGetOut" />
+    </wsdl:operation>
+    <wsdl:operation name="authenticate">
+      <wsdl:input message="tns:authenticateHttpGetIn" />
+      <wsdl:output message="tns:authenticateHttpGetOut" />
+    </wsdl:operation>
+    <wsdl:operation name="fetchPackage">
+      <wsdl:input message="tns:fetchPackageHttpGetIn" />
+      <wsdl:output message="tns:fetchPackageHttpGetOut" />
+    </wsdl:operation>
+    <wsdl:operation name="fetchPackageByVersion">
+      <wsdl:input message="tns:fetchPackageByVersionHttpGetIn" />
+      <wsdl:output message="tns:fetchPackageByVersionHttpGetOut" />
+    </wsdl:operation>
+    <wsdl:operation name="fetchProtectedPackage">
+      <wsdl:input message="tns:fetchProtectedPackageHttpGetIn" />
+      <wsdl:output message="tns:fetchProtectedPackageHttpGetOut" />
+    </wsdl:operation>
+    <wsdl:operation name="SubmitPackage">
+      <wsdl:input message="tns:SubmitPackageHttpGetIn" />
+      <wsdl:output message="tns:SubmitPackageHttpGetOut" />
+    </wsdl:operation>
+    <wsdl:operation name="PackageByGuid">
+      <wsdl:input message="tns:PackageByGuidHttpGetIn" />
+      <wsdl:output message="tns:PackageByGuidHttpGetOut" />
+    </wsdl:operation>
+  </wsdl:portType>
+  <wsdl:portType name="RepositoryHttpPost">
+    <wsdl:operation name="Categories">
+      <wsdl:input message="tns:CategoriesHttpPostIn" />
+      <wsdl:output message="tns:CategoriesHttpPostOut" />
+    </wsdl:operation>
+    <wsdl:operation name="Modules">
+      <wsdl:input message="tns:ModulesHttpPostIn" />
+      <wsdl:output message="tns:ModulesHttpPostOut" />
+    </wsdl:operation>
+    <wsdl:operation name="ModulesCategorized">
+      <wsdl:input message="tns:ModulesCategorizedHttpPostIn" />
+      <wsdl:output message="tns:ModulesCategorizedHttpPostOut" />
+    </wsdl:operation>
+    <wsdl:operation name="Nitros">
+      <wsdl:input message="tns:NitrosHttpPostIn" />
+      <wsdl:output message="tns:NitrosHttpPostOut" />
+    </wsdl:operation>
+    <wsdl:operation name="NitrosCategorized">
+      <wsdl:input message="tns:NitrosCategorizedHttpPostIn" />
+      <wsdl:output message="tns:NitrosCategorizedHttpPostOut" />
+    </wsdl:operation>
+    <wsdl:operation name="authenticate">
+      <wsdl:input message="tns:authenticateHttpPostIn" />
+      <wsdl:output message="tns:authenticateHttpPostOut" />
+    </wsdl:operation>
+    <wsdl:operation name="fetchPackage">
+      <wsdl:input message="tns:fetchPackageHttpPostIn" />
+      <wsdl:output message="tns:fetchPackageHttpPostOut" />
+    </wsdl:operation>
+    <wsdl:operation name="fetchPackageByVersion">
+      <wsdl:input message="tns:fetchPackageByVersionHttpPostIn" />
+      <wsdl:output message="tns:fetchPackageByVersionHttpPostOut" />
+    </wsdl:operation>
+    <wsdl:operation name="fetchProtectedPackage">
+      <wsdl:input message="tns:fetchProtectedPackageHttpPostIn" />
+      <wsdl:output message="tns:fetchProtectedPackageHttpPostOut" />
+    </wsdl:operation>
+    <wsdl:operation name="SubmitPackage">
+      <wsdl:input message="tns:SubmitPackageHttpPostIn" />
+      <wsdl:output message="tns:SubmitPackageHttpPostOut" />
+    </wsdl:operation>
+    <wsdl:operation name="PackageByGuid">
+      <wsdl:input message="tns:PackageByGuidHttpPostIn" />
+      <wsdl:output message="tns:PackageByGuidHttpPostOut" />
+    </wsdl:operation>
+  </wsdl:portType>
+  <wsdl:binding name="RepositorySoap" type="tns:RepositorySoap">
+    <soap:binding transport="http://schemas.xmlsoap.org/soap/http" />
+    <wsdl:operation name="Categories">
+      <soap:operation soapAction="http://packages.umbraco.org/webservices/Categories" style="document" />
+      <wsdl:input>
+        <soap:body use="literal" />
+      </wsdl:input>
+      <wsdl:output>
+        <soap:body use="literal" />
+      </wsdl:output>
+    </wsdl:operation>
+    <wsdl:operation name="Modules">
+      <soap:operation soapAction="http://packages.umbraco.org/webservices/Modules" style="document" />
+      <wsdl:input>
+        <soap:body use="literal" />
+      </wsdl:input>
+      <wsdl:output>
+        <soap:body use="literal" />
+      </wsdl:output>
+    </wsdl:operation>
+    <wsdl:operation name="ModulesCategorized">
+      <soap:operation soapAction="http://packages.umbraco.org/webservices/ModulesCategorized" style="document" />
+      <wsdl:input>
+        <soap:body use="literal" />
+      </wsdl:input>
+      <wsdl:output>
+        <soap:body use="literal" />
+      </wsdl:output>
+    </wsdl:operation>
+    <wsdl:operation name="Nitros">
+      <soap:operation soapAction="http://packages.umbraco.org/webservices/Nitros" style="document" />
+      <wsdl:input>
+        <soap:body use="literal" />
+      </wsdl:input>
+      <wsdl:output>
+        <soap:body use="literal" />
+      </wsdl:output>
+    </wsdl:operation>
+    <wsdl:operation name="NitrosCategorized">
+      <soap:operation soapAction="http://packages.umbraco.org/webservices/NitrosCategorized" style="document" />
+      <wsdl:input>
+        <soap:body use="literal" />
+      </wsdl:input>
+      <wsdl:output>
+        <soap:body use="literal" />
+      </wsdl:output>
+    </wsdl:operation>
+    <wsdl:operation name="authenticate">
+      <soap:operation soapAction="http://packages.umbraco.org/webservices/authenticate" style="document" />
+      <wsdl:input>
+        <soap:body use="literal" />
+      </wsdl:input>
+      <wsdl:output>
+        <soap:body use="literal" />
+      </wsdl:output>
+    </wsdl:operation>
+    <wsdl:operation name="fetchPackage">
+      <soap:operation soapAction="http://packages.umbraco.org/webservices/fetchPackage" style="document" />
+      <wsdl:input>
+        <soap:body use="literal" />
+      </wsdl:input>
+      <wsdl:output>
+        <soap:body use="literal" />
+      </wsdl:output>
+    </wsdl:operation>
+    <wsdl:operation name="fetchPackageByVersion">
+      <soap:operation soapAction="http://packages.umbraco.org/webservices/fetchPackageByVersion" style="document" />
+      <wsdl:input>
+        <soap:body use="literal" />
+      </wsdl:input>
+      <wsdl:output>
+        <soap:body use="literal" />
+      </wsdl:output>
+    </wsdl:operation>
+    <wsdl:operation name="fetchProtectedPackage">
+      <soap:operation soapAction="http://packages.umbraco.org/webservices/fetchProtectedPackage" style="document" />
+      <wsdl:input>
+        <soap:body use="literal" />
+      </wsdl:input>
+      <wsdl:output>
+        <soap:body use="literal" />
+      </wsdl:output>
+    </wsdl:operation>
+    <wsdl:operation name="SubmitPackage">
+      <soap:operation soapAction="http://packages.umbraco.org/webservices/SubmitPackage" style="document" />
+      <wsdl:input>
+        <soap:body use="literal" />
+      </wsdl:input>
+      <wsdl:output>
+        <soap:body use="literal" />
+      </wsdl:output>
+    </wsdl:operation>
+    <wsdl:operation name="PackageByGuid">
+      <soap:operation soapAction="http://packages.umbraco.org/webservices/PackageByGuid" style="document" />
+      <wsdl:input>
+        <soap:body use="literal" />
+      </wsdl:input>
+      <wsdl:output>
+        <soap:body use="literal" />
+      </wsdl:output>
+    </wsdl:operation>
+  </wsdl:binding>
+  <wsdl:binding name="RepositorySoap12" type="tns:RepositorySoap">
+    <soap12:binding transport="http://schemas.xmlsoap.org/soap/http" />
+    <wsdl:operation name="Categories">
+      <soap12:operation soapAction="http://packages.umbraco.org/webservices/Categories" style="document" />
+      <wsdl:input>
+        <soap12:body use="literal" />
+      </wsdl:input>
+      <wsdl:output>
+        <soap12:body use="literal" />
+      </wsdl:output>
+    </wsdl:operation>
+    <wsdl:operation name="Modules">
+      <soap12:operation soapAction="http://packages.umbraco.org/webservices/Modules" style="document" />
+      <wsdl:input>
+        <soap12:body use="literal" />
+      </wsdl:input>
+      <wsdl:output>
+        <soap12:body use="literal" />
+      </wsdl:output>
+    </wsdl:operation>
+    <wsdl:operation name="ModulesCategorized">
+      <soap12:operation soapAction="http://packages.umbraco.org/webservices/ModulesCategorized" style="document" />
+      <wsdl:input>
+        <soap12:body use="literal" />
+      </wsdl:input>
+      <wsdl:output>
+        <soap12:body use="literal" />
+      </wsdl:output>
+    </wsdl:operation>
+    <wsdl:operation name="Nitros">
+      <soap12:operation soapAction="http://packages.umbraco.org/webservices/Nitros" style="document" />
+      <wsdl:input>
+        <soap12:body use="literal" />
+      </wsdl:input>
+      <wsdl:output>
+        <soap12:body use="literal" />
+      </wsdl:output>
+    </wsdl:operation>
+    <wsdl:operation name="NitrosCategorized">
+      <soap12:operation soapAction="http://packages.umbraco.org/webservices/NitrosCategorized" style="document" />
+      <wsdl:input>
+        <soap12:body use="literal" />
+      </wsdl:input>
+      <wsdl:output>
+        <soap12:body use="literal" />
+      </wsdl:output>
+    </wsdl:operation>
+    <wsdl:operation name="authenticate">
+      <soap12:operation soapAction="http://packages.umbraco.org/webservices/authenticate" style="document" />
+      <wsdl:input>
+        <soap12:body use="literal" />
+      </wsdl:input>
+      <wsdl:output>
+        <soap12:body use="literal" />
+      </wsdl:output>
+    </wsdl:operation>
+    <wsdl:operation name="fetchPackage">
+      <soap12:operation soapAction="http://packages.umbraco.org/webservices/fetchPackage" style="document" />
+      <wsdl:input>
+        <soap12:body use="literal" />
+      </wsdl:input>
+      <wsdl:output>
+        <soap12:body use="literal" />
+      </wsdl:output>
+    </wsdl:operation>
+    <wsdl:operation name="fetchPackageByVersion">
+      <soap12:operation soapAction="http://packages.umbraco.org/webservices/fetchPackageByVersion" style="document" />
+      <wsdl:input>
+        <soap12:body use="literal" />
+      </wsdl:input>
+      <wsdl:output>
+        <soap12:body use="literal" />
+      </wsdl:output>
+    </wsdl:operation>
+    <wsdl:operation name="fetchProtectedPackage">
+      <soap12:operation soapAction="http://packages.umbraco.org/webservices/fetchProtectedPackage" style="document" />
+      <wsdl:input>
+        <soap12:body use="literal" />
+      </wsdl:input>
+      <wsdl:output>
+        <soap12:body use="literal" />
+      </wsdl:output>
+    </wsdl:operation>
+    <wsdl:operation name="SubmitPackage">
+      <soap12:operation soapAction="http://packages.umbraco.org/webservices/SubmitPackage" style="document" />
+      <wsdl:input>
+        <soap12:body use="literal" />
+      </wsdl:input>
+      <wsdl:output>
+        <soap12:body use="literal" />
+      </wsdl:output>
+    </wsdl:operation>
+    <wsdl:operation name="PackageByGuid">
+      <soap12:operation soapAction="http://packages.umbraco.org/webservices/PackageByGuid" style="document" />
+      <wsdl:input>
+        <soap12:body use="literal" />
+      </wsdl:input>
+      <wsdl:output>
+        <soap12:body use="literal" />
+      </wsdl:output>
+    </wsdl:operation>
+  </wsdl:binding>
+  <wsdl:binding name="RepositoryHttpGet" type="tns:RepositoryHttpGet">
+    <http:binding verb="GET" />
+    <wsdl:operation name="Categories">
+      <http:operation location="/Categories" />
+      <wsdl:input>
+        <http:urlEncoded />
+      </wsdl:input>
+      <wsdl:output>
+        <mime:mimeXml part="Body" />
+      </wsdl:output>
+    </wsdl:operation>
+    <wsdl:operation name="Modules">
+      <http:operation location="/Modules" />
+      <wsdl:input>
+        <http:urlEncoded />
+      </wsdl:input>
+      <wsdl:output>
+        <mime:mimeXml part="Body" />
+      </wsdl:output>
+    </wsdl:operation>
+    <wsdl:operation name="ModulesCategorized">
+      <http:operation location="/ModulesCategorized" />
+      <wsdl:input>
+        <http:urlEncoded />
+      </wsdl:input>
+      <wsdl:output>
+        <mime:mimeXml part="Body" />
+      </wsdl:output>
+    </wsdl:operation>
+    <wsdl:operation name="Nitros">
+      <http:operation location="/Nitros" />
+      <wsdl:input>
+        <http:urlEncoded />
+      </wsdl:input>
+      <wsdl:output>
+        <mime:mimeXml part="Body" />
+      </wsdl:output>
+    </wsdl:operation>
+    <wsdl:operation name="NitrosCategorized">
+      <http:operation location="/NitrosCategorized" />
+      <wsdl:input>
+        <http:urlEncoded />
+      </wsdl:input>
+      <wsdl:output>
+        <mime:mimeXml part="Body" />
+      </wsdl:output>
+    </wsdl:operation>
+    <wsdl:operation name="authenticate">
+      <http:operation location="/authenticate" />
+      <wsdl:input>
+        <http:urlEncoded />
+      </wsdl:input>
+      <wsdl:output>
+        <mime:mimeXml part="Body" />
+      </wsdl:output>
+    </wsdl:operation>
+    <wsdl:operation name="fetchPackage">
+      <http:operation location="/fetchPackage" />
+      <wsdl:input>
+        <http:urlEncoded />
+      </wsdl:input>
+      <wsdl:output>
+        <mime:mimeXml part="Body" />
+      </wsdl:output>
+    </wsdl:operation>
+    <wsdl:operation name="fetchPackageByVersion">
+      <http:operation location="/fetchPackageByVersion" />
+      <wsdl:input>
+        <http:urlEncoded />
+      </wsdl:input>
+      <wsdl:output>
+        <mime:mimeXml part="Body" />
+      </wsdl:output>
+    </wsdl:operation>
+    <wsdl:operation name="fetchProtectedPackage">
+      <http:operation location="/fetchProtectedPackage" />
+      <wsdl:input>
+        <http:urlEncoded />
+      </wsdl:input>
+      <wsdl:output>
+        <mime:mimeXml part="Body" />
+      </wsdl:output>
+    </wsdl:operation>
+    <wsdl:operation name="SubmitPackage">
+      <http:operation location="/SubmitPackage" />
+      <wsdl:input>
+        <http:urlEncoded />
+      </wsdl:input>
+      <wsdl:output>
+        <mime:mimeXml part="Body" />
+      </wsdl:output>
+    </wsdl:operation>
+    <wsdl:operation name="PackageByGuid">
+      <http:operation location="/PackageByGuid" />
+      <wsdl:input>
+        <http:urlEncoded />
+      </wsdl:input>
+      <wsdl:output>
+        <mime:mimeXml part="Body" />
+      </wsdl:output>
+    </wsdl:operation>
+  </wsdl:binding>
+  <wsdl:binding name="RepositoryHttpPost" type="tns:RepositoryHttpPost">
+    <http:binding verb="POST" />
+    <wsdl:operation name="Categories">
+      <http:operation location="/Categories" />
+      <wsdl:input>
+        <mime:content type="application/x-www-form-urlencoded" />
+      </wsdl:input>
+      <wsdl:output>
+        <mime:mimeXml part="Body" />
+      </wsdl:output>
+    </wsdl:operation>
+    <wsdl:operation name="Modules">
+      <http:operation location="/Modules" />
+      <wsdl:input>
+        <mime:content type="application/x-www-form-urlencoded" />
+      </wsdl:input>
+      <wsdl:output>
+        <mime:mimeXml part="Body" />
+      </wsdl:output>
+    </wsdl:operation>
+    <wsdl:operation name="ModulesCategorized">
+      <http:operation location="/ModulesCategorized" />
+      <wsdl:input>
+        <mime:content type="application/x-www-form-urlencoded" />
+      </wsdl:input>
+      <wsdl:output>
+        <mime:mimeXml part="Body" />
+      </wsdl:output>
+    </wsdl:operation>
+    <wsdl:operation name="Nitros">
+      <http:operation location="/Nitros" />
+      <wsdl:input>
+        <mime:content type="application/x-www-form-urlencoded" />
+      </wsdl:input>
+      <wsdl:output>
+        <mime:mimeXml part="Body" />
+      </wsdl:output>
+    </wsdl:operation>
+    <wsdl:operation name="NitrosCategorized">
+      <http:operation location="/NitrosCategorized" />
+      <wsdl:input>
+        <mime:content type="application/x-www-form-urlencoded" />
+      </wsdl:input>
+      <wsdl:output>
+        <mime:mimeXml part="Body" />
+      </wsdl:output>
+    </wsdl:operation>
+    <wsdl:operation name="authenticate">
+      <http:operation location="/authenticate" />
+      <wsdl:input>
+        <mime:content type="application/x-www-form-urlencoded" />
+      </wsdl:input>
+      <wsdl:output>
+        <mime:mimeXml part="Body" />
+      </wsdl:output>
+    </wsdl:operation>
+    <wsdl:operation name="fetchPackage">
+      <http:operation location="/fetchPackage" />
+      <wsdl:input>
+        <mime:content type="application/x-www-form-urlencoded" />
+      </wsdl:input>
+      <wsdl:output>
+        <mime:mimeXml part="Body" />
+      </wsdl:output>
+    </wsdl:operation>
+    <wsdl:operation name="fetchPackageByVersion">
+      <http:operation location="/fetchPackageByVersion" />
+      <wsdl:input>
+        <mime:content type="application/x-www-form-urlencoded" />
+      </wsdl:input>
+      <wsdl:output>
+        <mime:mimeXml part="Body" />
+      </wsdl:output>
+    </wsdl:operation>
+    <wsdl:operation name="fetchProtectedPackage">
+      <http:operation location="/fetchProtectedPackage" />
+      <wsdl:input>
+        <mime:content type="application/x-www-form-urlencoded" />
+      </wsdl:input>
+      <wsdl:output>
+        <mime:mimeXml part="Body" />
+      </wsdl:output>
+    </wsdl:operation>
+    <wsdl:operation name="SubmitPackage">
+      <http:operation location="/SubmitPackage" />
+      <wsdl:input>
+        <mime:content type="application/x-www-form-urlencoded" />
+      </wsdl:input>
+      <wsdl:output>
+        <mime:mimeXml part="Body" />
+      </wsdl:output>
+    </wsdl:operation>
+    <wsdl:operation name="PackageByGuid">
+      <http:operation location="/PackageByGuid" />
+      <wsdl:input>
+        <mime:content type="application/x-www-form-urlencoded" />
+      </wsdl:input>
+      <wsdl:output>
+        <mime:mimeXml part="Body" />
+      </wsdl:output>
+    </wsdl:operation>
+  </wsdl:binding>
+  <wsdl:service name="Repository">
+    <wsdl:port name="RepositorySoap" binding="tns:RepositorySoap">
+      <soap:address location="https://our.umbraco.com/umbraco/webservices/api/repository.asmx" />
+    </wsdl:port>
+    <wsdl:port name="RepositorySoap12" binding="tns:RepositorySoap12">
+      <soap12:address location="https://our.umbraco.com/umbraco/webservices/api/repository.asmx" />
+    </wsdl:port>
+    <wsdl:port name="RepositoryHttpGet" binding="tns:RepositoryHttpGet">
+      <http:address location="https://our.umbraco.com/umbraco/webservices/api/repository.asmx" />
+    </wsdl:port>
+    <wsdl:port name="RepositoryHttpPost" binding="tns:RepositoryHttpPost">
+      <http:address location="https://our.umbraco.com/umbraco/webservices/api/repository.asmx" />
+    </wsdl:port>
+  </wsdl:service>
+</wsdl:definitions>
\ No newline at end of file

From 83ad1fd9109e6d104a166e4422ef1ac31bb85a66 Mon Sep 17 00:00:00 2001
From: Sebastiaan Janssen <sebastiaan@umbraco.com>
Date: Tue, 10 Sep 2019 17:13:31 +0200
Subject: [PATCH 08/14] Apply only the wanted change from V7/bug/6283 save
 member resets password #6284

---
 .../src/views/member/member.edit.controller.js                  | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/Umbraco.Web.UI.Client/src/views/member/member.edit.controller.js b/src/Umbraco.Web.UI.Client/src/views/member/member.edit.controller.js
index eb99e46a1f..8d54597791 100644
--- a/src/Umbraco.Web.UI.Client/src/views/member/member.edit.controller.js
+++ b/src/Umbraco.Web.UI.Client/src/views/member/member.edit.controller.js
@@ -133,7 +133,7 @@ function MemberEditController($scope, $routeParams, $location, $q, $window, appS
 
             //anytime a user is changing a member's password without the oldPassword, we are in effect resetting it so we need to set that flag here
             var passwordProp = _.find(contentEditingHelper.getAllProps($scope.content), function (e) { return e.alias === '_umb_password' });
-            if (passwordProp && passwordProp.value && !passwordProp.value.reset) {
+            if (passwordProp && passwordProp.value && (typeof passwordProp.value.reset !== 'undefined') && !passwordProp.value.reset) {
                 //so if the admin is not explicitly resetting the password, flag it for resetting if a new password is being entered
                 passwordProp.value.reset = !passwordProp.value.oldPassword && passwordProp.config.allowManuallyChangingPassword;
             }

From 7d0d5b9c939a9d9578c9e112a2f1d90bac6df777 Mon Sep 17 00:00:00 2001
From: Shannon Deminick <sdeminick@gmail.com>
Date: Thu, 19 Sep 2019 18:46:02 +1000
Subject: [PATCH 09/14] U4-9912 Previewing without changing creates new version
 (#1943)

---
 src/Umbraco.Core/Services/ContentService.cs  | 5894 +++++++++---------
 src/Umbraco.Web/Editors/ContentController.cs | 2442 ++++----
 2 files changed, 4172 insertions(+), 4164 deletions(-)

diff --git a/src/Umbraco.Core/Services/ContentService.cs b/src/Umbraco.Core/Services/ContentService.cs
index 2994bcc4f6..0b50eb1f65 100644
--- a/src/Umbraco.Core/Services/ContentService.cs
+++ b/src/Umbraco.Core/Services/ContentService.cs
@@ -1,2945 +1,2949 @@
-using System;
-using System.Collections.Generic;
-using System.ComponentModel;
-using System.Globalization;
-using System.IO;
-using System.Linq;
-using System.Text.RegularExpressions;
-using System.Threading;
-using System.Xml;
-using System.Xml.Linq;
-using Umbraco.Core.Events;
-using Umbraco.Core.Logging;
-using Umbraco.Core.Models;
-using Umbraco.Core.Models.Membership;
-using Umbraco.Core.Models.Rdbms;
-using Umbraco.Core.Persistence;
-using Umbraco.Core.Persistence.DatabaseModelDefinitions;
-using Umbraco.Core.Persistence.Querying;
-using Umbraco.Core.Persistence.Repositories;
-using Umbraco.Core.Persistence.UnitOfWork;
-using Umbraco.Core.Publishing;
-
-namespace Umbraco.Core.Services
-{
-    /// <summary>
-    /// Represents the Content Service, which is an easy access to operations involving <see cref="IContent"/>
-    /// </summary>
-    public class ContentService : ScopeRepositoryService, IContentService, IContentServiceOperations
-    {
-        private readonly IPublishingStrategy2 _publishingStrategy;
-        private readonly EntityXmlSerializer _entitySerializer = new EntityXmlSerializer();
-        private readonly IDataTypeService _dataTypeService;
-        private readonly IUserService _userService;
-
-        //Support recursive locks because some of the methods that require locking call other methods that require locking.
-        //for example, the Move method needs to be locked but this calls the Save method which also needs to be locked.
-        private static readonly ReaderWriterLockSlim Locker = new ReaderWriterLockSlim(LockRecursionPolicy.SupportsRecursion);
-        private static readonly Regex AnchorRegex = new Regex("<a id=\"(.*?)\">", RegexOptions.Compiled);
-
-        public ContentService(
-            IDatabaseUnitOfWorkProvider provider,
-            RepositoryFactory repositoryFactory,
-            ILogger logger,
-            IEventMessagesFactory eventMessagesFactory,
-            IDataTypeService dataTypeService,
-            IUserService userService)
-            : base(provider, repositoryFactory, logger, eventMessagesFactory)
-        {
-            if (dataTypeService == null) throw new ArgumentNullException("dataTypeService");
-            if (userService == null) throw new ArgumentNullException("userService");
-            _publishingStrategy = new PublishingStrategy(UowProvider.ScopeProvider, eventMessagesFactory, logger);
-            _dataTypeService = dataTypeService;
-            _userService = userService;
-        }
-
-        #region Static Queries
-
-        private IQuery<IContent> _notTrashedQuery;
-
-        #endregion
-
-        public int CountPublished(string contentTypeAlias = null)
-        {
-            using (var uow = UowProvider.GetUnitOfWork(readOnly: true))
-            {
-                var repository = RepositoryFactory.CreateContentRepository(uow);
-                return repository.CountPublished(contentTypeAlias);
-            }
-        }
-
-        public int Count(string contentTypeAlias = null)
-        {
-            using (var uow = UowProvider.GetUnitOfWork(readOnly: true))
-            {
-                var repository = RepositoryFactory.CreateContentRepository(uow);
-                return repository.Count(contentTypeAlias);
-            }
-        }
-
-        public int CountChildren(int parentId, string contentTypeAlias = null)
-        {
-            using (var uow = UowProvider.GetUnitOfWork(readOnly: true))
-            {
-                var repository = RepositoryFactory.CreateContentRepository(uow);
-                return repository.CountChildren(parentId, contentTypeAlias);
-            }
-        }
-
-        public int CountDescendants(int parentId, string contentTypeAlias = null)
-        {
-            using (var uow = UowProvider.GetUnitOfWork(readOnly: true))
-            {
-                var repository = RepositoryFactory.CreateContentRepository(uow);
-                return repository.CountDescendants(parentId, contentTypeAlias);
-            }
-        }
-
-        /// <summary>
-        /// Used to bulk update the permissions set for a content item. This will replace all permissions
-        /// assigned to an entity with a list of user id & permission pairs.
-        /// </summary>
-        /// <param name="permissionSet"></param>
-        public void ReplaceContentPermissions(EntityPermissionSet permissionSet)
-        {
-            using (var uow = UowProvider.GetUnitOfWork())
-            {
-                var repository = RepositoryFactory.CreateContentRepository(uow);
-                repository.ReplaceContentPermissions(permissionSet);
-                uow.Commit();
-            }
-        }
-
-        /// <summary>
-        /// Assigns a single permission to the current content item for the specified group ids
-        /// </summary>
-        /// <param name="entity"></param>
-        /// <param name="permission"></param>
-        /// <param name="groupIds"></param>
-        public void AssignContentPermission(IContent entity, char permission, IEnumerable<int> groupIds)
-        {
-            using (var uow = UowProvider.GetUnitOfWork())
-            {
-                var repository = RepositoryFactory.CreateContentRepository(uow);
-                repository.AssignEntityPermission(entity, permission, groupIds);
-                uow.Commit();
-            }
-        }
-
-        /// <summary>
-        /// Returns implicit/inherited permissions assigned to the content item for all user groups
-        /// </summary>
-        /// <param name="content"></param>
-        /// <returns></returns>
-        public EntityPermissionCollection GetPermissionsForEntity(IContent content)
-        {
-            using (var uow = UowProvider.GetUnitOfWork(readOnly: true))
-            {
-                var repository = RepositoryFactory.CreateContentRepository(uow);
-                return repository.GetPermissionsForEntity(content.Id);
-            }
-        }
-
-        /// <summary>
-        /// Creates an <see cref="IContent"/> object using the alias of the <see cref="IContentType"/>
-        /// that this Content should based on.
-        /// </summary>
-        /// <remarks>
-        /// Note that using this method will simply return a new IContent without any identity
-        /// as it has not yet been persisted. It is intended as a shortcut to creating new content objects
-        /// that does not invoke a save operation against the database.
-        /// </remarks>
-        /// <param name="name">Name of the Content object</param>
-        /// <param name="parentId">Id of Parent for the new Content</param>
-        /// <param name="contentTypeAlias">Alias of the <see cref="IContentType"/></param>
-        /// <param name="userId">Optional id of the user creating the content</param>
-        /// <returns><see cref="IContent"/></returns>
-        public IContent CreateContent(string name, Guid parentId, string contentTypeAlias, int userId = 0)
-        {
-            var parent = GetById(parentId);
-            return CreateContent(name, parent, contentTypeAlias, userId);
-        }
-
-        /// <summary>
-        /// Creates an <see cref="IContent"/> object using the alias of the <see cref="IContentType"/>
-        /// that this Content should based on.
-        /// </summary>
-        /// <remarks>
-        /// Note that using this method will simply return a new IContent without any identity
-        /// as it has not yet been persisted. It is intended as a shortcut to creating new content objects
-        /// that does not invoke a save operation against the database.
-        /// </remarks>
-        /// <param name="name">Name of the Content object</param>
-        /// <param name="parentId">Id of Parent for the new Content</param>
-        /// <param name="contentTypeAlias">Alias of the <see cref="IContentType"/></param>
-        /// <param name="userId">Optional id of the user creating the content</param>
-        /// <returns><see cref="IContent"/></returns>
-        public IContent CreateContent(string name, int parentId, string contentTypeAlias, int userId = 0)
-        {
-            var contentType = FindContentTypeByAlias(contentTypeAlias);
-            var content = new Content(name, parentId, contentType);
-            var parent = GetById(content.ParentId);
-            content.Path = string.Concat(parent.IfNotNull(x => x.Path, content.ParentId.ToString()), ",", content.Id);
-
-            using (var uow = UowProvider.GetUnitOfWork())
-            {
-                var newEventArgs = new NewEventArgs<IContent>(content, contentTypeAlias, parentId);
-                if (uow.Events.DispatchCancelable(Creating, this, newEventArgs))
-                {
-                    uow.Commit();
-                    content.WasCancelled = true;
-                    return content;
-                }
-
-                content.CreatorId = userId;
-                content.WriterId = userId;
-                newEventArgs.CanCancel = false;
-                uow.Events.Dispatch(Created, this, newEventArgs);
-
-                uow.Commit();
-            }
-
-            return content;
-        }
-
-        /// <summary>
-        /// Creates an <see cref="IContent"/> object using the alias of the <see cref="IContentType"/>
-        /// that this Content should based on.
-        /// </summary>
-        /// <remarks>
-        /// Note that using this method will simply return a new IContent without any identity
-        /// as it has not yet been persisted. It is intended as a shortcut to creating new content objects
-        /// that does not invoke a save operation against the database.
-        /// </remarks>
-        /// <param name="name">Name of the Content object</param>
-        /// <param name="parent">Parent <see cref="IContent"/> object for the new Content</param>
-        /// <param name="contentTypeAlias">Alias of the <see cref="IContentType"/></param>
-        /// <param name="userId">Optional id of the user creating the content</param>
-        /// <returns><see cref="IContent"/></returns>
-        public IContent CreateContent(string name, IContent parent, string contentTypeAlias, int userId = 0)
-        {
-            if (parent == null) throw new ArgumentNullException("parent");
-
-            var contentType = FindContentTypeByAlias(contentTypeAlias);
-            var content = new Content(name, parent, contentType);
-            content.Path = string.Concat(parent.Path, ",", content.Id);
-
-            using (var uow = UowProvider.GetUnitOfWork())
-            {
-                var newEventArgs = new NewEventArgs<IContent>(content, contentTypeAlias, parent);
-                if (uow.Events.DispatchCancelable(Creating, this, newEventArgs))
-                {
-                    uow.Commit();
-                    content.WasCancelled = true;
-                    return content;
-                }
-
-                content.CreatorId = userId;
-                content.WriterId = userId;
-                newEventArgs.CanCancel = false;
-                uow.Events.Dispatch(Created, this, newEventArgs);
-
-                uow.Commit();
-            }
-
-            return content;
-        }
-
-        /// <summary>
-        /// Creates and saves an <see cref="IContent"/> object using the alias of the <see cref="IContentType"/>
-        /// that this Content should based on.
-        /// </summary>
-        /// <remarks>
-        /// This method returns an <see cref="IContent"/> object that has been persisted to the database
-        /// and therefor has an identity.
-        /// </remarks>
-        /// <param name="name">Name of the Content object</param>
-        /// <param name="parentId">Id of Parent for the new Content</param>
-        /// <param name="contentTypeAlias">Alias of the <see cref="IContentType"/></param>
-        /// <param name="userId">Optional id of the user creating the content</param>
-        /// <returns><see cref="IContent"/></returns>
-        public IContent CreateContentWithIdentity(string name, int parentId, string contentTypeAlias, int userId = 0)
-        {
-            var contentType = FindContentTypeByAlias(contentTypeAlias);
-            var content = new Content(name, parentId, contentType);
-
-            using (var uow = UowProvider.GetUnitOfWork())
-            {
-                //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.
-                var newEventArgs = new NewEventArgs<IContent>(content, contentTypeAlias, parentId);
-                if (uow.Events.DispatchCancelable(Creating, this, newEventArgs))
-                {
-                    uow.Commit();
-                    content.WasCancelled = true;
-                    return content;
-                }
-
-                var saveEventArgs = new SaveEventArgs<IContent>(content);
-                if (uow.Events.DispatchCancelable(Saving, this, saveEventArgs, "Saving"))
-                {
-                    uow.Commit();
-                    content.WasCancelled = true;
-                    return content;
-                }
-
-                var repository = RepositoryFactory.CreateContentRepository(uow);
-                content.CreatorId = userId;
-                content.WriterId = userId;
-
-                repository.AddOrUpdate(content);
-                repository.AddOrUpdatePreviewXml(content, c => _entitySerializer.Serialize(this, _dataTypeService, _userService, c));
-                saveEventArgs.CanCancel = false;
-                uow.Events.Dispatch(Saved, this, saveEventArgs, "Saved");
-                newEventArgs.CanCancel = false;
-                uow.Events.Dispatch(Created, this, newEventArgs);
-
-                Audit(uow, AuditType.New, string.Format("Content '{0}' was created with Id {1}", name, content.Id), content.CreatorId, content.Id);
-                uow.Commit();
-            }
-
-            return content;
-        }
-
-        public IEnumerable<string> GetAnchorValuesFromRTEs(int id)
-        {
-            var result = new List<string>();
-
-            var content = GetById(id);
-
-            foreach (var contentProperty in content.Properties)
-            {
-                if (contentProperty.PropertyType.PropertyEditorAlias.InvariantEquals(Constants.PropertyEditors.TinyMCEAlias))
-                {
-                    var value = contentProperty.Value?.ToString();
-
-                    if (!string.IsNullOrEmpty(value))
-                    {
-                        result.AddRange(GetAnchorValuesFromRTEContent(value));
-                    }
-
-                }
-            }
-
-
-            return result;
-        }
-
-
-        public IEnumerable<string> GetAnchorValuesFromRTEContent(string rteContent)
-        {
-            var result = new List<string>();
-
-            var matches = AnchorRegex.Matches(rteContent);
-
-            foreach (Match match in matches)
-            {
-                result.Add(match.Value.Split('\"')[1]);
-            }
-
-            return result;
-        }
-
-        /// <summary>
-        /// Creates and saves an <see cref="IContent"/> object using the alias of the <see cref="IContentType"/>
-        /// that this Content should based on.
-        /// </summary>
-        /// <remarks>
-        /// This method returns an <see cref="IContent"/> object that has been persisted to the database
-        /// and therefor has an identity.
-        /// </remarks>
-        /// <param name="name">Name of the Content object</param>
-        /// <param name="parent">Parent <see cref="IContent"/> object for the new Content</param>
-        /// <param name="contentTypeAlias">Alias of the <see cref="IContentType"/></param>
-        /// <param name="userId">Optional id of the user creating the content</param>
-        /// <returns><see cref="IContent"/></returns>
-        public IContent CreateContentWithIdentity(string name, IContent parent, string contentTypeAlias, int userId = 0)
-        {
-            if (parent == null) throw new ArgumentNullException("parent");
-
-            var contentType = FindContentTypeByAlias(contentTypeAlias);
-            var content = new Content(name, parent, contentType);
-
-            using (var uow = UowProvider.GetUnitOfWork())
-            {
-                //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.
-                var newEventArgs = new NewEventArgs<IContent>(content, contentTypeAlias, parent);
-                if (uow.Events.DispatchCancelable(Creating, this, newEventArgs))
-                {
-                    uow.Commit();
-                    content.WasCancelled = true;
-                    return content;
-                }
-
-                var saveEventArgs = new SaveEventArgs<IContent>(content);
-                if (uow.Events.DispatchCancelable(Saving, this, saveEventArgs, "Saving"))
-                {
-                    uow.Commit();
-                    content.WasCancelled = true;
-                    return content;
-                }
-
-                var repository = RepositoryFactory.CreateContentRepository(uow);
-                content.CreatorId = userId;
-                content.WriterId = userId;
-
-                repository.AddOrUpdate(content);
-                repository.AddOrUpdatePreviewXml(content, c => _entitySerializer.Serialize(this, _dataTypeService, _userService, c));
-                saveEventArgs.CanCancel = false;
-                uow.Events.Dispatch(Saved, this, saveEventArgs, "Saved");
-                newEventArgs.CanCancel = false;
-                uow.Events.Dispatch(Created, this, newEventArgs);
-
-                Audit(uow, AuditType.New, string.Format("Content '{0}' was created with Id {1}", name, content.Id), content.CreatorId, content.Id);
-                uow.Commit();
-            }
-
-            return content;
-        }
-
-        /// <summary>
-        /// Gets an <see cref="IContent"/> object by Id
-        /// </summary>
-        /// <param name="id">Id of the Content to retrieve</param>
-        /// <returns><see cref="IContent"/></returns>
-        public IContent GetById(int id)
-        {
-            using (var uow = UowProvider.GetUnitOfWork(readOnly: true))
-            {
-                var repository = RepositoryFactory.CreateContentRepository(uow);
-                return repository.Get(id);
-            }
-        }
-
-        /// <summary>
-        /// Gets <see cref="IContent"/> objects by Ids
-        /// </summary>
-        /// <param name="ids">Ids of the Content to retrieve</param>
-        /// <returns><see cref="IContent"/></returns>
-        public IEnumerable<IContent> GetByIds(IEnumerable<int> ids)
-        {
-            var idsArray = ids.ToArray();
-            if (idsArray.Length == 0) return Enumerable.Empty<IContent>();
-
-            using (var uow = UowProvider.GetUnitOfWork(readOnly: true))
-            {
-                var repository = RepositoryFactory.CreateContentRepository(uow);
-
-                // ensure that the result has the order based on the ids passed in
-                var result = repository.GetAll(idsArray);
-                var content = result.ToDictionary(x => x.Id, x => x);
-
-                var sortedResult = idsArray.Select(x =>
-                {
-                    IContent c;
-                    return content.TryGetValue(x, out c) ? c : null;
-                }).WhereNotNull();
-
-                return sortedResult;
-            }
-        }
-
-        /// <summary>
-        /// Gets <see cref="IContent"/> objects by Ids
-        /// </summary>
-        /// <param name="ids">Ids of the Content to retrieve</param>
-        /// <returns><see cref="IContent"/></returns>
-        public IEnumerable<IContent> GetByIds(IEnumerable<Guid> ids)
-        {
-            var idsArray = ids.ToArray();
-            if (idsArray.Length == 0) return Enumerable.Empty<IContent>();
-
-            using (var uow = UowProvider.GetUnitOfWork(readOnly: true))
-            {
-                var repository = RepositoryFactory.CreateContentRepository(uow);
-
-                // ensure that the result has the order based on the ids passed in
-                var result = repository.GetAll(idsArray);
-                var content = result.ToDictionary(x => x.Key, x => x);
-
-                var sortedResult = idsArray.Select(x =>
-                {
-                    IContent c;
-                    return content.TryGetValue(x, out c) ? c : null;
-                }).WhereNotNull();
-
-                return sortedResult;
-            }
-        }
-
-        /// <summary>
-        /// Gets an <see cref="IContent"/> object by its 'UniqueId'
-        /// </summary>
-        /// <param name="key">Guid key of the Content to retrieve</param>
-        /// <returns><see cref="IContent"/></returns>
-        public IContent GetById(Guid key)
-        {
-            using (var uow = UowProvider.GetUnitOfWork(readOnly: true))
-            {
-                var repository = RepositoryFactory.CreateContentRepository(uow);
-                return repository.Get(key);
-            }
-        }
-
-        /// <summary>
-        /// Gets a collection of <see cref="IContent"/> objects by the Id of the <see cref="IContentType"/>
-        /// </summary>
-        /// <param name="id">Id of the <see cref="IContentType"/></param>
-        /// <returns>An Enumerable list of <see cref="IContent"/> objects</returns>
-        public IEnumerable<IContent> GetContentOfContentType(int id)
-        {
-            using (var uow = UowProvider.GetUnitOfWork(readOnly: true))
-            {
-                var repository = RepositoryFactory.CreateContentRepository(uow);
-                var query = Query<IContent>.Builder.Where(x => x.ContentTypeId == id);
-                return repository.GetByQuery(query);
-            }
-        }
-
-        internal IEnumerable<IContent> GetPublishedContentOfContentType(int id)
-        {
-            using (var uow = UowProvider.GetUnitOfWork(readOnly: true))
-            {
-                var repository = RepositoryFactory.CreateContentRepository(uow);
-                var query = Query<IContent>.Builder.Where(x => x.ContentTypeId == id);
-                return repository.GetByPublishedVersion(query);
-            }
-        }
-
-        /// <summary>
-        /// Gets a collection of <see cref="IContent"/> objects by Level
-        /// </summary>
-        /// <param name="level">The level to retrieve Content from</param>
-        /// <returns>An Enumerable list of <see cref="IContent"/> objects</returns>
-        public IEnumerable<IContent> GetByLevel(int level)
-        {
-            using (var uow = UowProvider.GetUnitOfWork(readOnly: true))
-            {
-                var repository = RepositoryFactory.CreateContentRepository(uow);
-                var query = Query<IContent>.Builder.Where(x => x.Level == level && x.Path.StartsWith(Constants.System.RecycleBinContent.ToInvariantString()) == false);
-                return repository.GetByQuery(query);
-            }
-        }
-
-        /// <summary>
-        /// Gets a specific version of an <see cref="IContent"/> item.
-        /// </summary>
-        /// <param name="versionId">Id of the version to retrieve</param>
-        /// <returns>An <see cref="IContent"/> item</returns>
-        public IContent GetByVersion(Guid versionId)
-        {
-            using (var uow = UowProvider.GetUnitOfWork(readOnly: true))
-            {
-                var repository = RepositoryFactory.CreateContentRepository(uow);
-                return repository.GetByVersion(versionId);
-            }
-        }
-
-
-        /// <summary>
-        /// Gets a collection of an <see cref="IContent"/> objects versions by Id
-        /// </summary>
-        /// <param name="id"></param>
-        /// <returns>An Enumerable list of <see cref="IContent"/> objects</returns>
-        public IEnumerable<IContent> GetVersions(int id)
-        {
-            using (var uow = UowProvider.GetUnitOfWork(readOnly: true))
-            {
-                var repository = RepositoryFactory.CreateContentRepository(uow);
-                return repository.GetAllVersions(id);
-            }
-        }
-
-        /// <summary>
-        /// Gets a list of all version Ids for the given content item ordered so latest is first
-        /// </summary>
-        /// <param name="id"></param>
-        /// <param name="maxRows">The maximum number of rows to return</param>
-        /// <returns></returns>
-        public IEnumerable<Guid> GetVersionIds(int id, int maxRows)
-        {
-            using (var uow = UowProvider.GetUnitOfWork(readOnly: true))
-            {
-                var repository = RepositoryFactory.CreateContentRepository(uow);
-                return repository.GetVersionIds(id, maxRows);
-            }
-        }
-
-        /// <summary>
-        /// Gets a collection of <see cref="IContent"/> objects, which are ancestors of the current content.
-        /// </summary>
-        /// <param name="id">Id of the <see cref="IContent"/> to retrieve ancestors for</param>
-        /// <returns>An Enumerable list of <see cref="IContent"/> objects</returns>
-        public IEnumerable<IContent> GetAncestors(int id)
-        {
-            var content = GetById(id);
-            return GetAncestors(content);
-        }
-
-        /// <summary>
-        /// Gets a collection of <see cref="IContent"/> objects, which are ancestors of the current content.
-        /// </summary>
-        /// <param name="content"><see cref="IContent"/> to retrieve ancestors for</param>
-        /// <returns>An Enumerable list of <see cref="IContent"/> objects</returns>
-        public IEnumerable<IContent> GetAncestors(IContent content)
-        {
-            //null check otherwise we get exceptions
-            if (content.Path.IsNullOrWhiteSpace()) return Enumerable.Empty<IContent>();
-
-            var ids = content.Path.Split(',').Where(x => x != Constants.System.Root.ToInvariantString() && x != content.Id.ToString(CultureInfo.InvariantCulture)).Select(int.Parse).ToArray();
-            if (ids.Any() == false)
-                return new List<IContent>();
-
-            using (var uow = UowProvider.GetUnitOfWork(readOnly: true))
-            {
-                var repository = RepositoryFactory.CreateContentRepository(uow);
-                return repository.GetAll(ids);
-            }
-        }
-
-        /// <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>
-        /// <returns>An Enumerable list of <see cref="IContent"/> objects</returns>
-        public IEnumerable<IContent> GetChildren(int id)
-        {
-            using (var uow = UowProvider.GetUnitOfWork(readOnly: true))
-            {
-                var repository = RepositoryFactory.CreateContentRepository(uow);
-                var query = Query<IContent>.Builder.Where(x => x.ParentId == id);
-                return repository.GetByQuery(query).OrderBy(x => x.SortOrder);
-            }
-        }
-
-        [Obsolete("Use the overload with 'long' parameter types instead")]
-        [EditorBrowsable(EditorBrowsableState.Never)]
-        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;
-        }
-
-        /// <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="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, 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");
-
-            using (var uow = UowProvider.GetUnitOfWork(readOnly: true))
-            {
-                var repository = RepositoryFactory.CreateContentRepository(uow);
-
-                var query = Query<IContent>.Builder;
-                // always check for a parent - else it will also get decendants (and then you should use the GetPagedDescendants method)
-                query.Where(x => x.ParentId == id);
-
-                IQuery<IContent> filterQuery = null;
-                if (filter.IsNullOrWhiteSpace() == false)
-                {
-                    filterQuery = Query<IContent>.Builder.Where(x => x.Name.Contains(filter));
-                }
-                return repository.GetPagedResultsByQuery(query, pageIndex, pageSize, out totalChildren, orderBy, orderDirection, orderBySystemField, filterQuery);
-            }
-        }
-
-        [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");
-            using (var uow = UowProvider.GetUnitOfWork(readOnly: true))
-            {
-                var repository = RepositoryFactory.CreateContentRepository(uow);
-
-                // get query - if the id is System Root, then just get all
-                var query = Query<IContent>.Builder;
-                if (id != Constants.System.Root)
-                {
-                    var entityRepository = RepositoryFactory.CreateEntityRepository(uow);
-                    var contentPath = entityRepository.GetAllPaths(Constants.ObjectTypes.DocumentGuid, id).ToArray();
-                    if (contentPath.Length == 0)
-                    {
-                        totalChildren = 0;
-                        return Enumerable.Empty<IContent>();
-                    }
-                    query.Where(x => x.Path.SqlStartsWith(string.Format("{0},", contentPath[0].Path), TextColumnType.NVarchar));
-                }
-
-
-                // get filter
-                IQuery<IContent> filterQuery = null;
-                if (filter.IsNullOrWhiteSpace() == false)
-                    filterQuery = Query<IContent>.Builder.Where(x => x.Name.Contains(filter));
-
-                return repository.GetPagedResultsByQuery(query, pageIndex, pageSize, out totalChildren, orderBy, orderDirection, orderBySystemField, filterQuery);
-            }
-        }
-
-        /// <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 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, IQuery<IContent> filter)
-        {
-            Mandate.ParameterCondition(pageIndex >= 0, "pageIndex");
-            Mandate.ParameterCondition(pageSize > 0, "pageSize");
-
-            using (var uow = UowProvider.GetUnitOfWork(readOnly: true))
-            {
-                var repository = RepositoryFactory.CreateContentRepository(uow);
-
-                // get query - if the id is System Root, then just get all
-                var query = Query<IContent>.Builder;
-                if (id != Constants.System.Root)
-                {
-                    var entityRepository = RepositoryFactory.CreateEntityRepository(uow);
-                    var contentPath = entityRepository.GetAllPaths(Constants.ObjectTypes.DocumentGuid, id).ToArray();
-                    if (contentPath.Length == 0)
-                    {
-                        totalChildren = 0;
-                        return Enumerable.Empty<IContent>();
-                    }
-                    query.Where(x => x.Path.SqlStartsWith(string.Format("{0},", contentPath[0].Path), TextColumnType.NVarchar));
-                }
-
-                return repository.GetPagedResultsByQuery(query, pageIndex, pageSize, out totalChildren, orderBy, orderDirection, orderBySystemField, filter);
-            }
-        }
-
-        /// <summary>
-        /// Gets a collection of <see cref="IContent"/> objects by its name or partial name
-        /// </summary>
-        /// <param name="parentId">Id of the Parent to retrieve Children from</param>
-        /// <param name="name">Full or partial name of the children</param>
-        /// <returns>An Enumerable list of <see cref="IContent"/> objects</returns>
-        public IEnumerable<IContent> GetChildrenByName(int parentId, string name)
-        {
-            using (var uow = UowProvider.GetUnitOfWork(readOnly: true))
-            {
-                var repository = RepositoryFactory.CreateContentRepository(uow);
-
-                var query = Query<IContent>.Builder.Where(x => x.ParentId == parentId && x.Name.Contains(name));
-                return repository.GetByQuery(query);
-            }
-        }
-
-        /// <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>
-        /// <returns>An Enumerable list of <see cref="IContent"/> objects</returns>
-        public IEnumerable<IContent> GetDescendants(int id)
-        {
-            var content = GetById(id);
-            return content == null ? Enumerable.Empty<IContent>() : GetDescendants(content);
-        }
-
-        /// <summary>
-        /// Gets a collection of <see cref="IContent"/> objects by Parent Id
-        /// </summary>
-        /// <param name="content"><see cref="IContent"/> item to retrieve Descendants from</param>
-        /// <returns>An Enumerable list of <see cref="IContent"/> objects</returns>
-        public IEnumerable<IContent> GetDescendants(IContent content)
-        {
-            //This is a check to ensure that the path is correct for this entity to avoid problems like: http://issues.umbraco.org/issue/U4-9336 due to data corruption
-            if (content.ValidatePath() == false)
-                throw new InvalidDataException(string.Format("The content item {0} has an invalid path: {1} with parentID: {2}", content.Id, content.Path, content.ParentId));
-
-            using (var uow = UowProvider.GetUnitOfWork(readOnly: true))
-            {
-                var repository = RepositoryFactory.CreateContentRepository(uow);
-
-                var pathMatch = content.Path + ",";
-                var query = Query<IContent>.Builder.Where(x => x.Path.StartsWith(pathMatch) && x.Id != content.Id);
-                return repository.GetByQuery(query);
-            }
-        }
-
-        /// <summary>
-        /// Gets the parent of the current content as an <see cref="IContent"/> item.
-        /// </summary>
-        /// <param name="id">Id of the <see cref="IContent"/> to retrieve the parent from</param>
-        /// <returns>Parent <see cref="IContent"/> object</returns>
-        public IContent GetParent(int id)
-        {
-            var content = GetById(id);
-            return GetParent(content);
-        }
-
-        /// <summary>
-        /// Gets the parent of the current content as an <see cref="IContent"/> item.
-        /// </summary>
-        /// <param name="content"><see cref="IContent"/> to retrieve the parent from</param>
-        /// <returns>Parent <see cref="IContent"/> object</returns>
-        public IContent GetParent(IContent content)
-        {
-            if (content.ParentId == Constants.System.Root || content.ParentId == Constants.System.RecycleBinContent)
-                return null;
-
-            return GetById(content.ParentId);
-        }
-
-        /// <summary>
-        /// Gets the published version of an <see cref="IContent"/> item
-        /// </summary>
-        /// <param name="id">Id of the <see cref="IContent"/> to retrieve version from</param>
-        /// <returns>An <see cref="IContent"/> item</returns>
-        public IContent GetPublishedVersion(int id)
-        {
-            var version = GetVersions(id);
-            return version.FirstOrDefault(x => x.Published);
-        }
-
-        /// <summary>
-        /// Gets the published version of a <see cref="IContent"/> item.
-        /// </summary>
-        /// <param name="content">The content item.</param>
-        /// <returns>The published version, if any; otherwise, null.</returns>
-        public IContent GetPublishedVersion(IContent content)
-        {
-            if (content.Published) return content;
-            return content.HasPublishedVersion
-                ? GetByVersion(content.PublishedVersionGuid)
-                : null;
-        }
-
-        /// <summary>
-        /// Gets a collection of <see cref="IContent"/> objects, which reside at the first level / root
-        /// </summary>
-        /// <returns>An Enumerable list of <see cref="IContent"/> objects</returns>
-        public IEnumerable<IContent> GetRootContent()
-        {
-            using (var uow = UowProvider.GetUnitOfWork(readOnly: true))
-            {
-                var repository = RepositoryFactory.CreateContentRepository(uow);
-
-                var query = Query<IContent>.Builder.Where(x => x.ParentId == Constants.System.Root);
-                return repository.GetByQuery(query);
-            }
-        }
-
-        /// <summary>
-        /// Gets all published content items
-        /// </summary>
-        /// <returns></returns>
-        internal IEnumerable<IContent> GetAllPublished()
-        {
-            //create it once if it is needed (no need for locking here)
-            if (_notTrashedQuery == null)
-            {
-                _notTrashedQuery = Query<IContent>.Builder.Where(x => x.Trashed == false);
-            }
-
-            using (var uow = UowProvider.GetUnitOfWork(readOnly: true))
-            {
-                var repository = RepositoryFactory.CreateContentRepository(uow);
-                return repository.GetByPublishedVersion(_notTrashedQuery);
-            }
-        }
-
-        /// <summary>
-        /// Gets a collection of <see cref="IContent"/> objects, which has an expiration date less than or equal to today.
-        /// </summary>
-        /// <returns>An Enumerable list of <see cref="IContent"/> objects</returns>
-        public IEnumerable<IContent> GetContentForExpiration()
-        {
-            using (var uow = UowProvider.GetUnitOfWork(readOnly: true))
-            {
-                var repository = RepositoryFactory.CreateContentRepository(uow);
-                var query = Query<IContent>.Builder.Where(x => x.ExpireDate <= DateTime.Now);
-                return repository.GetByQuery(query).Where(x => x.HasPublishedVersion);
-            }
-        }
-
-        /// <summary>
-        /// Gets a collection of <see cref="IContent"/> objects, which has a release date less than or equal to today.
-        /// </summary>
-        /// <returns>An Enumerable list of <see cref="IContent"/> objects</returns>
-        public IEnumerable<IContent> GetContentForRelease()
-        {
-            using (var uow = UowProvider.GetUnitOfWork(readOnly: true))
-            {
-                var repository = RepositoryFactory.CreateContentRepository(uow);
-                var query = Query<IContent>.Builder.Where(x => x.Published == false && x.ReleaseDate <= DateTime.Now);
-                return repository.GetByQuery(query);
-            }
-        }
-
-        /// <summary>
-        /// Gets a collection of an <see cref="IContent"/> objects, which resides in the Recycle Bin
-        /// </summary>
-        /// <returns>An Enumerable list of <see cref="IContent"/> objects</returns>
-        public IEnumerable<IContent> GetContentInRecycleBin()
-        {
-            using (var uow = UowProvider.GetUnitOfWork(readOnly: true))
-            {
-                var repository = RepositoryFactory.CreateContentRepository(uow);
-                var query = Query<IContent>.Builder.Where(x => x.Path.StartsWith(Constants.System.RecycleBinContentPathPrefix));
-                return repository.GetByQuery(query);
-            }
-        }
-
-        /// <summary>
-        /// Checks whether an <see cref="IContent"/> item has any children
-        /// </summary>
-        /// <param name="id">Id of the <see cref="IContent"/></param>
-        /// <returns>True if the content has any children otherwise False</returns>
-        public bool HasChildren(int id)
-        {
-            return CountChildren(id) > 0;
-        }
-
-        internal int CountChildren(int id)
-        {
-            using (var uow = UowProvider.GetUnitOfWork(readOnly: true))
-            {
-                var repository = RepositoryFactory.CreateContentRepository(uow);
-                var query = Query<IContent>.Builder.Where(x => x.ParentId == id);
-                return repository.Count(query);
-            }
-        }
-
-        /// <summary>
-        /// Checks whether an <see cref="IContent"/> item has any published versions
-        /// </summary>
-        /// <param name="id">Id of the <see cref="IContent"/></param>
-        /// <returns>True if the content has any published version otherwise False</returns>
-        public bool HasPublishedVersion(int id)
-        {
-            using (var uow = UowProvider.GetUnitOfWork(readOnly: true))
-            {
-                var repository = RepositoryFactory.CreateContentRepository(uow);
-                var query = Query<IContent>.Builder.Where(x => x.Published == true && x.Id == id && x.Trashed == false);
-                return repository.Count(query) > 0;
-            }
-        }
-
-        /// <summary>
-        /// Checks if the passed in <see cref="IContent"/> can be published based on the anscestors publish state.
-        /// </summary>
-        /// <param name="content"><see cref="IContent"/> to check if anscestors are published</param>
-        /// <returns>True if the Content can be published, otherwise False</returns>
-        public bool IsPublishable(IContent content)
-        {
-            int[] ids;
-            if (content.HasIdentity)
-            {
-                // get ids from path (we have identity)
-                // skip the first one that has to be -1 - and we don't care
-                // skip the last one that has to be "this" - and it's ok to stop at the parent
-                ids = content.Path.Split(',').Skip(1).SkipLast().Select(int.Parse).ToArray();
-            }
-            else
-            {
-                // no path yet (no identity), have to move up to parent
-                // skip the first one that has to be -1 - and we don't care
-                // don't skip the last one that is "parent"
-                var parent = GetById(content.ParentId);
-                if (parent == null) return false;
-                ids = parent.Path.Split(',').Skip(1).Select(int.Parse).ToArray();
-            }
-            if (ids.Length == 0)
-                return false;
-
-            // if the first one is recycle bin, fail fast
-            if (ids[0] == Constants.System.RecycleBinContent)
-                return false;
-
-            // fixme - move to repository?
-            using (var uow = UowProvider.GetUnitOfWork(readOnly: true))
-            {
-                var sql = new Sql(@"
-                    SELECT id
-                    FROM umbracoNode
-                    JOIN cmsDocument ON umbracoNode.id=cmsDocument.nodeId AND cmsDocument.published=@0
-                    WHERE umbracoNode.trashed=@1 AND umbracoNode.id IN (@2)",
-                    true, false, ids);
-                var x = uow.Database.Fetch<int>(sql);
-                return ids.Length == x.Count;
-            }
-        }
-
-        /// <summary>
-        /// This will rebuild the xml structures for content in the database.
-        /// </summary>
-        /// <param name="userId">This is not used for anything</param>
-        /// <returns>True if publishing succeeded, otherwise False</returns>
-        /// <remarks>
-        /// This is used for when a document type alias or a document type property is changed, the xml will need to
-        /// be regenerated.
-        /// </remarks>
-        public bool RePublishAll(int userId = 0)
-        {
-            try
-            {
-                RebuildXmlStructures();
-                return true;
-            }
-            catch (Exception ex)
-            {
-                Logger.Error<ContentService>("An error occurred executing RePublishAll", ex);
-                return false;
-            }
-        }
-
-        /// <summary>
-        /// This will rebuild the xml structures for content in the database.
-        /// </summary>
-        /// <param name="contentTypeIds">
-        /// If specified will only rebuild the xml for the content type's specified, otherwise will update the structure
-        /// for all published content.
-        /// </param>
-        internal void RePublishAll(params int[] contentTypeIds)
-        {
-            try
-            {
-                RebuildXmlStructures(contentTypeIds);
-            }
-            catch (Exception ex)
-            {
-                Logger.Error<ContentService>("An error occurred executing RePublishAll", ex);
-            }
-        }
-
-        /// <summary>
-        /// Publishes a single <see cref="IContent"/> object
-        /// </summary>
-        /// <param name="content">The <see cref="IContent"/> to publish</param>
-        /// <param name="userId">Optional Id of the User issueing the publishing</param>
-        /// <returns>True if publishing succeeded, otherwise False</returns>
-        public bool Publish(IContent content, int userId = 0)
-        {
-            var result = SaveAndPublishDo(content, userId);
-            Logger.Info<ContentService>("Call was made to ContentService.Publish, use PublishWithStatus instead since that method will provide more detailed information on the outcome");
-            return result.Success;
-        }
-
-        /// <summary>
-        /// Publishes a <see cref="IContent"/> object and all its children
-        /// </summary>
-        /// <param name="content">The <see cref="IContent"/> to publish along with its children</param>
-        /// <param name="userId">Optional Id of the User issueing the publishing</param>
-        /// <param name="includeUnpublished"></param>
-        /// <returns>The list of statuses for all published items</returns>
-        IEnumerable<Attempt<PublishStatus>> IContentServiceOperations.PublishWithChildren(IContent content, int userId, bool includeUnpublished)
-        {
-            return PublishWithChildrenDo(content, userId, includeUnpublished);
-        }
-
-        /// <summary>
-        /// Saves and Publishes a single <see cref="IContent"/> object
-        /// </summary>
-        /// <param name="content">The <see cref="IContent"/> to save and publish</param>
-        /// <param name="userId">Optional Id of the User issueing the publishing</param>
-        /// <param name="raiseEvents">Optional boolean indicating whether or not to raise save events.</param>
-        /// <returns>True if publishing succeeded, otherwise False</returns>
-        Attempt<PublishStatus> IContentServiceOperations.SaveAndPublish(IContent content, int userId, bool raiseEvents)
-        {
-            return SaveAndPublishDo(content, userId, raiseEvents);
-        }
-
-        /// <summary>
-        /// Deletes an <see cref="IContent"/> object by moving it to the Recycle Bin
-        /// </summary>
-        /// <remarks>Move an item to the Recycle Bin will result in the item being unpublished</remarks>
-        /// <param name="content">The <see cref="IContent"/> to delete</param>
-        /// <param name="userId">Optional Id of the User deleting the Content</param>
-        Attempt<OperationStatus> IContentServiceOperations.MoveToRecycleBin(IContent content, int userId)
-        {
-            return MoveToRecycleBinDo(content, userId, false);
-        }
-
-        /// <summary>
-        /// Deletes an <see cref="IContent"/> object by moving it to the Recycle Bin
-        /// </summary>
-        /// <remarks>Move an item to the Recycle Bin will result in the item being unpublished</remarks>
-        /// <param name="content">The <see cref="IContent"/> to delete</param>
-        /// <param name="userId">Optional Id of the User deleting the Content</param>
-        /// <param name="ignoreDescendants">
-        /// A boolean indicating to ignore this item's descendant list from also being moved to the recycle bin. This is required for the DeleteContentOfTypes method
-        /// because it has already looked up all descendant nodes that will need to be recycled
-        /// TODO: Fix all of this, it will require a reasonable refactor and most of this stuff should be done at the repo level instead of service sub operations
-        /// </param>
-        private Attempt<OperationStatus> MoveToRecycleBinDo(IContent content, int userId, bool ignoreDescendants)
-        {
-            var evtMsgs = EventMessagesFactory.Get();
-            using (new WriteLock(Locker))
-            {
-                using (var uow = UowProvider.GetUnitOfWork())
-                {
-                    //Hack: this ensures that the entity's path is valid and if not it fixes/persists it
-                    //see: http://issues.umbraco.org/issue/U4-9336
-                    content.EnsureValidPath(Logger, entity => GetById(entity.ParentId), QuickUpdate);
-                    var originalPath = content.Path;
-                    var moveEventInfo = new MoveEventInfo<IContent>(content, originalPath, Constants.System.RecycleBinContent);
-                    var moveEventArgs = new MoveEventArgs<IContent>(evtMsgs, moveEventInfo);
-                    if (uow.Events.DispatchCancelable(Trashing, this, moveEventArgs, "Trashing"))
-                    {
-                        uow.Commit();
-                        return OperationStatus.Cancelled(evtMsgs);
-                    }
-                    var moveInfo = new List<MoveEventInfo<IContent>>
-                    {
-                        moveEventInfo
-                    };
-
-                    //get descendents to process of the content item that is being moved to trash - must be done before changing the state below
-                    //must be processed with shallowest levels first
-                    var descendants = ignoreDescendants ? Enumerable.Empty<IContent>() : GetDescendants(content).OrderBy(x => x.Level);
-
-                    //Do the updates for this item
-                    var repository = RepositoryFactory.CreateContentRepository(uow);
-                    //Make sure that published content is unpublished before being moved to the Recycle Bin
-                    if (HasPublishedVersion(content.Id))
-                    {
-                        //TODO: this shouldn't be a 'sub operation', and if it needs to be it cannot raise events and cannot be cancelled!
-                        UnPublish(content, userId);
-                    }
-                    content.WriterId = userId;
-                    content.ChangeTrashedState(true);
-                    repository.AddOrUpdate(content);
-
-                    //Loop through descendants to update their trash state, but ensuring structure by keeping the ParentId
-                    foreach (var descendant in descendants)
-                    {
-                        //TODO: this shouldn't be a 'sub operation', and if it needs to be it cannot raise events and cannot be cancelled!
-                        UnPublish(descendant, userId);
-                        descendant.WriterId = userId;
-                        descendant.ChangeTrashedState(true, descendant.ParentId);
-                        repository.AddOrUpdate(descendant);
-
-                        moveInfo.Add(new MoveEventInfo<IContent>(descendant, descendant.Path, descendant.ParentId));
-                    }
-
-                    moveEventArgs.CanCancel = false;
-                    moveEventArgs.MoveInfoCollection = moveInfo;
-                    uow.Events.Dispatch(Trashed, this, moveEventArgs, "Trashed");
-
-                    Audit(uow, AuditType.Move, "Move Content to Recycle Bin performed by user", userId, content.Id);
-                    uow.Commit();
-                }
-
-                return OperationStatus.Success(evtMsgs);
-            }
-        }
-
-        /// <summary>
-        /// UnPublishes a single <see cref="IContent"/> object
-        /// </summary>
-        /// <param name="content">The <see cref="IContent"/> to publish</param>
-        /// <param name="userId">Optional Id of the User issueing the publishing</param>
-        /// <returns>True if unpublishing succeeded, otherwise False</returns>
-        Attempt<UnPublishStatus> IContentServiceOperations.UnPublish(IContent content, int userId)
-        {
-            return UnPublishDo(content, false, userId);
-        }
-
-        /// <summary>
-        /// Publishes a single <see cref="IContent"/> object
-        /// </summary>
-        /// <param name="content">The <see cref="IContent"/> to publish</param>
-        /// <param name="userId">Optional Id of the User issueing the publishing</param>
-        /// <returns>True if publishing succeeded, otherwise False</returns>
-        public Attempt<PublishStatus> PublishWithStatus(IContent content, int userId = 0)
-        {
-            return ((IContentServiceOperations)this).Publish(content, userId);
-        }
-
-        /// <summary>
-        /// Publishes a <see cref="IContent"/> object and all its children
-        /// </summary>
-        /// <param name="content">The <see cref="IContent"/> to publish along with its children</param>
-        /// <param name="userId">Optional Id of the User issueing the publishing</param>
-        /// <returns>True if publishing succeeded, otherwise False</returns>
-        [Obsolete("Use PublishWithChildrenWithStatus instead, that method will provide more detailed information on the outcome and also allows the includeUnpublished flag")]
-        public bool PublishWithChildren(IContent content, int userId = 0)
-        {
-            var result = PublishWithChildrenDo(content, userId, true);
-
-            //This used to just return false only when the parent content failed, otherwise would always return true so we'll
-            // do the same thing for the moment
-            if (result.All(x => x.Result.ContentItem.Id != content.Id))
-                return false;
-
-            return result.Single(x => x.Result.ContentItem.Id == content.Id).Success;
-        }
-
-        /// <summary>
-        /// Publishes a <see cref="IContent"/> object and all its children
-        /// </summary>
-        /// <param name="content">The <see cref="IContent"/> to publish along with its children</param>
-        /// <param name="userId">Optional Id of the User issueing the publishing</param>
-        /// <param name="includeUnpublished">set to true if you want to also publish children that are currently unpublished</param>
-        /// <returns>True if publishing succeeded, otherwise False</returns>
-        public IEnumerable<Attempt<PublishStatus>> PublishWithChildrenWithStatus(IContent content, int userId = 0, bool includeUnpublished = false)
-        {
-            return ((IContentServiceOperations)this).PublishWithChildren(content, userId, includeUnpublished);
-        }
-
-        /// <summary>
-        /// UnPublishes a single <see cref="IContent"/> object
-        /// </summary>
-        /// <param name="content">The <see cref="IContent"/> to publish</param>
-        /// <param name="userId">Optional Id of the User issueing the publishing</param>
-        /// <returns>True if unpublishing succeeded, otherwise False</returns>
-        public bool UnPublish(IContent content, int userId = 0)
-        {
-            var attempt = ((IContentServiceOperations)this).UnPublish(content, userId);
-            LogHelper.Debug<ContentService>(string.Format("Result of unpublish attempt: {0}", attempt.Result.StatusType));
-            return attempt.Success;
-        }
-
-        /// <summary>
-        /// Saves and Publishes a single <see cref="IContent"/> object
-        /// </summary>
-        /// <param name="content">The <see cref="IContent"/> to save and publish</param>
-        /// <param name="userId">Optional Id of the User issueing the publishing</param>
-        /// <param name="raiseEvents">Optional boolean indicating whether or not to raise save events.</param>
-        /// <returns>True if publishing succeeded, otherwise False</returns>
-        [Obsolete("Use SaveAndPublishWithStatus instead, that method will provide more detailed information on the outcome")]
-        public bool SaveAndPublish(IContent content, int userId = 0, bool raiseEvents = true)
-        {
-            var result = SaveAndPublishDo(content, userId, raiseEvents);
-            return result.Success;
-        }
-
-        /// <summary>
-        /// Saves and Publishes a single <see cref="IContent"/> object
-        /// </summary>
-        /// <param name="content">The <see cref="IContent"/> to save and publish</param>
-        /// <param name="userId">Optional Id of the User issueing the publishing</param>
-        /// <param name="raiseEvents">Optional boolean indicating whether or not to raise save events.</param>
-        /// <returns>True if publishing succeeded, otherwise False</returns>
-        public Attempt<PublishStatus> SaveAndPublishWithStatus(IContent content, int userId = 0, bool raiseEvents = true)
-        {
-            return ((IContentServiceOperations)this).SaveAndPublish(content, userId, raiseEvents);
-        }
-
-        public IContent GetBlueprintById(int id)
-        {
-            using (var uow = UowProvider.GetUnitOfWork(readOnly: true))
-            {
-                var repository = RepositoryFactory.CreateContentBlueprintRepository(uow);
-                var blueprint = repository.Get(id);
-                if (blueprint != null)
-                    ((Content) blueprint).IsBlueprint = true;
-                return blueprint;
-            }
-        }
-
-        public IContent GetBlueprintById(Guid id)
-        {
-            using (var uow = UowProvider.GetUnitOfWork(readOnly: true))
-            {
-                var repository = RepositoryFactory.CreateContentBlueprintRepository(uow);
-                var blueprint = repository.Get(id);
-                if (blueprint != null)
-                    ((Content)blueprint).IsBlueprint = true;
-                return blueprint;
-            }
-        }
-
-        public void SaveBlueprint(IContent content, int userId = 0)
-        {
-            //always ensure the blueprint is at the root
-            if (content.ParentId != -1)
-                content.ParentId = -1;
-
-            ((Content) content).IsBlueprint = true;
-
-            using (new WriteLock(Locker))
-            {
-                using (var uow = UowProvider.GetUnitOfWork())
-                {
-                    if (string.IsNullOrWhiteSpace(content.Name))
-                    {
-                        throw new ArgumentException("Cannot save content blueprint with empty name.");
-                    }
-
-                    var repository = RepositoryFactory.CreateContentBlueprintRepository(uow);
-
-                    if (content.HasIdentity == false)
-                    {
-                        content.CreatorId = userId;
-                    }
-                    content.WriterId = userId;
-
-                    repository.AddOrUpdate(content);
-
-                    uow.Events.Dispatch(SavedBlueprint, this, new SaveEventArgs<IContent>(content), "SavedBlueprint");
-
-                    uow.Commit();
-                }
-            }
-        }
-
-        public void DeleteBlueprint(IContent content, int userId = 0)
-        {
-            using (new WriteLock(Locker))
-            {
-                using (var uow = UowProvider.GetUnitOfWork())
-                {
-                    var repository = RepositoryFactory.CreateContentBlueprintRepository(uow);
-                    repository.Delete(content);
-                    uow.Events.Dispatch(DeletedBlueprint, this, new DeleteEventArgs<IContent>(content), "DeletedBlueprint");
-                    uow.Commit();
-                }
-            }
-        }
-
-        public IContent CreateContentFromBlueprint(IContent blueprint, string name, int userId = 0)
-        {
-            if (blueprint == null) throw new ArgumentNullException("blueprint");
-
-            var contentType = blueprint.ContentType;
-            var content = new Content(name, -1, contentType);
-            content.Path = string.Concat(content.ParentId.ToString(), ",", content.Id);
-
-            content.CreatorId = userId;
-            content.WriterId = userId;
-
-            foreach (var property in blueprint.Properties)
-                content.SetValue(property.Alias, property.Value);
-
-            return content;
-        }
-
-        public void DeleteBlueprintsOfTypes(IEnumerable<int> contentTypeIds, int userId = 0)
-        {
-            using (new WriteLock(Locker))
-            using (var uow = UowProvider.GetUnitOfWork())
-            {
-                var repository = RepositoryFactory.CreateContentBlueprintRepository(uow);
-
-                var contentTypeIdsA = contentTypeIds.ToArray();
-                var query = new Query<IContent>();
-                if (contentTypeIdsA.Length > 0)
-                {
-                    query.Where(x => contentTypeIdsA.Contains(x.ContentTypeId));
-                }
-                var blueprints = repository.GetByQuery(query).Select(x =>
-                {
-                    ((Content) x).IsBlueprint = true;
-                    return x;
-                }).ToArray();
-
-                foreach (var blueprint in blueprints)
-                {
-                    repository.Delete(blueprint);
-                }
-
-                uow.Events.Dispatch(DeletedBlueprint, this, new DeleteEventArgs<IContent>(blueprints), "DeletedBlueprint");
-                uow.Commit();
-            }
-        }
-
-        public void DeleteBlueprintsOfType(int contentTypeId, int userId = 0)
-        {
-            DeleteBlueprintsOfTypes(new[] {contentTypeId}, userId);
-        }
-
-        /// <summary>
-        /// Saves a single <see cref="IContent"/> object
-        /// </summary>
-        /// <param name="content">The <see cref="IContent"/> to save</param>
-        /// <param name="userId">Optional Id of the User saving the Content</param>
-        /// <param name="raiseEvents">Optional boolean indicating whether or not to raise events.</param>
-        public void Save(IContent content, int userId = 0, bool raiseEvents = true)
-        {
-            ((IContentServiceOperations)this).Save(content, userId, raiseEvents);
-        }
-
-        /// <summary>
-        /// Saves a collection of <see cref="IContent"/> objects.
-        /// </summary>
-        /// <param name="contents">Collection of <see cref="IContent"/> to save</param>
-        /// <param name="userId">Optional Id of the User saving the Content</param>
-        /// <param name="raiseEvents">Optional boolean indicating whether or not to raise events.</param>
-        Attempt<OperationStatus> IContentServiceOperations.Save(IEnumerable<IContent> contents, int userId, bool raiseEvents)
-        {
-            var asArray = contents.ToArray();
-
-            var evtMsgs = EventMessagesFactory.Get();
-
-            using (var uow = UowProvider.GetUnitOfWork())
-            {
-                var saveEventArgs = new SaveEventArgs<IContent>(asArray, evtMsgs);
-                if (raiseEvents && uow.Events.DispatchCancelable(Saving, this, saveEventArgs, "Saving"))
-                {
-                    uow.Commit();
-                    return OperationStatus.Cancelled(evtMsgs);
-                }
-
-                // todo - understand what's a lock in a scope?
-                // (though, these locks are refactored in v8)
-                using (new WriteLock(Locker))
-                {
-                    var containsNew = asArray.Any(x => x.HasIdentity == false);
-                    var repository = RepositoryFactory.CreateContentRepository(uow);
-
-                    if (containsNew)
-                    {
-                        foreach (var content in asArray)
-                        {
-                            content.WriterId = userId;
-
-                            //Only change the publish state if the "previous" version was actually published
-                            if (content.Published)
-                                content.ChangePublishedState(PublishedState.Saved);
-
-                            repository.AddOrUpdate(content);
-                            //add or update preview
-                            repository.AddOrUpdatePreviewXml(content, c => _entitySerializer.Serialize(this, _dataTypeService, _userService, c));
-                        }
-                    }
-                    else
-                    {
-                        foreach (var content in asArray)
-                        {
-                            content.WriterId = userId;
-                            repository.AddOrUpdate(content);
-                            //add or update preview
-                            repository.AddOrUpdatePreviewXml(content, c => _entitySerializer.Serialize(this, _dataTypeService, _userService, c));
-                        }
-                    }
-                }
-
-                if (raiseEvents)
-                {
-                    saveEventArgs.CanCancel = false;
-                    uow.Events.Dispatch(Saved, this, saveEventArgs, "Saved");
-                }
-
-                Audit(uow, AuditType.Save, "Bulk Save content performed by user", userId == -1 ? 0 : userId, Constants.System.Root);
-                uow.Commit();
-
-                return OperationStatus.Success(evtMsgs);
-            }
-        }
-
-        /// <summary>
-        /// Permanently deletes an <see cref="IContent"/> object.
-        /// </summary>
-        /// <remarks>
-        /// This method will also delete associated media files, child content and possibly associated domains.
-        /// </remarks>
-        /// <remarks>Please note that this method will completely remove the Content from the database</remarks>
-        /// <param name="content">The <see cref="IContent"/> to delete</param>
-        /// <param name="userId">Optional Id of the User deleting the Content</param>
-        Attempt<OperationStatus> IContentServiceOperations.Delete(IContent content, int userId)
-        {
-            var evtMsgs = EventMessagesFactory.Get();
-
-            using (new WriteLock(Locker))
-            {
-                using (var uow = UowProvider.GetUnitOfWork())
-                {
-                    var deleteEventArgs = new DeleteEventArgs<IContent>(content, evtMsgs);
-                    if (uow.Events.DispatchCancelable(Deleting, this, deleteEventArgs, "Deleting"))
-                    {
-                        uow.Commit();
-                        return OperationStatus.Cancelled(evtMsgs);
-                    }
-
-                    //Make sure that published content is unpublished before being deleted
-                    if (HasPublishedVersion(content.Id))
-                    {
-                        UnPublish(content, userId);
-                    }
-
-                    //Delete children before deleting the 'possible parent'
-                    var children = GetChildren(content.Id);
-                    foreach (var child in children)
-                    {
-                        Delete(child, userId);
-                    }
-
-                    var repository = RepositoryFactory.CreateContentRepository(uow);
-
-                    repository.Delete(content);
-
-                    deleteEventArgs.CanCancel = false;
-                    uow.Events.Dispatch(Deleted, this, deleteEventArgs, "Deleted");
-
-                    Audit(uow, AuditType.Delete, "Delete Content performed by user", userId, content.Id);
-                    uow.Commit();
-                }
-
-                return OperationStatus.Success(evtMsgs);
-            }
-        }
-
-        /// <summary>
-        /// Publishes a single <see cref="IContent"/> object
-        /// </summary>
-        /// <param name="content">The <see cref="IContent"/> to publish</param>
-        /// <param name="userId">Optional Id of the User issueing the publishing</param>
-        /// <returns>The published status attempt</returns>
-        Attempt<PublishStatus> IContentServiceOperations.Publish(IContent content, int userId)
-        {
-            return SaveAndPublishDo(content, userId);
-        }
-
-        /// <summary>
-        /// Saves a single <see cref="IContent"/> object
-        /// </summary>
-        /// <param name="content">The <see cref="IContent"/> to save</param>
-        /// <param name="userId">Optional Id of the User saving the Content</param>
-        /// <param name="raiseEvents">Optional boolean indicating whether or not to raise events.</param>
-        Attempt<OperationStatus> IContentServiceOperations.Save(IContent content, int userId, bool raiseEvents)
-        {
-            return Save(content, true, userId, raiseEvents);
-        }
-
-        /// <summary>
-        /// Saves a collection of <see cref="IContent"/> objects.
-        /// </summary>
-        /// <remarks>
-        /// If the collection of content contains new objects that references eachother by Id or ParentId,
-        /// then use the overload Save method with a collection of Lazy <see cref="IContent"/>.
-        /// </remarks>
-        /// <param name="contents">Collection of <see cref="IContent"/> to save</param>
-        /// <param name="userId">Optional Id of the User saving the Content</param>
-        /// <param name="raiseEvents">Optional boolean indicating whether or not to raise events.</param>
-        public void Save(IEnumerable<IContent> contents, int userId = 0, bool raiseEvents = true)
-        {
-            ((IContentServiceOperations)this).Save(contents, userId, raiseEvents);
-        }
-
-        /// <summary>
-        /// Deletes all content of the specified types. All Descendants of deleted content that is not of these types is moved to Recycle Bin.
-        /// </summary>
-        /// <param name="contentTypeIds">Id of the <see cref="IContentType"/></param>
-        /// <param name="userId">Optional Id of the user issueing the delete operation</param>
-        public void DeleteContentOfTypes(IEnumerable<int> contentTypeIds, int userId = 0)
-        {
-            using (new WriteLock(Locker))
-            using (var uow = UowProvider.GetUnitOfWork())
-            {
-                var repository = RepositoryFactory.CreateContentRepository(uow);
-
-                //track the 'root' items of the collection of nodes discovered to delete, we need to use
-                //these items to lookup descendants that are not of this doc type so they can be transfered
-                //to the recycle bin
-                IDictionary<string, IContent> rootItems;
-                var contentToDelete = this.TrackDeletionsForDeleteContentOfTypes(contentTypeIds, repository, out rootItems).ToArray();
-
-                if (uow.Events.DispatchCancelable(Deleting, this, new DeleteEventArgs<IContent>(contentToDelete), "Deleting"))
-                {
-                    uow.Commit();
-                    return;
-                }
-
-                //Determine the items that will need to be recycled (that are children of these content items but not of these content types)
-                var contentToRecycle = this.TrackTrashedForDeleteContentOfTypes(contentTypeIds, rootItems, repository);
-
-                //move each item to the bin starting with the deepest items
-                foreach (var child in contentToRecycle.OrderByDescending(x => x.Level))
-                {
-                    MoveToRecycleBinDo(child, userId, true);
-                }
-
-                foreach (var content in contentToDelete)
-                {
-                    Delete(content, userId);
-                }
-
-                Audit(uow, AuditType.Delete,
-                    string.Format("Delete Content of Types {0} performed by user", string.Join(",", contentTypeIds)),
-                    userId, Constants.System.Root);
-                uow.Commit();
-            }
-        }
-
-        /// <summary>
-        /// Deletes all content of specified type. All children of deleted content is moved to Recycle Bin.
-        /// </summary>
-        /// <remarks>This needs extra care and attention as its potentially a dangerous and extensive operation</remarks>
-        /// <param name="contentTypeId">Id of the <see cref="IContentType"/></param>
-        /// <param name="userId">Optional Id of the user issueing the delete operation</param>
-        public void DeleteContentOfType(int contentTypeId, int userId = 0)
-        {
-            DeleteContentOfTypes(new[] {contentTypeId}, userId);
-        }
-
-        /// <summary>
-        /// Permanently deletes an <see cref="IContent"/> object as well as all of its Children.
-        /// </summary>
-        /// <remarks>
-        /// This method will also delete associated media files, child content and possibly associated domains.
-        /// </remarks>
-        /// <remarks>Please note that this method will completely remove the Content from the database</remarks>
-        /// <param name="content">The <see cref="IContent"/> to delete</param>
-        /// <param name="userId">Optional Id of the User deleting the Content</param>
-        public void Delete(IContent content, int userId = 0)
-        {
-            ((IContentServiceOperations)this).Delete(content, userId);
-        }
-
-        /// <summary>
-        /// Permanently deletes versions from an <see cref="IContent"/> object prior to a specific date.
-        /// This method will never delete the latest version of a content item.
-        /// </summary>
-        /// <param name="id">Id of the <see cref="IContent"/> object to delete versions from</param>
-        /// <param name="versionDate">Latest version date</param>
-        /// <param name="userId">Optional Id of the User deleting versions of a Content object</param>
-        public void DeleteVersions(int id, DateTime versionDate, int userId = 0)
-        {
-            using (var uow = UowProvider.GetUnitOfWork())
-            {
-                var deleteRevisionsEventArgs = new DeleteRevisionsEventArgs(id, dateToRetain: versionDate);
-                if (uow.Events.DispatchCancelable(DeletingVersions, this, deleteRevisionsEventArgs, "DeletingVersions"))
-                {
-                    uow.Commit();
-                    return;
-                }
-
-                var repository = RepositoryFactory.CreateContentRepository(uow);
-                repository.DeleteVersions(id, versionDate);
-                deleteRevisionsEventArgs.CanCancel = false;
-                uow.Events.Dispatch(DeletedVersions, this, deleteRevisionsEventArgs, "DeletedVersions");
-
-                Audit(uow, AuditType.Delete, "Delete Content by version date performed by user", userId, Constants.System.Root);
-                uow.Commit();
-            }
-        }
-
-        /// <summary>
-        /// Permanently deletes specific version(s) from an <see cref="IContent"/> object.
-        /// This method will never delete the latest version of a content item.
-        /// </summary>
-        /// <param name="id">Id of the <see cref="IContent"/> object to delete a version from</param>
-        /// <param name="versionId">Id of the version to delete</param>
-        /// <param name="deletePriorVersions">Boolean indicating whether to delete versions prior to the versionId</param>
-        /// <param name="userId">Optional Id of the User deleting versions of a Content object</param>
-        public void DeleteVersion(int id, Guid versionId, bool deletePriorVersions, int userId = 0)
-        {
-            using (new WriteLock(Locker))
-            {
-                using (var uow = UowProvider.GetUnitOfWork())
-                {
-                    if (uow.Events.DispatchCancelable(DeletingVersions, this, new DeleteRevisionsEventArgs(id, specificVersion: versionId), "DeletingVersions"))
-                    {
-                        uow.Commit();
-                        return;
-                    }
-
-                    if (deletePriorVersions)
-                    {
-                        var content = GetByVersion(versionId);
-                        DeleteVersions(id, content.UpdateDate, userId);
-                    }
-
-                    var repository = RepositoryFactory.CreateContentRepository(uow);
-                    repository.DeleteVersion(versionId);
-
-                    uow.Events.Dispatch(DeletedVersions, this, new DeleteRevisionsEventArgs(id, false, specificVersion: versionId), "DeletedVersions");
-
-                    Audit(uow, AuditType.Delete, "Delete Content by version performed by user", userId, Constants.System.Root);
-                    uow.Commit();
-                }
-            }
-        }
-
-        /// <summary>
-        /// Deletes an <see cref="IContent"/> object by moving it to the Recycle Bin
-        /// </summary>
-        /// <remarks>Move an item to the Recycle Bin will result in the item being unpublished</remarks>
-        /// <param name="content">The <see cref="IContent"/> to delete</param>
-        /// <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);
-        }
-
-        /// <summary>
-        /// Moves an <see cref="IContent"/> object to a new location by changing its parent id.
-        /// </summary>
-        /// <remarks>
-        /// If the <see cref="IContent"/> object is already published it will be
-        /// published after being moved to its new location. Otherwise it'll just
-        /// be saved with a new parent id.
-        /// </remarks>
-        /// <param name="content">The <see cref="IContent"/> to move</param>
-        /// <param name="parentId">Id of the Content's new Parent</param>
-        /// <param name="userId">Optional Id of the User moving the Content</param>
-        public void Move(IContent content, int parentId, int userId = 0)
-        {
-            using (new WriteLock(Locker))
-            {
-                //This ensures that the correct method is called if this method is used to Move to recycle bin.
-                if (parentId == Constants.System.RecycleBinContent)
-                {
-                    MoveToRecycleBin(content, userId);
-                    return;
-                }
-
-                using (var uow = UowProvider.GetUnitOfWork())
-                {
-                    var moveEventInfo = new MoveEventInfo<IContent>(content, content.Path, parentId);
-                    var moveEventArgs = new MoveEventArgs<IContent>(moveEventInfo);
-                    if (uow.Events.DispatchCancelable(Moving, this, moveEventArgs, "Moving"))
-                    {
-                        uow.Commit();
-                        return;
-                    }
-
-                    //used to track all the moved entities to be given to the event
-                    var moveInfo = new List<MoveEventInfo<IContent>>();
-
-                    //call private method that does the recursive moving
-                    PerformMove(content, parentId, userId, moveInfo);
-
-                    moveEventArgs.MoveInfoCollection = moveInfo;
-                    moveEventArgs.CanCancel = false;
-                    uow.Events.Dispatch(Moved, this, moveEventArgs, "Moved");
-
-                    Audit(uow, AuditType.Move, "Move Content performed by user", userId, content.Id);
-                    uow.Commit();
-                }
-            }
-        }
-
-        /// <summary>
-        /// Empties the Recycle Bin by deleting all <see cref="IContent"/> that resides in the bin
-        /// </summary>
-        [EditorBrowsable(EditorBrowsableState.Never)]
-        [Obsolete("Use EmptyRecycleBin with explicit indication of user ID instead")]
-        public void EmptyRecycleBin() => EmptyRecycleBin(0);
-
-        /// <summary>
-        /// Empties the Recycle Bin by deleting all <see cref="IContent"/> that resides in the bin
-        /// </summary>
-        /// <param name="userId">Optional Id of the User emptying the Recycle Bin</param>
-        public void EmptyRecycleBin(int userId = 0)
-        {
-            using (new WriteLock(Locker))
-            {
-                var nodeObjectType = Constants.ObjectTypes.DocumentGuid;
-
-                using (var uow = UowProvider.GetUnitOfWork())
-                {
-                    var repository = RepositoryFactory.CreateContentRepository(uow);
-
-                    //Create a dictionary of ids -> dictionary of property aliases + values
-                    var entities = repository.GetEntitiesInRecycleBin()
-                        .ToDictionary(
-                            key => key.Id,
-                            val => (IEnumerable<Property>)val.Properties);
-
-                    var files = ((ContentRepository)repository).GetFilesInRecycleBinForUploadField();
-
-                    var recycleBinEventArgs = new RecycleBinEventArgs(nodeObjectType, entities, files);
-                    if (uow.Events.DispatchCancelable(EmptyingRecycleBin, this, recycleBinEventArgs))
-                    {
-                        uow.Commit();
-                        return;
-                    }
-
-                    var success = repository.EmptyRecycleBin();
-                    recycleBinEventArgs.CanCancel = false;
-                    recycleBinEventArgs.RecycleBinEmptiedSuccessfully = success;
-                    uow.Events.Dispatch(EmptiedRecycleBin, this, recycleBinEventArgs);
-
-                    Audit(uow, AuditType.Delete, "Empty Content Recycle Bin performed by user", userId, Constants.System.RecycleBinContent);
-                    uow.Commit();
-                }
-            }
-        }
-
-        /// <summary>
-        /// Copies an <see cref="IContent"/> object by creating a new Content object of the same type and copies all data from the current
-        /// to the new copy which is returned. Recursively copies all children.
-        /// </summary>
-        /// <param name="content">The <see cref="IContent"/> to copy</param>
-        /// <param name="parentId">Id of the Content's new Parent</param>
-        /// <param name="relateToOriginal">Boolean indicating whether the copy should be related to the original</param>
-        /// <param name="userId">Optional Id of the User copying the Content</param>
-        /// <returns>The newly created <see cref="IContent"/> object</returns>
-        public IContent Copy(IContent content, int parentId, bool relateToOriginal, int userId = 0)
-        {
-            return Copy(content, parentId, relateToOriginal, true, userId);
-        }
-
-        /// <summary>
-        /// Copies an <see cref="IContent"/> object by creating a new Content object of the same type and copies all data from the current
-        /// to the new copy which is returned.
-        /// </summary>
-        /// <param name="content">The <see cref="IContent"/> to copy</param>
-        /// <param name="parentId">Id of the Content's new Parent</param>
-        /// <param name="relateToOriginal">Boolean indicating whether the copy should be related to the original</param>
-        /// <param name="recursive">A value indicating whether to recursively copy children.</param>
-        /// <param name="userId">Optional Id of the User copying the Content</param>
-        /// <returns>The newly created <see cref="IContent"/> object</returns>
-        public IContent Copy(IContent content, int parentId, bool relateToOriginal, bool recursive, int userId = 0)
-        {
-            //TODO: This all needs to be managed correctly so that the logic is submitted in one
-            // transaction, the CRUD needs to be moved to the repo
-
-            using (new WriteLock(Locker))
-            {
-                var copy = content.DeepCloneWithResetIdentities();
-                copy.ParentId = parentId;
-
-                // A copy should never be set to published automatically even if the original was.
-                copy.ChangePublishedState(PublishedState.Unpublished);
-
-                using (var uow = UowProvider.GetUnitOfWork())
-                {
-                    var copyEventArgs = new CopyEventArgs<IContent>(content, copy, true, parentId, relateToOriginal);
-                    if (uow.Events.DispatchCancelable(Copying, this, copyEventArgs))
-                    {
-                        uow.Commit();
-                        return null;
-                    }
-
-                    var repository = RepositoryFactory.CreateContentRepository(uow);
-
-                    // Update the create author and last edit author
-                    copy.CreatorId = userId;
-                    copy.WriterId = userId;
-
-                    //get the current permissions, if there are any explicit ones they need to be copied
-                    var currentPermissions = GetPermissionsForEntity(content);
-                    currentPermissions.RemoveWhere(p => p.IsDefaultPermissions);
-
-                    repository.AddOrUpdate(copy);
-                    repository.AddOrUpdatePreviewXml(copy, c => _entitySerializer.Serialize(this, _dataTypeService, _userService, c));
-
-                    //add permissions
-                    if (currentPermissions.Count > 0)
-                    {
-                        var permissionSet = new ContentPermissionSet(copy, currentPermissions);
-                        repository.AddOrUpdatePermissions(permissionSet);
-                    }
-
-                    uow.Commit(); // todo - this should flush, not commit
-
-                    //Special case for the associated tags
-                    //TODO: Move this to the repository layer in a single transaction!
-                    //don't copy tags data in tags table if the item is in the recycle bin
-                    if (parentId != Constants.System.RecycleBinContent)
-                    {
-                        var tags = uow.Database.Fetch<TagRelationshipDto>("WHERE nodeId = @Id", new { Id = content.Id });
-                        foreach (var tag in tags)
-                            uow.Database.Insert(new TagRelationshipDto
-                            {
-                                NodeId = copy.Id, TagId = tag.TagId, PropertyTypeId = tag.PropertyTypeId
-                            });
-                    }
-                    uow.Commit(); // todo - this should flush, not commit
-
-                    if (recursive)
-                    {
-                        //Look for children and copy those as well
-                        var children = GetChildren(content.Id);
-                        foreach (var child in children)
-                        {
-                            //TODO: This shouldn't recurse back to this method, it should be done in a private method
-                            // that doesn't have a nested lock and so we can perform the entire operation in one commit.
-                            Copy(child, copy.Id, relateToOriginal, true, userId);
-                        }
-                    }
-                    copyEventArgs.CanCancel = false;
-                    uow.Events.Dispatch(Copied, this, copyEventArgs);
-                    Audit(uow, AuditType.Copy, "Copy Content performed by user", userId, content.Id);
-                    uow.Commit();
-                }
-
-                return copy;
-            }
-        }
-
-
-        /// <summary>
-        /// Sends an <see cref="IContent"/> to Publication, which executes handlers and events for the 'Send to Publication' action.
-        /// </summary>
-        /// <param name="content">The <see cref="IContent"/> to send to publication</param>
-        /// <param name="userId">Optional Id of the User issueing the send to publication</param>
-        /// <returns>True if sending publication was succesfull otherwise false</returns>
-        public bool SendToPublication(IContent content, int userId = 0)
-        {
-            using (var uow = UowProvider.GetUnitOfWork())
-            {
-                var sendToPublishEventArgs = new SendToPublishEventArgs<IContent>(content);
-                if (uow.Events.DispatchCancelable(SendingToPublish, this, sendToPublishEventArgs))
-                {
-                    uow.Commit();
-                    return false;
-                }
-
-                //Save before raising event
-                Save(content, userId);
-                sendToPublishEventArgs.CanCancel = false;
-                uow.Events.Dispatch(SentToPublish, this, sendToPublishEventArgs);
-
-                Audit(uow, AuditType.SendToPublish, "Send to Publish performed by user", content.WriterId, content.Id);
-                uow.Commit();
-
-                return true;
-            }
-        }
-
-        /// <summary>
-        /// Rollback an <see cref="IContent"/> object to a previous version.
-        /// This will create a new version, which is a copy of all the old data.
-        /// </summary>
-        /// <remarks>
-        /// The way data is stored actually only allows us to rollback on properties
-        /// and not data like Name and Alias of the Content.
-        /// </remarks>
-        /// <param name="id">Id of the <see cref="IContent"/>being rolled back</param>
-        /// <param name="versionId">Id of the version to rollback to</param>
-        /// <param name="userId">Optional Id of the User issueing the rollback of the Content</param>
-        /// <returns>The newly created <see cref="IContent"/> object</returns>
-        public IContent Rollback(int id, Guid versionId, int userId = 0)
-        {
-            var content = GetByVersion(versionId);
-
-            using (var uow = UowProvider.GetUnitOfWork())
-            {
-                var rollbackEventArgs = new RollbackEventArgs<IContent>(content);
-                if (uow.Events.DispatchCancelable(RollingBack, this, rollbackEventArgs))
-                {
-                    uow.Commit();
-                    return content;
-                }
-
-                var repository = RepositoryFactory.CreateContentRepository(uow);
-
-                content.WriterId = userId;
-                content.CreatorId = userId;
-                content.ChangePublishedState(PublishedState.Unpublished);
-
-                repository.AddOrUpdate(content);
-                repository.AddOrUpdatePreviewXml(content, c => _entitySerializer.Serialize(this, _dataTypeService, _userService, c));
-                rollbackEventArgs.CanCancel = false;
-                uow.Events.Dispatch(RolledBack, this, rollbackEventArgs);
-
-                Audit(uow, AuditType.RollBack, "Content rollback performed by user", content.WriterId, content.Id);
-                uow.Commit();
-            }
-
-            return content;
-        }
-
-        /// <summary>
-        /// Sorts a collection of <see cref="IContent"/> objects by updating the SortOrder according
-        /// to the ordering of items in the passed in <see cref="IEnumerable{T}"/>.
-        /// </summary>
-        /// <remarks>
-        /// Using this method will ensure that the Published-state is maintained upon sorting
-        /// so the cache is updated accordingly - as needed.
-        /// </remarks>
-        /// <param name="items"></param>
-        /// <param name="userId"></param>
-        /// <param name="raiseEvents"></param>
-        /// <returns>True if sorting succeeded, otherwise False</returns>
-        public bool Sort(IEnumerable<IContent> items, int userId = 0, bool raiseEvents = true)
-        {
-            var shouldBePublished = new List<IContent>();
-            var shouldBeSaved = new List<IContent>();
-
-            using (new WriteLock(Locker))
-            {
-                using (var uow = UowProvider.GetUnitOfWork())
-                {
-                    var asArray = items.ToArray();
-                    var saveEventArgs = new SaveEventArgs<IContent>(asArray);
-                    if (raiseEvents && uow.Events.DispatchCancelable(Saving, this, saveEventArgs, "Saving"))
-                    {
-                        uow.Commit();
-                        return false;
-                    }
-
-                    var repository = RepositoryFactory.CreateContentRepository(uow);
-
-                    var i = 0;
-                    foreach (var content in asArray)
-                    {
-                        //If the current sort order equals that of the content
-                        //we don't need to update it, so just increment the sort order
-                        //and continue.
-                        if (content.SortOrder == i)
-                        {
-                            i++;
-                            continue;
-                        }
-
-                        content.SortOrder = i;
-                        content.WriterId = userId;
-                        i++;
-
-                        if (content.Published)
-                        {
-                            //TODO: This should not be an inner operation, but if we do this, it cannot raise events and cannot be cancellable!
-                            var published = _publishingStrategy.Publish(uow, content, userId).Success;
-                            shouldBePublished.Add(content);
-                        }
-                        else
-                            shouldBeSaved.Add(content);
-
-                        repository.AddOrUpdate(content);
-                        //add or update a preview
-                        repository.AddOrUpdatePreviewXml(content, c => _entitySerializer.Serialize(this, _dataTypeService, _userService, c));
-                    }
-
-                    foreach (var content in shouldBePublished)
-                    {
-                        //Create and Save ContentXml DTO
-                        repository.AddOrUpdateContentXml(content, c => _entitySerializer.Serialize(this, _dataTypeService, _userService, c));
-                    }
-
-                    if (raiseEvents)
-                    {
-                        saveEventArgs.CanCancel = false;
-                        uow.Events.Dispatch(Saved, this, saveEventArgs, "Saved");
-                    }
-
-                    if (shouldBePublished.Any())
-                    {
-                        //TODO: This should not be an inner operation, but if we do this, it cannot raise events and cannot be cancellable!
-                        _publishingStrategy.PublishingFinalized(uow, shouldBePublished, false);
-                    }
-
-                    Audit(uow, AuditType.Sort, "Sorting content performed by user", userId, 0);
-                    uow.Commit();
-                }
-            }
-
-            return true;
-        }
-
-        /// <summary>
-        /// Sorts a collection of <see cref="IContent"/> objects by updating the SortOrder according
-        /// to the ordering of node Ids passed in.
-        /// </summary>
-        /// <remarks>
-        /// Using this method will ensure that the Published-state is maintained upon sorting
-        /// so the cache is updated accordingly - as needed.
-        /// </remarks>
-        /// <param name="ids"></param>
-        /// <param name="userId"></param>
-        /// <param name="raiseEvents"></param>
-        /// <returns>True if sorting succeeded, otherwise False</returns>
-        public bool Sort(int[] ids, int userId = 0, bool raiseEvents = true)
-        {
-            var shouldBePublished = new List<IContent>();
-            var shouldBeSaved = new List<IContent>();
-
-            using (new WriteLock(Locker))
-            {
-                var allContent = GetByIds(ids).ToDictionary(x => x.Id, x => x);
-                if (allContent.Any() == false)
-                {
-                    return false;
-                }
-                var items = ids.Select(x => allContent[x]).ToArray();
-
-                using (var uow = UowProvider.GetUnitOfWork())
-                {
-                    var saveEventArgs = new SaveEventArgs<IContent>(items);
-                    if (raiseEvents && uow.Events.DispatchCancelable(Saving, this, saveEventArgs, "Saving"))
-                    {
-                        uow.Commit();
-                        return false;
-                    }
-
-                    var repository = RepositoryFactory.CreateContentRepository(uow);
-
-                    var i = 0;
-                    foreach (var content in items)
-                    {
-                        //If the current sort order equals that of the content
-                        //we don't need to update it, so just increment the sort order
-                        //and continue.
-                        if (content.SortOrder == i)
-                        {
-                            i++;
-                            continue;
-                        }
-
-                        content.SortOrder = i;
-                        content.WriterId = userId;
-                        i++;
-
-                        if (content.Published)
-                        {
-                            //TODO: This should not be an inner operation, but if we do this, it cannot raise events and cannot be cancellable!
-                            var published = _publishingStrategy.Publish(uow, content, userId).Success;
-                            shouldBePublished.Add(content);
-                        }
-                        else
-                            shouldBeSaved.Add(content);
-
-                        repository.AddOrUpdate(content);
-                        //add or update a preview
-                        repository.AddOrUpdatePreviewXml(content, c => _entitySerializer.Serialize(this, _dataTypeService, _userService, c));
-                    }
-
-                    foreach (var content in shouldBePublished)
-                    {
-                        //Create and Save ContentXml DTO
-                        repository.AddOrUpdateContentXml(content, c => _entitySerializer.Serialize(this, _dataTypeService, _userService, c));
-                    }
-
-                    if (raiseEvents)
-                    {
-                        saveEventArgs.CanCancel = false;
-                        uow.Events.Dispatch(Saved, this, saveEventArgs, "Saved");
-                    }
-
-                    if (shouldBePublished.Any())
-                    {
-                        //TODO: This should not be an inner operation, but if we do this, it cannot raise events and cannot be cancellable!
-                        _publishingStrategy.PublishingFinalized(uow, shouldBePublished, false);
-                    }
-
-                    Audit(uow, AuditType.Sort, "Sort child items performed by user", userId, items.First().ParentId);
-                    uow.Commit();
-                }
-            }
-
-            return true;
-        }
-
-        public IEnumerable<IContent> GetBlueprintsForContentTypes(params int[] documentTypeIds)
-        {
-            using (var uow = UowProvider.GetUnitOfWork(readOnly: true))
-            {
-                var repository = RepositoryFactory.CreateContentBlueprintRepository(uow);
-
-                var query = new Query<IContent>();
-                if (documentTypeIds.Length > 0)
-                {
-                    query.Where(x => documentTypeIds.Contains(x.ContentTypeId));
-                }
-                return repository.GetByQuery(query).Select(x =>
-                {
-                    ((Content) x).IsBlueprint = true;
-                    return x;
-                });
-            }
-        }
-
-        /// <summary>
-        /// Gets paged content descendants as XML by path
-        /// </summary>
-        /// <param name="path">Path starts with</param>
-        /// <param name="pageIndex">Page number</param>
-        /// <param name="pageSize">Page size</param>
-        /// <param name="totalRecords">Total records the query would return without paging</param>
-        /// <returns>A paged enumerable of XML entries of content items</returns>
-        public IEnumerable<XElement> GetPagedXmlEntries(string path, long pageIndex, int pageSize, out long totalRecords)
-        {
-            Mandate.ParameterCondition(pageIndex >= 0, "pageIndex");
-            Mandate.ParameterCondition(pageSize > 0, "pageSize");
-
-            using (var uow = UowProvider.GetUnitOfWork(readOnly: true))
-            {
-                var repository = RepositoryFactory.CreateContentRepository(uow);
-                var contents = repository.GetPagedXmlEntriesByPath(path, pageIndex, pageSize,
-                    //This order by is VERY important! This allows us to figure out what is implicitly not published, see ContentRepository.BuildXmlCache and
-                    // UmbracoContentIndexer.PerformIndexAll which uses the logic based on this sort order
-                    new[] { "level", "parentID", "sortOrder" },
-                    out totalRecords);
-                return contents;
-            }
-        }
-
-        /// <summary>
-        /// This builds the Xml document used for the XML cache
-        /// </summary>
-        /// <returns></returns>
-        public XmlDocument BuildXmlCache()
-        {
-            using (var uow = UowProvider.GetUnitOfWork())
-            {
-                var repository = RepositoryFactory.CreateContentRepository(uow);
-                var result = repository.BuildXmlCache();
-                uow.Commit();
-                return result;
-            }
-        }
-
-        public XmlDocument BuildPreviewXmlCache()
-        {
-            using (var uow = UowProvider.GetUnitOfWork())
-            {
-                var repository = RepositoryFactory.CreateContentRepository(uow);
-                var result = repository.BuildPreviewXmlCache();
-                uow.Commit();
-                return result;
-            }
-        }
-
-        /// <summary>
-        /// Rebuilds all xml content in the cmsContentXml table for all documents
-        /// </summary>
-        /// <param name="contentTypeIds">
-        /// Only rebuild the xml structures for the content type ids passed in, if none then rebuilds the structures
-        /// for all content
-        /// </param>
-        public void RebuildXmlStructures(params int[] contentTypeIds)
-        {
-            using (var uow = UowProvider.GetUnitOfWork())
-            {
-                var repository = RepositoryFactory.CreateContentRepository(uow);
-
-                repository.RebuildXmlStructures(
-                    content => _entitySerializer.Serialize(this, _dataTypeService, _userService, content),
-                    contentTypeIds: contentTypeIds.Length == 0 ? null : contentTypeIds);
-
-                Audit(uow, AuditType.Publish, "ContentService.RebuildXmlStructures completed, the xml has been regenerated in the database", 0, Constants.System.Root);
-                uow.Commit();
-            }
-        }
-
-        #region Internal Methods
-
-        /// <summary>
-        /// Gets a collection of <see cref="IContent"/> descendants by the first Parent.
-        /// </summary>
-        /// <param name="content"><see cref="IContent"/> item to retrieve Descendants from</param>
-        /// <returns>An Enumerable list of <see cref="IContent"/> objects</returns>
-        internal IEnumerable<IContent> GetPublishedDescendants(IContent content)
-        {
-            using (var uow = UowProvider.GetUnitOfWork(readOnly: true))
-            {
-                var repository = RepositoryFactory.CreateContentRepository(uow);
-
-                var query = Query<IContent>.Builder.Where(x => x.Id != content.Id && x.Path.StartsWith(content.Path) && x.Trashed == false);
-                return repository.GetByPublishedVersion(query);
-            }
-        }
-
-        #endregion
-
-        #region Private Methods
-
-        /// <summary>
-        /// Hack: This is used to fix some data if an entity's properties are invalid/corrupt
-        /// </summary>
-        /// <param name="content"></param>
-        private void QuickUpdate(IContent content)
-        {
-            if (content == null) throw new ArgumentNullException("content");
-            if (content.HasIdentity == false) throw new InvalidOperationException("Cannot update an entity without an Identity");
-
-            using (var uow = UowProvider.GetUnitOfWork())
-            {
-                var repository = RepositoryFactory.CreateContentRepository(uow);
-                repository.AddOrUpdate(content);
-                uow.Commit();
-            }
-        }
-
-        private void Audit(IScopeUnitOfWork uow, AuditType type, string message, int userId, int objectId)
-        {
-            var auditRepo = RepositoryFactory.CreateAuditRepository(uow);
-            auditRepo.AddOrUpdate(new AuditItem(objectId, message, type, userId));
-        }
-
-        //TODO: All of this needs to be moved to the repository
-        private void PerformMove(IContent content, int parentId, int userId, ICollection<MoveEventInfo<IContent>> moveInfo)
-        {
-            //add a tracking item to use in the Moved event
-            moveInfo.Add(new MoveEventInfo<IContent>(content, content.Path, parentId));
-
-            content.WriterId = userId;
-            if (parentId == Constants.System.Root)
-            {
-                content.Path = string.Concat(Constants.System.Root, ",", content.Id);
-                content.Level = 1;
-            }
-            else
-            {
-                var parent = GetById(parentId);
-                content.Path = string.Concat(parent.Path, ",", content.Id);
-                content.Level = parent.Level + 1;
-            }
-
-            //If Content is being moved away from Recycle Bin, its state should be un-trashed
-            if (content.Trashed && parentId != Constants.System.RecycleBinContent)
-            {
-                content.ChangeTrashedState(false, parentId);
-            }
-            else
-            {
-                content.ParentId = parentId;
-            }
-
-            //If Content is published, it should be (re)published from its new location
-            if (content.Published)
-            {
-                //If Content is Publishable its saved and published
-                //otherwise we save the content without changing the publish state, and generate new xml because the Path, Level and Parent has changed.
-                if (IsPublishable(content))
-                {
-                    //TODO: This is raising events, probably not desirable as this costs performance for event listeners like Examine
-                    SaveAndPublish(content, userId);
-                }
-                else
-                {
-                    //TODO: This is raising events, probably not desirable as this costs performance for event listeners like Examine
-                    Save(content, false, userId);
-
-                    //TODO: This shouldn't be here! This needs to be part of the repository logic but in order to fix this we need to
-                    // change how this method calls "Save" as it needs to save using an internal method
-                    using (var uow = UowProvider.GetUnitOfWork())
-                    {
-                        var xml = _entitySerializer.Serialize(this, _dataTypeService, _userService, content);
-
-                        var poco = new ContentXmlDto { NodeId = content.Id, Xml = xml.ToDataString() };
-                        var exists =
-                            uow.Database.FirstOrDefault<ContentXmlDto>("WHERE nodeId = @Id", new { Id = content.Id }) !=
-                            null;
-                        int result = exists
-                                         ? uow.Database.Update(poco)
-                                         : Convert.ToInt32(uow.Database.Insert(poco));
-                        uow.Commit();
-                    }
-                }
-            }
-            else
-            {
-                //TODO: This is raising events, probably not desirable as this costs performance for event listeners like Examine
-                Save(content, userId);
-            }
-
-            //Ensure that Path and Level is updated on children
-            var children = GetChildren(content.Id).ToArray();
-            if (children.Any())
-            {
-                foreach (var child in children)
-                {
-                    PerformMove(child, content.Id, userId, moveInfo);
-                }
-            }
-        }
-
-        /// <summary>
-        /// Publishes a <see cref="IContent"/> object and all its children
-        /// </summary>
-        /// <param name="content">The <see cref="IContent"/> to publish along with its children</param>
-        /// <param name="userId">Optional Id of the User issueing the publishing</param>
-        /// <param name="includeUnpublished">If set to true, this will also publish descendants that are completely unpublished, normally this will only publish children that have previously been published</param>
-        /// <returns>
-        /// A list of publish statues. If the parent document is not valid or cannot be published because it's parent(s) is not published
-        /// then the list will only contain one status item, otherwise it will contain status items for it and all of it's descendants that
-        /// are to be published.
-        /// </returns>
-        private IEnumerable<Attempt<PublishStatus>> PublishWithChildrenDo(
-            IContent content, int userId = 0, bool includeUnpublished = false)
-        {
-            if (content == null) throw new ArgumentNullException("content");
-
-            var evtMsgs = EventMessagesFactory.Get();
-
-            using (new WriteLock(Locker))
-            {
-                //Hack: this ensures that the entity's path is valid and if not it fixes/persists it
-                //see: http://issues.umbraco.org/issue/U4-9336
-                content.EnsureValidPath(Logger, entity => GetById(entity.ParentId), QuickUpdate);
-
-                var result = new List<Attempt<PublishStatus>>();
-
-                //Check if parent is published (although not if its a root node) - if parent isn't published this Content cannot be published
-                if (content.ParentId != Constants.System.Root && content.ParentId != Constants.System.RecycleBinContent && IsPublishable(content) == false)
-                {
-                    Logger.Info<ContentService>(
-                        string.Format(
-                            "Content '{0}' with Id '{1}' could not be published because its parent or one of its ancestors is not published.",
-                            content.Name, content.Id));
-                    result.Add(Attempt.Fail(new PublishStatus(content, PublishStatusType.FailedPathNotPublished, evtMsgs)));
-                    return result;
-                }
-
-                //Content contains invalid property values and can therefore not be published - fire event?
-                if (!content.IsValid())
-                {
-                    Logger.Info<ContentService>(
-                        string.Format("Content '{0}' with Id '{1}' could not be published because of invalid properties.",
-                                      content.Name, content.Id));
-                    result.Add(
-                        Attempt.Fail(
-                            new PublishStatus(content, PublishStatusType.FailedContentInvalid, evtMsgs)
-                            {
-                                InvalidProperties = ((ContentBase)content).LastInvalidProperties
-                            }));
-                    return result;
-                }
-
-                //Consider creating a Path query instead of recursive method:
-                //var query = Query<IContent>.Builder.Where(x => x.Path.StartsWith(content.Path));
-
-                var updated = new List<IContent>();
-                var list = new List<IContent>();
-                list.Add(content); //include parent item
-                list.AddRange(GetDescendants(content));
-
-                var internalStrategy = _publishingStrategy;
-
-                using (var uow = UowProvider.GetUnitOfWork())
-                {
-                    //Publish and then update the database with new status
-                    var publishedOutcome = internalStrategy.PublishWithChildren(uow, list, userId, includeUnpublished).ToArray();
-                    var published = publishedOutcome
-                        .Where(x => x.Success || x.Result.StatusType == PublishStatusType.SuccessAlreadyPublished)
-                        // ensure proper order (for events) - cannot publish a child before its parent!
-                        .OrderBy(x => x.Result.ContentItem.Level)
-                        .ThenBy(x => x.Result.ContentItem.SortOrder);
-
-                    var repository = RepositoryFactory.CreateContentRepository(uow);
-
-                    //NOTE The Publish with subpages-dialog was used more as a republish-type-thing, so we'll have to include PublishStatusType.SuccessAlreadyPublished
-                    //in the updated-list, so the Published event is triggered with the expected set of pages and the xml is updated.
-                    foreach (var item in published)
-                    {
-                        item.Result.ContentItem.WriterId = userId;
-                        repository.AddOrUpdate(item.Result.ContentItem);
-                        //add or update a preview
-                        repository.AddOrUpdatePreviewXml(item.Result.ContentItem, c => _entitySerializer.Serialize(this, _dataTypeService, _userService, c));
-                        //add or update the published xml
-                        repository.AddOrUpdateContentXml(item.Result.ContentItem, c => _entitySerializer.Serialize(this, _dataTypeService, _userService, c));
-                        updated.Add(item.Result.ContentItem);
-                    }
-
-                    //Save xml to db and call following method to fire event:
-                    _publishingStrategy.PublishingFinalized(uow, updated, false);
-
-                    Audit(uow, AuditType.Publish, "Publish with Children performed by user", userId, content.Id);
-                    uow.Commit();
-
-                    return publishedOutcome;
-                }
-            }
-        }
-
-        /// <summary>
-        /// UnPublishes a single <see cref="IContent"/> object
-        /// </summary>
-        /// <param name="content">The <see cref="IContent"/> to publish</param>
-        /// <param name="omitCacheRefresh">Optional boolean to avoid having the cache refreshed when calling this Unpublish method. By default this method will update the cache.</param>
-        /// <param name="userId">Optional Id of the User issueing the publishing</param>
-        /// <returns>True if unpublishing succeeded, otherwise False</returns>
-        private Attempt<UnPublishStatus> UnPublishDo(IContent content, bool omitCacheRefresh = false, int userId = 0)
-        {
-            var newest = GetById(content.Id); // ensure we have the newest version
-            if (content.Version != newest.Version) // but use the original object if it's already the newest version
-                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
-            }
-
-            using (var uow = UowProvider.GetUnitOfWork())
-            {
-                var unpublished = _publishingStrategy.UnPublish(uow, content, userId);
-                if (unpublished == false)
-                {
-                    uow.Commit();
-                    return Attempt.Fail(new UnPublishStatus(content, UnPublishedStatusType.FailedCancelledByEvent, evtMsgs));
-                }
-
-                var repository = RepositoryFactory.CreateContentRepository(uow);
-
-                content.WriterId = userId;
-                repository.AddOrUpdate(content);
-                // is published is not newest, reset the published flag on published version
-                if (published.Version != content.Version)
-                    repository.ClearPublished(published);
-                repository.DeleteContentXml(content);
-
-                //Delete xml from db? and call following method to fire event through PublishingStrategy to update cache
-                if (omitCacheRefresh == false)
-                    _publishingStrategy.UnPublishingFinalized(uow, content);
-
-                Audit(uow, AuditType.UnPublish, "UnPublish performed by user", userId, content.Id);
-                uow.Commit();
-            }
-
-            return Attempt.Succeed(new UnPublishStatus(content, UnPublishedStatusType.Success, evtMsgs));
-        }
-
-        /// <summary>
-        /// Saves and Publishes a single <see cref="IContent"/> object
-        /// </summary>
-        /// <param name="content">The <see cref="IContent"/> to save and publish</param>
-        /// <param name="userId">Optional Id of the User issueing the publishing</param>
-        /// <param name="raiseEvents">Optional boolean indicating whether or not to raise save events.</param>
-        /// <returns>True if publishing succeeded, otherwise False</returns>
-        private Attempt<PublishStatus> SaveAndPublishDo(IContent content, int userId = 0, bool raiseEvents = true)
-        {
-            var evtMsgs = EventMessagesFactory.Get();
-
-            using (new WriteLock(Locker))
-            {
-                using (var uow = UowProvider.GetUnitOfWork())
-                {
-                    var saveEventArgs = new SaveEventArgs<IContent>(content, evtMsgs);
-                    if (raiseEvents && uow.Events.DispatchCancelable(Saving, this, saveEventArgs, "Saving"))
-                    {
-                        uow.Commit();
-                        return Attempt.Fail(new PublishStatus(content, PublishStatusType.FailedCancelledByEvent, evtMsgs));
-                    }
-
-                    //Has this content item previously been published? If so, we don't need to refresh the children
-                    var previouslyPublished = content.HasIdentity && HasPublishedVersion(content.Id); //content might not have an id
-                    var publishStatus = new PublishStatus(content, PublishStatusType.Success, evtMsgs); //initially set to success
-
-                    //Check if parent is published (although not if its a root node) - if parent isn't published this Content cannot be published
-                    publishStatus.StatusType = CheckAndLogIsPublishable(content);
-                    //if it is not successful, then check if the props are valid
-                    if ((int)publishStatus.StatusType < 10)
-                    {
-                        //Content contains invalid property values and can therefore not be published - fire event?
-                        publishStatus.StatusType = CheckAndLogIsValid(content);
-                        //set the invalid properties (if there are any)
-                        publishStatus.InvalidProperties = ((ContentBase)content).LastInvalidProperties;
-                    }
-                    //if we're still successful, then publish using the strategy
-                    if (publishStatus.StatusType == PublishStatusType.Success)
-                    {
-                        //Publish and then update the database with new status
-                        var publishResult = _publishingStrategy.Publish(uow, content, userId);
-                        //set the status type to the publish result
-                        publishStatus.StatusType = publishResult.Result.StatusType;
-                    }
-
-                    //we are successfully published if our publishStatus is still Successful
-                    bool published = publishStatus.StatusType == PublishStatusType.Success;
-
-                    var repository = RepositoryFactory.CreateContentRepository(uow);
-
-                    if (published == false)
-                    {
-                        content.ChangePublishedState(PublishedState.Saved);
-                    }
-                    //Since this is the Save and Publish method, the content should be saved even though the publish fails or isn't allowed
-                    if (content.HasIdentity == false)
-                    {
-                        content.CreatorId = userId;
-                    }
-                    content.WriterId = userId;
-
-                    repository.AddOrUpdate(content);
-                    repository.AddOrUpdatePreviewXml(content, c => _entitySerializer.Serialize(this, _dataTypeService, _userService, c));
-
-                    if (published)
-                    {
-                        //Content Xml
-                        repository.AddOrUpdateContentXml(content, c => _entitySerializer.Serialize(this, _dataTypeService, _userService, c));
-                    }
-
-                    if (raiseEvents)
-                    {
-                        saveEventArgs.CanCancel = false;
-                        uow.Events.Dispatch(Saved, this, saveEventArgs, "Saved");
-                    }
-
-                    //Save xml to db and call following method to fire event through PublishingStrategy to update cache
-                    if (published)
-                    {
-                        _publishingStrategy.PublishingFinalized(uow, content);
-                    }
-
-                    //We need to check if children and their publish state to ensure that we 'republish' content that was previously published
-                    if (published && previouslyPublished == false && HasChildren(content.Id))
-                    {
-                    //TODO: Horrible for performance if there are lots of descendents! We should page if anything but this is crazy
-                        var descendants = GetPublishedDescendants(content);
-                        _publishingStrategy.PublishingFinalized(uow, descendants, false);
-                    }
-
-                    uow.Commit();
-
-                    if (publishStatus.StatusType == PublishStatusType.Success)
-                    {
-                        Audit(uow, AuditType.Publish, "Save and Publish performed by user", userId, content.Id);
-                    }
-                    else
-                    {
-                        Audit(uow, AuditType.Save, "Save performed by user", userId, content.Id);
-                    }
-                    uow.Commit();
-
-                    return Attempt.If(publishStatus.StatusType == PublishStatusType.Success, publishStatus);
-                }
-            }
-        }
-
-        /// <summary>
-        /// Saves a single <see cref="IContent"/> object
-        /// </summary>
-        /// <param name="content">The <see cref="IContent"/> to save</param>
-        /// <param name="changeState">Boolean indicating whether or not to change the Published state upon saving</param>
-        /// <param name="userId">Optional Id of the User saving the Content</param>
-        /// <param name="raiseEvents">Optional boolean indicating whether or not to raise events.</param>
-        private Attempt<OperationStatus> Save(IContent content, bool changeState, int userId = 0, bool raiseEvents = true)
-        {
-            var evtMsgs = EventMessagesFactory.Get();
-
-            using (new WriteLock(Locker))
-            {
-                using (var uow = UowProvider.GetUnitOfWork())
-                {
-                    var saveEventArgs = new SaveEventArgs<IContent>(content, evtMsgs);
-                    if (raiseEvents && uow.Events.DispatchCancelable(Saving, this, saveEventArgs, "Saving"))
-                    {
-                        uow.Commit();
-                        return OperationStatus.Cancelled(evtMsgs);
-                    }
-
-                    if (string.IsNullOrWhiteSpace(content.Name))
-                    {
-                        throw new ArgumentException("Cannot save content with empty name.");
-                    }
-
-                    var repository = RepositoryFactory.CreateContentRepository(uow);
-
-                    if (content.HasIdentity == false)
-                    {
-                        content.CreatorId = userId;
-                    }
-                    content.WriterId = userId;
-
-                    //Only change the publish state if the "previous" version was actually published or marked as unpublished
-                    if (changeState && (content.Published || ((Content)content).PublishedState == PublishedState.Unpublished))
-                        content.ChangePublishedState(PublishedState.Saved);
-
-                    repository.AddOrUpdate(content);
-
-                    //Generate a new preview
-                    repository.AddOrUpdatePreviewXml(content, c => _entitySerializer.Serialize(this, _dataTypeService, _userService, c));
-
-                    if (raiseEvents)
-                    {
-                        saveEventArgs.CanCancel = false;
-                        uow.Events.Dispatch(Saved, this, saveEventArgs, "Saved");
-                    }
-
-                    Audit(uow, AuditType.Save, "Save Content performed by user", userId, content.Id);
-                    uow.Commit();
-                }
-
-                return OperationStatus.Success(evtMsgs);
-            }
-        }
-
-        private PublishStatusType CheckAndLogIsPublishable(IContent content)
-        {
-            //Check if parent is published (although not if its a root node) - if parent isn't published this Content cannot be published
-            if (content.ParentId != Constants.System.Root && content.ParentId != Constants.System.RecycleBinContent && IsPublishable(content) == false)
-            {
-                Logger.Info<ContentService>(
-                    string.Format(
-                        "Content '{0}' with Id '{1}' could not be published because its parent is not published.",
-                        content.Name, content.Id));
-                return PublishStatusType.FailedPathNotPublished;
-            }
-
-            if (content.ExpireDate.HasValue && content.ExpireDate.Value > DateTime.MinValue && DateTime.Now > content.ExpireDate.Value)
-            {
-                Logger.Info<ContentService>(
-                    string.Format(
-                        "Content '{0}' with Id '{1}' has expired and could not be published.",
-                        content.Name, content.Id));
-                return PublishStatusType.FailedHasExpired;
-            }
-
-            if (content.ReleaseDate.HasValue && content.ReleaseDate.Value > DateTime.MinValue && content.ReleaseDate.Value > DateTime.Now)
-            {
-                Logger.Info<ContentService>(
-                    string.Format(
-                        "Content '{0}' with Id '{1}' is awaiting release and could not be published.",
-                        content.Name, content.Id));
-                return PublishStatusType.FailedAwaitingRelease;
-            }
-
-            return PublishStatusType.Success;
-        }
-
-        private PublishStatusType CheckAndLogIsValid(IContent content)
-        {
-            //Content contains invalid property values and can therefore not be published - fire event?
-            if (content.IsValid() == false)
-            {
-                Logger.Info<ContentService>(
-                    string.Format(
-                        "Content '{0}' with Id '{1}' could not be published because of invalid properties.",
-                        content.Name, content.Id));
-                return PublishStatusType.FailedContentInvalid;
-            }
-
-            return PublishStatusType.Success;
-        }
-
-        private IContentType FindContentTypeByAlias(string contentTypeAlias)
-        {
-            using (var uow = UowProvider.GetUnitOfWork(readOnly: true))
-            {
-                var repository = RepositoryFactory.CreateContentTypeRepository(uow);
-
-                var query = Query<IContentType>.Builder.Where(x => x.Alias == contentTypeAlias);
-                var types = repository.GetByQuery(query);
-
-                if (types.Any() == false)
-                    throw new Exception(
-                        string.Format("No ContentType matching the passed in Alias: '{0}' was found",
-                                      contentTypeAlias));
-
-                var contentType = types.First();
-
-                if (contentType == null)
-                    throw new Exception(string.Format("ContentType matching the passed in Alias: '{0}' was null",
-                                                      contentTypeAlias));
-                return contentType;
-            }
-        }
-
-        #endregion
-
-        #region Proxy Event Handlers
-        /// <summary>
-        /// Occurs before publish.
-        /// </summary>
-        /// <remarks>Proxy to the real event on the <see cref="PublishingStrategy"/></remarks>
-        public static event TypedEventHandler<IPublishingStrategy, PublishEventArgs<IContent>> Publishing
-        {
-            add { PublishingStrategy.Publishing += value; }
-            remove { PublishingStrategy.Publishing -= value; }
-        }
-
-        /// <summary>
-        /// Occurs after publish.
-        /// </summary>
-        /// <remarks>Proxy to the real event on the <see cref="PublishingStrategy"/></remarks>
-        public static event TypedEventHandler<IPublishingStrategy, PublishEventArgs<IContent>> Published
-        {
-            add { PublishingStrategy.Published += value; }
-            remove { PublishingStrategy.Published -= value; }
-        }
-        /// <summary>
-        /// Occurs before unpublish.
-        /// </summary>
-        /// <remarks>Proxy to the real event on the <see cref="PublishingStrategy"/></remarks>
-        public static event TypedEventHandler<IPublishingStrategy, PublishEventArgs<IContent>> UnPublishing
-        {
-            add { PublishingStrategy.UnPublishing += value; }
-            remove { PublishingStrategy.UnPublishing -= value; }
-        }
-
-        /// <summary>
-        /// Occurs after unpublish.
-        /// </summary>
-        /// <remarks>Proxy to the real event on the <see cref="PublishingStrategy"/></remarks>
-        public static event TypedEventHandler<IPublishingStrategy, PublishEventArgs<IContent>> UnPublished
-        {
-            add { PublishingStrategy.UnPublished += value; }
-            remove { PublishingStrategy.UnPublished -= value; }
-        }
-        #endregion
-
-        #region Event Handlers
-        /// <summary>
-        /// Occurs before Delete
-        /// </summary>
-        public static event TypedEventHandler<IContentService, DeleteEventArgs<IContent>> Deleting;
-
-        /// <summary>
-        /// Occurs after Delete
-        /// </summary>
-        public static event TypedEventHandler<IContentService, DeleteEventArgs<IContent>> Deleted;
-
-        /// <summary>
-        /// Occurs before Delete Versions
-        /// </summary>
-        public static event TypedEventHandler<IContentService, DeleteRevisionsEventArgs> DeletingVersions;
-
-        /// <summary>
-        /// Occurs after Delete Versions
-        /// </summary>
-        public static event TypedEventHandler<IContentService, DeleteRevisionsEventArgs> DeletedVersions;
-
-        /// <summary>
-        /// Occurs before Save
-        /// </summary>
-        public static event TypedEventHandler<IContentService, SaveEventArgs<IContent>> Saving;
-
-        /// <summary>
-        /// Occurs after Save
-        /// </summary>
-        public static event TypedEventHandler<IContentService, SaveEventArgs<IContent>> Saved;
-
-        /// <summary>
-        /// Occurs before Create
-        /// </summary>
-        [Obsolete("Use the Created event instead, the Creating and Created events both offer the same functionality, Creating event has been deprecated.")]
-        public static event TypedEventHandler<IContentService, NewEventArgs<IContent>> Creating;
-
-        /// <summary>
-        /// Occurs after Create
-        /// </summary>
-        /// <remarks>
-        /// Please note that the Content object has been created, but might not have been saved
-        /// so it does not have an identity yet (meaning no Id has been set).
-        /// </remarks>
-        public static event TypedEventHandler<IContentService, NewEventArgs<IContent>> Created;
-
-        /// <summary>
-        /// Occurs before Copy
-        /// </summary>
-        public static event TypedEventHandler<IContentService, CopyEventArgs<IContent>> Copying;
-
-        /// <summary>
-        /// Occurs after Copy
-        /// </summary>
-        public static event TypedEventHandler<IContentService, CopyEventArgs<IContent>> Copied;
-
-        /// <summary>
-        /// Occurs before Content is moved to Recycle Bin
-        /// </summary>
-        public static event TypedEventHandler<IContentService, MoveEventArgs<IContent>> Trashing;
-
-        /// <summary>
-        /// Occurs after Content is moved to Recycle Bin
-        /// </summary>
-        public static event TypedEventHandler<IContentService, MoveEventArgs<IContent>> Trashed;
-
-        /// <summary>
-        /// Occurs before Move
-        /// </summary>
-        public static event TypedEventHandler<IContentService, MoveEventArgs<IContent>> Moving;
-
-        /// <summary>
-        /// Occurs after Move
-        /// </summary>
-        public static event TypedEventHandler<IContentService, MoveEventArgs<IContent>> Moved;
-
-        /// <summary>
-        /// Occurs before Rollback
-        /// </summary>
-        public static event TypedEventHandler<IContentService, RollbackEventArgs<IContent>> RollingBack;
-
-        /// <summary>
-        /// Occurs after Rollback
-        /// </summary>
-        public static event TypedEventHandler<IContentService, RollbackEventArgs<IContent>> RolledBack;
-
-        /// <summary>
-        /// Occurs before Send to Publish
-        /// </summary>
-        public static event TypedEventHandler<IContentService, SendToPublishEventArgs<IContent>> SendingToPublish;
-
-        /// <summary>
-        /// Occurs after Send to Publish
-        /// </summary>
-        public static event TypedEventHandler<IContentService, SendToPublishEventArgs<IContent>> SentToPublish;
-
-        /// <summary>
-        /// Occurs before the Recycle Bin is emptied
-        /// </summary>
-        public static event TypedEventHandler<IContentService, RecycleBinEventArgs> EmptyingRecycleBin;
-
-        /// <summary>
-        /// Occurs after the Recycle Bin has been Emptied
-        /// </summary>
-        public static event TypedEventHandler<IContentService, RecycleBinEventArgs> EmptiedRecycleBin;
-
-        /// <summary>
-        /// Occurs after a blueprint has been saved.
-        /// </summary>
-        public static event TypedEventHandler<IContentService, SaveEventArgs<IContent>> SavedBlueprint;
-
-        /// <summary>
-        /// Occurs after a blueprint has been deleted.
-        /// </summary>
-        public static event TypedEventHandler<IContentService, DeleteEventArgs<IContent>> DeletedBlueprint;
-
-        #endregion
-    }
-}
+using System;
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.Globalization;
+using System.IO;
+using System.Linq;
+using System.Text.RegularExpressions;
+using System.Threading;
+using System.Xml;
+using System.Xml.Linq;
+using Umbraco.Core.Events;
+using Umbraco.Core.Logging;
+using Umbraco.Core.Models;
+using Umbraco.Core.Models.Membership;
+using Umbraco.Core.Models.Rdbms;
+using Umbraco.Core.Persistence;
+using Umbraco.Core.Persistence.DatabaseModelDefinitions;
+using Umbraco.Core.Persistence.Querying;
+using Umbraco.Core.Persistence.Repositories;
+using Umbraco.Core.Persistence.UnitOfWork;
+using Umbraco.Core.Publishing;
+
+namespace Umbraco.Core.Services
+{
+    /// <summary>
+    /// Represents the Content Service, which is an easy access to operations involving <see cref="IContent"/>
+    /// </summary>
+    public class ContentService : ScopeRepositoryService, IContentService, IContentServiceOperations
+    {
+        private readonly IPublishingStrategy2 _publishingStrategy;
+        private readonly EntityXmlSerializer _entitySerializer = new EntityXmlSerializer();
+        private readonly IDataTypeService _dataTypeService;
+        private readonly IUserService _userService;
+
+        //Support recursive locks because some of the methods that require locking call other methods that require locking.
+        //for example, the Move method needs to be locked but this calls the Save method which also needs to be locked.
+        private static readonly ReaderWriterLockSlim Locker = new ReaderWriterLockSlim(LockRecursionPolicy.SupportsRecursion);
+        private static readonly Regex AnchorRegex = new Regex("<a id=\"(.*?)\">", RegexOptions.Compiled);
+
+        public ContentService(
+            IDatabaseUnitOfWorkProvider provider,
+            RepositoryFactory repositoryFactory,
+            ILogger logger,
+            IEventMessagesFactory eventMessagesFactory,
+            IDataTypeService dataTypeService,
+            IUserService userService)
+            : base(provider, repositoryFactory, logger, eventMessagesFactory)
+        {
+            if (dataTypeService == null) throw new ArgumentNullException("dataTypeService");
+            if (userService == null) throw new ArgumentNullException("userService");
+            _publishingStrategy = new PublishingStrategy(UowProvider.ScopeProvider, eventMessagesFactory, logger);
+            _dataTypeService = dataTypeService;
+            _userService = userService;
+        }
+
+        #region Static Queries
+
+        private IQuery<IContent> _notTrashedQuery;
+
+        #endregion
+
+        public int CountPublished(string contentTypeAlias = null)
+        {
+            using (var uow = UowProvider.GetUnitOfWork(readOnly: true))
+            {
+                var repository = RepositoryFactory.CreateContentRepository(uow);
+                return repository.CountPublished(contentTypeAlias);
+            }
+        }
+
+        public int Count(string contentTypeAlias = null)
+        {
+            using (var uow = UowProvider.GetUnitOfWork(readOnly: true))
+            {
+                var repository = RepositoryFactory.CreateContentRepository(uow);
+                return repository.Count(contentTypeAlias);
+            }
+        }
+
+        public int CountChildren(int parentId, string contentTypeAlias = null)
+        {
+            using (var uow = UowProvider.GetUnitOfWork(readOnly: true))
+            {
+                var repository = RepositoryFactory.CreateContentRepository(uow);
+                return repository.CountChildren(parentId, contentTypeAlias);
+            }
+        }
+
+        public int CountDescendants(int parentId, string contentTypeAlias = null)
+        {
+            using (var uow = UowProvider.GetUnitOfWork(readOnly: true))
+            {
+                var repository = RepositoryFactory.CreateContentRepository(uow);
+                return repository.CountDescendants(parentId, contentTypeAlias);
+            }
+        }
+
+        /// <summary>
+        /// Used to bulk update the permissions set for a content item. This will replace all permissions
+        /// assigned to an entity with a list of user id & permission pairs.
+        /// </summary>
+        /// <param name="permissionSet"></param>
+        public void ReplaceContentPermissions(EntityPermissionSet permissionSet)
+        {
+            using (var uow = UowProvider.GetUnitOfWork())
+            {
+                var repository = RepositoryFactory.CreateContentRepository(uow);
+                repository.ReplaceContentPermissions(permissionSet);
+                uow.Commit();
+            }
+        }
+
+        /// <summary>
+        /// Assigns a single permission to the current content item for the specified group ids
+        /// </summary>
+        /// <param name="entity"></param>
+        /// <param name="permission"></param>
+        /// <param name="groupIds"></param>
+        public void AssignContentPermission(IContent entity, char permission, IEnumerable<int> groupIds)
+        {
+            using (var uow = UowProvider.GetUnitOfWork())
+            {
+                var repository = RepositoryFactory.CreateContentRepository(uow);
+                repository.AssignEntityPermission(entity, permission, groupIds);
+                uow.Commit();
+            }
+        }
+
+        /// <summary>
+        /// Returns implicit/inherited permissions assigned to the content item for all user groups
+        /// </summary>
+        /// <param name="content"></param>
+        /// <returns></returns>
+        public EntityPermissionCollection GetPermissionsForEntity(IContent content)
+        {
+            using (var uow = UowProvider.GetUnitOfWork(readOnly: true))
+            {
+                var repository = RepositoryFactory.CreateContentRepository(uow);
+                return repository.GetPermissionsForEntity(content.Id);
+            }
+        }
+
+        /// <summary>
+        /// Creates an <see cref="IContent"/> object using the alias of the <see cref="IContentType"/>
+        /// that this Content should based on.
+        /// </summary>
+        /// <remarks>
+        /// Note that using this method will simply return a new IContent without any identity
+        /// as it has not yet been persisted. It is intended as a shortcut to creating new content objects
+        /// that does not invoke a save operation against the database.
+        /// </remarks>
+        /// <param name="name">Name of the Content object</param>
+        /// <param name="parentId">Id of Parent for the new Content</param>
+        /// <param name="contentTypeAlias">Alias of the <see cref="IContentType"/></param>
+        /// <param name="userId">Optional id of the user creating the content</param>
+        /// <returns><see cref="IContent"/></returns>
+        public IContent CreateContent(string name, Guid parentId, string contentTypeAlias, int userId = 0)
+        {
+            var parent = GetById(parentId);
+            return CreateContent(name, parent, contentTypeAlias, userId);
+        }
+
+        /// <summary>
+        /// Creates an <see cref="IContent"/> object using the alias of the <see cref="IContentType"/>
+        /// that this Content should based on.
+        /// </summary>
+        /// <remarks>
+        /// Note that using this method will simply return a new IContent without any identity
+        /// as it has not yet been persisted. It is intended as a shortcut to creating new content objects
+        /// that does not invoke a save operation against the database.
+        /// </remarks>
+        /// <param name="name">Name of the Content object</param>
+        /// <param name="parentId">Id of Parent for the new Content</param>
+        /// <param name="contentTypeAlias">Alias of the <see cref="IContentType"/></param>
+        /// <param name="userId">Optional id of the user creating the content</param>
+        /// <returns><see cref="IContent"/></returns>
+        public IContent CreateContent(string name, int parentId, string contentTypeAlias, int userId = 0)
+        {
+            var contentType = FindContentTypeByAlias(contentTypeAlias);
+            var content = new Content(name, parentId, contentType);
+            var parent = GetById(content.ParentId);
+            content.Path = string.Concat(parent.IfNotNull(x => x.Path, content.ParentId.ToString()), ",", content.Id);
+
+            using (var uow = UowProvider.GetUnitOfWork())
+            {
+                var newEventArgs = new NewEventArgs<IContent>(content, contentTypeAlias, parentId);
+                if (uow.Events.DispatchCancelable(Creating, this, newEventArgs))
+                {
+                    uow.Commit();
+                    content.WasCancelled = true;
+                    return content;
+                }
+
+                content.CreatorId = userId;
+                content.WriterId = userId;
+                newEventArgs.CanCancel = false;
+                uow.Events.Dispatch(Created, this, newEventArgs);
+
+                uow.Commit();
+            }
+
+            return content;
+        }
+
+        /// <summary>
+        /// Creates an <see cref="IContent"/> object using the alias of the <see cref="IContentType"/>
+        /// that this Content should based on.
+        /// </summary>
+        /// <remarks>
+        /// Note that using this method will simply return a new IContent without any identity
+        /// as it has not yet been persisted. It is intended as a shortcut to creating new content objects
+        /// that does not invoke a save operation against the database.
+        /// </remarks>
+        /// <param name="name">Name of the Content object</param>
+        /// <param name="parent">Parent <see cref="IContent"/> object for the new Content</param>
+        /// <param name="contentTypeAlias">Alias of the <see cref="IContentType"/></param>
+        /// <param name="userId">Optional id of the user creating the content</param>
+        /// <returns><see cref="IContent"/></returns>
+        public IContent CreateContent(string name, IContent parent, string contentTypeAlias, int userId = 0)
+        {
+            if (parent == null) throw new ArgumentNullException("parent");
+
+            var contentType = FindContentTypeByAlias(contentTypeAlias);
+            var content = new Content(name, parent, contentType);
+            content.Path = string.Concat(parent.Path, ",", content.Id);
+
+            using (var uow = UowProvider.GetUnitOfWork())
+            {
+                var newEventArgs = new NewEventArgs<IContent>(content, contentTypeAlias, parent);
+                if (uow.Events.DispatchCancelable(Creating, this, newEventArgs))
+                {
+                    uow.Commit();
+                    content.WasCancelled = true;
+                    return content;
+                }
+
+                content.CreatorId = userId;
+                content.WriterId = userId;
+                newEventArgs.CanCancel = false;
+                uow.Events.Dispatch(Created, this, newEventArgs);
+
+                uow.Commit();
+            }
+
+            return content;
+        }
+
+        /// <summary>
+        /// Creates and saves an <see cref="IContent"/> object using the alias of the <see cref="IContentType"/>
+        /// that this Content should based on.
+        /// </summary>
+        /// <remarks>
+        /// This method returns an <see cref="IContent"/> object that has been persisted to the database
+        /// and therefor has an identity.
+        /// </remarks>
+        /// <param name="name">Name of the Content object</param>
+        /// <param name="parentId">Id of Parent for the new Content</param>
+        /// <param name="contentTypeAlias">Alias of the <see cref="IContentType"/></param>
+        /// <param name="userId">Optional id of the user creating the content</param>
+        /// <returns><see cref="IContent"/></returns>
+        public IContent CreateContentWithIdentity(string name, int parentId, string contentTypeAlias, int userId = 0)
+        {
+            var contentType = FindContentTypeByAlias(contentTypeAlias);
+            var content = new Content(name, parentId, contentType);
+
+            using (var uow = UowProvider.GetUnitOfWork())
+            {
+                //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.
+                var newEventArgs = new NewEventArgs<IContent>(content, contentTypeAlias, parentId);
+                if (uow.Events.DispatchCancelable(Creating, this, newEventArgs))
+                {
+                    uow.Commit();
+                    content.WasCancelled = true;
+                    return content;
+                }
+
+                var saveEventArgs = new SaveEventArgs<IContent>(content);
+                if (uow.Events.DispatchCancelable(Saving, this, saveEventArgs, "Saving"))
+                {
+                    uow.Commit();
+                    content.WasCancelled = true;
+                    return content;
+                }
+
+                var repository = RepositoryFactory.CreateContentRepository(uow);
+                content.CreatorId = userId;
+                content.WriterId = userId;
+
+                repository.AddOrUpdate(content);
+                repository.AddOrUpdatePreviewXml(content, c => _entitySerializer.Serialize(this, _dataTypeService, _userService, c));
+                saveEventArgs.CanCancel = false;
+                uow.Events.Dispatch(Saved, this, saveEventArgs, "Saved");
+                newEventArgs.CanCancel = false;
+                uow.Events.Dispatch(Created, this, newEventArgs);
+
+                Audit(uow, AuditType.New, string.Format("Content '{0}' was created with Id {1}", name, content.Id), content.CreatorId, content.Id);
+                uow.Commit();
+            }
+
+            return content;
+        }
+
+        public IEnumerable<string> GetAnchorValuesFromRTEs(int id)
+        {
+            var result = new List<string>();
+
+            var content = GetById(id);
+
+            foreach (var contentProperty in content.Properties)
+            {
+                if (contentProperty.PropertyType.PropertyEditorAlias.InvariantEquals(Constants.PropertyEditors.TinyMCEAlias))
+                {
+                    var value = contentProperty.Value?.ToString();
+
+                    if (!string.IsNullOrEmpty(value))
+                    {
+                        result.AddRange(GetAnchorValuesFromRTEContent(value));
+                    }
+
+                }
+            }
+
+
+            return result;
+        }
+
+
+        public IEnumerable<string> GetAnchorValuesFromRTEContent(string rteContent)
+        {
+            var result = new List<string>();
+
+            var matches = AnchorRegex.Matches(rteContent);
+
+            foreach (Match match in matches)
+            {
+                result.Add(match.Value.Split('\"')[1]);
+            }
+
+            return result;
+        }
+
+        /// <summary>
+        /// Creates and saves an <see cref="IContent"/> object using the alias of the <see cref="IContentType"/>
+        /// that this Content should based on.
+        /// </summary>
+        /// <remarks>
+        /// This method returns an <see cref="IContent"/> object that has been persisted to the database
+        /// and therefor has an identity.
+        /// </remarks>
+        /// <param name="name">Name of the Content object</param>
+        /// <param name="parent">Parent <see cref="IContent"/> object for the new Content</param>
+        /// <param name="contentTypeAlias">Alias of the <see cref="IContentType"/></param>
+        /// <param name="userId">Optional id of the user creating the content</param>
+        /// <returns><see cref="IContent"/></returns>
+        public IContent CreateContentWithIdentity(string name, IContent parent, string contentTypeAlias, int userId = 0)
+        {
+            if (parent == null) throw new ArgumentNullException("parent");
+
+            var contentType = FindContentTypeByAlias(contentTypeAlias);
+            var content = new Content(name, parent, contentType);
+
+            using (var uow = UowProvider.GetUnitOfWork())
+            {
+                //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.
+                var newEventArgs = new NewEventArgs<IContent>(content, contentTypeAlias, parent);
+                if (uow.Events.DispatchCancelable(Creating, this, newEventArgs))
+                {
+                    uow.Commit();
+                    content.WasCancelled = true;
+                    return content;
+                }
+
+                var saveEventArgs = new SaveEventArgs<IContent>(content);
+                if (uow.Events.DispatchCancelable(Saving, this, saveEventArgs, "Saving"))
+                {
+                    uow.Commit();
+                    content.WasCancelled = true;
+                    return content;
+                }
+
+                var repository = RepositoryFactory.CreateContentRepository(uow);
+                content.CreatorId = userId;
+                content.WriterId = userId;
+
+                repository.AddOrUpdate(content);
+                repository.AddOrUpdatePreviewXml(content, c => _entitySerializer.Serialize(this, _dataTypeService, _userService, c));
+                saveEventArgs.CanCancel = false;
+                uow.Events.Dispatch(Saved, this, saveEventArgs, "Saved");
+                newEventArgs.CanCancel = false;
+                uow.Events.Dispatch(Created, this, newEventArgs);
+
+                Audit(uow, AuditType.New, string.Format("Content '{0}' was created with Id {1}", name, content.Id), content.CreatorId, content.Id);
+                uow.Commit();
+            }
+
+            return content;
+        }
+
+        /// <summary>
+        /// Gets an <see cref="IContent"/> object by Id
+        /// </summary>
+        /// <param name="id">Id of the Content to retrieve</param>
+        /// <returns><see cref="IContent"/></returns>
+        public IContent GetById(int id)
+        {
+            using (var uow = UowProvider.GetUnitOfWork(readOnly: true))
+            {
+                var repository = RepositoryFactory.CreateContentRepository(uow);
+                return repository.Get(id);
+            }
+        }
+
+        /// <summary>
+        /// Gets <see cref="IContent"/> objects by Ids
+        /// </summary>
+        /// <param name="ids">Ids of the Content to retrieve</param>
+        /// <returns><see cref="IContent"/></returns>
+        public IEnumerable<IContent> GetByIds(IEnumerable<int> ids)
+        {
+            var idsArray = ids.ToArray();
+            if (idsArray.Length == 0) return Enumerable.Empty<IContent>();
+
+            using (var uow = UowProvider.GetUnitOfWork(readOnly: true))
+            {
+                var repository = RepositoryFactory.CreateContentRepository(uow);
+
+                // ensure that the result has the order based on the ids passed in
+                var result = repository.GetAll(idsArray);
+                var content = result.ToDictionary(x => x.Id, x => x);
+
+                var sortedResult = idsArray.Select(x =>
+                {
+                    IContent c;
+                    return content.TryGetValue(x, out c) ? c : null;
+                }).WhereNotNull();
+
+                return sortedResult;
+            }
+        }
+
+        /// <summary>
+        /// Gets <see cref="IContent"/> objects by Ids
+        /// </summary>
+        /// <param name="ids">Ids of the Content to retrieve</param>
+        /// <returns><see cref="IContent"/></returns>
+        public IEnumerable<IContent> GetByIds(IEnumerable<Guid> ids)
+        {
+            var idsArray = ids.ToArray();
+            if (idsArray.Length == 0) return Enumerable.Empty<IContent>();
+
+            using (var uow = UowProvider.GetUnitOfWork(readOnly: true))
+            {
+                var repository = RepositoryFactory.CreateContentRepository(uow);
+
+                // ensure that the result has the order based on the ids passed in
+                var result = repository.GetAll(idsArray);
+                var content = result.ToDictionary(x => x.Key, x => x);
+
+                var sortedResult = idsArray.Select(x =>
+                {
+                    IContent c;
+                    return content.TryGetValue(x, out c) ? c : null;
+                }).WhereNotNull();
+
+                return sortedResult;
+            }
+        }
+
+        /// <summary>
+        /// Gets an <see cref="IContent"/> object by its 'UniqueId'
+        /// </summary>
+        /// <param name="key">Guid key of the Content to retrieve</param>
+        /// <returns><see cref="IContent"/></returns>
+        public IContent GetById(Guid key)
+        {
+            using (var uow = UowProvider.GetUnitOfWork(readOnly: true))
+            {
+                var repository = RepositoryFactory.CreateContentRepository(uow);
+                return repository.Get(key);
+            }
+        }
+
+        /// <summary>
+        /// Gets a collection of <see cref="IContent"/> objects by the Id of the <see cref="IContentType"/>
+        /// </summary>
+        /// <param name="id">Id of the <see cref="IContentType"/></param>
+        /// <returns>An Enumerable list of <see cref="IContent"/> objects</returns>
+        public IEnumerable<IContent> GetContentOfContentType(int id)
+        {
+            using (var uow = UowProvider.GetUnitOfWork(readOnly: true))
+            {
+                var repository = RepositoryFactory.CreateContentRepository(uow);
+                var query = Query<IContent>.Builder.Where(x => x.ContentTypeId == id);
+                return repository.GetByQuery(query);
+            }
+        }
+
+        internal IEnumerable<IContent> GetPublishedContentOfContentType(int id)
+        {
+            using (var uow = UowProvider.GetUnitOfWork(readOnly: true))
+            {
+                var repository = RepositoryFactory.CreateContentRepository(uow);
+                var query = Query<IContent>.Builder.Where(x => x.ContentTypeId == id);
+                return repository.GetByPublishedVersion(query);
+            }
+        }
+
+        /// <summary>
+        /// Gets a collection of <see cref="IContent"/> objects by Level
+        /// </summary>
+        /// <param name="level">The level to retrieve Content from</param>
+        /// <returns>An Enumerable list of <see cref="IContent"/> objects</returns>
+        public IEnumerable<IContent> GetByLevel(int level)
+        {
+            using (var uow = UowProvider.GetUnitOfWork(readOnly: true))
+            {
+                var repository = RepositoryFactory.CreateContentRepository(uow);
+                var query = Query<IContent>.Builder.Where(x => x.Level == level && x.Path.StartsWith(Constants.System.RecycleBinContent.ToInvariantString()) == false);
+                return repository.GetByQuery(query);
+            }
+        }
+
+        /// <summary>
+        /// Gets a specific version of an <see cref="IContent"/> item.
+        /// </summary>
+        /// <param name="versionId">Id of the version to retrieve</param>
+        /// <returns>An <see cref="IContent"/> item</returns>
+        public IContent GetByVersion(Guid versionId)
+        {
+            using (var uow = UowProvider.GetUnitOfWork(readOnly: true))
+            {
+                var repository = RepositoryFactory.CreateContentRepository(uow);
+                return repository.GetByVersion(versionId);
+            }
+        }
+
+
+        /// <summary>
+        /// Gets a collection of an <see cref="IContent"/> objects versions by Id
+        /// </summary>
+        /// <param name="id"></param>
+        /// <returns>An Enumerable list of <see cref="IContent"/> objects</returns>
+        public IEnumerable<IContent> GetVersions(int id)
+        {
+            using (var uow = UowProvider.GetUnitOfWork(readOnly: true))
+            {
+                var repository = RepositoryFactory.CreateContentRepository(uow);
+                return repository.GetAllVersions(id);
+            }
+        }
+
+        /// <summary>
+        /// Gets a list of all version Ids for the given content item ordered so latest is first
+        /// </summary>
+        /// <param name="id"></param>
+        /// <param name="maxRows">The maximum number of rows to return</param>
+        /// <returns></returns>
+        public IEnumerable<Guid> GetVersionIds(int id, int maxRows)
+        {
+            using (var uow = UowProvider.GetUnitOfWork(readOnly: true))
+            {
+                var repository = RepositoryFactory.CreateContentRepository(uow);
+                return repository.GetVersionIds(id, maxRows);
+            }
+        }
+
+        /// <summary>
+        /// Gets a collection of <see cref="IContent"/> objects, which are ancestors of the current content.
+        /// </summary>
+        /// <param name="id">Id of the <see cref="IContent"/> to retrieve ancestors for</param>
+        /// <returns>An Enumerable list of <see cref="IContent"/> objects</returns>
+        public IEnumerable<IContent> GetAncestors(int id)
+        {
+            var content = GetById(id);
+            return GetAncestors(content);
+        }
+
+        /// <summary>
+        /// Gets a collection of <see cref="IContent"/> objects, which are ancestors of the current content.
+        /// </summary>
+        /// <param name="content"><see cref="IContent"/> to retrieve ancestors for</param>
+        /// <returns>An Enumerable list of <see cref="IContent"/> objects</returns>
+        public IEnumerable<IContent> GetAncestors(IContent content)
+        {
+            //null check otherwise we get exceptions
+            if (content.Path.IsNullOrWhiteSpace()) return Enumerable.Empty<IContent>();
+
+            var ids = content.Path.Split(',').Where(x => x != Constants.System.Root.ToInvariantString() && x != content.Id.ToString(CultureInfo.InvariantCulture)).Select(int.Parse).ToArray();
+            if (ids.Any() == false)
+                return new List<IContent>();
+
+            using (var uow = UowProvider.GetUnitOfWork(readOnly: true))
+            {
+                var repository = RepositoryFactory.CreateContentRepository(uow);
+                return repository.GetAll(ids);
+            }
+        }
+
+        /// <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>
+        /// <returns>An Enumerable list of <see cref="IContent"/> objects</returns>
+        public IEnumerable<IContent> GetChildren(int id)
+        {
+            using (var uow = UowProvider.GetUnitOfWork(readOnly: true))
+            {
+                var repository = RepositoryFactory.CreateContentRepository(uow);
+                var query = Query<IContent>.Builder.Where(x => x.ParentId == id);
+                return repository.GetByQuery(query).OrderBy(x => x.SortOrder);
+            }
+        }
+
+        [Obsolete("Use the overload with 'long' parameter types instead")]
+        [EditorBrowsable(EditorBrowsableState.Never)]
+        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;
+        }
+
+        /// <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="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, 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");
+
+            using (var uow = UowProvider.GetUnitOfWork(readOnly: true))
+            {
+                var repository = RepositoryFactory.CreateContentRepository(uow);
+
+                var query = Query<IContent>.Builder;
+                // always check for a parent - else it will also get decendants (and then you should use the GetPagedDescendants method)
+                query.Where(x => x.ParentId == id);
+
+                IQuery<IContent> filterQuery = null;
+                if (filter.IsNullOrWhiteSpace() == false)
+                {
+                    filterQuery = Query<IContent>.Builder.Where(x => x.Name.Contains(filter));
+                }
+                return repository.GetPagedResultsByQuery(query, pageIndex, pageSize, out totalChildren, orderBy, orderDirection, orderBySystemField, filterQuery);
+            }
+        }
+
+        [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");
+            using (var uow = UowProvider.GetUnitOfWork(readOnly: true))
+            {
+                var repository = RepositoryFactory.CreateContentRepository(uow);
+
+                // get query - if the id is System Root, then just get all
+                var query = Query<IContent>.Builder;
+                if (id != Constants.System.Root)
+                {
+                    var entityRepository = RepositoryFactory.CreateEntityRepository(uow);
+                    var contentPath = entityRepository.GetAllPaths(Constants.ObjectTypes.DocumentGuid, id).ToArray();
+                    if (contentPath.Length == 0)
+                    {
+                        totalChildren = 0;
+                        return Enumerable.Empty<IContent>();
+                    }
+                    query.Where(x => x.Path.SqlStartsWith(string.Format("{0},", contentPath[0].Path), TextColumnType.NVarchar));
+                }
+
+
+                // get filter
+                IQuery<IContent> filterQuery = null;
+                if (filter.IsNullOrWhiteSpace() == false)
+                    filterQuery = Query<IContent>.Builder.Where(x => x.Name.Contains(filter));
+
+                return repository.GetPagedResultsByQuery(query, pageIndex, pageSize, out totalChildren, orderBy, orderDirection, orderBySystemField, filterQuery);
+            }
+        }
+
+        /// <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 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, IQuery<IContent> filter)
+        {
+            Mandate.ParameterCondition(pageIndex >= 0, "pageIndex");
+            Mandate.ParameterCondition(pageSize > 0, "pageSize");
+
+            using (var uow = UowProvider.GetUnitOfWork(readOnly: true))
+            {
+                var repository = RepositoryFactory.CreateContentRepository(uow);
+
+                // get query - if the id is System Root, then just get all
+                var query = Query<IContent>.Builder;
+                if (id != Constants.System.Root)
+                {
+                    var entityRepository = RepositoryFactory.CreateEntityRepository(uow);
+                    var contentPath = entityRepository.GetAllPaths(Constants.ObjectTypes.DocumentGuid, id).ToArray();
+                    if (contentPath.Length == 0)
+                    {
+                        totalChildren = 0;
+                        return Enumerable.Empty<IContent>();
+                    }
+                    query.Where(x => x.Path.SqlStartsWith(string.Format("{0},", contentPath[0].Path), TextColumnType.NVarchar));
+                }
+
+                return repository.GetPagedResultsByQuery(query, pageIndex, pageSize, out totalChildren, orderBy, orderDirection, orderBySystemField, filter);
+            }
+        }
+
+        /// <summary>
+        /// Gets a collection of <see cref="IContent"/> objects by its name or partial name
+        /// </summary>
+        /// <param name="parentId">Id of the Parent to retrieve Children from</param>
+        /// <param name="name">Full or partial name of the children</param>
+        /// <returns>An Enumerable list of <see cref="IContent"/> objects</returns>
+        public IEnumerable<IContent> GetChildrenByName(int parentId, string name)
+        {
+            using (var uow = UowProvider.GetUnitOfWork(readOnly: true))
+            {
+                var repository = RepositoryFactory.CreateContentRepository(uow);
+
+                var query = Query<IContent>.Builder.Where(x => x.ParentId == parentId && x.Name.Contains(name));
+                return repository.GetByQuery(query);
+            }
+        }
+
+        /// <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>
+        /// <returns>An Enumerable list of <see cref="IContent"/> objects</returns>
+        public IEnumerable<IContent> GetDescendants(int id)
+        {
+            var content = GetById(id);
+            return content == null ? Enumerable.Empty<IContent>() : GetDescendants(content);
+        }
+
+        /// <summary>
+        /// Gets a collection of <see cref="IContent"/> objects by Parent Id
+        /// </summary>
+        /// <param name="content"><see cref="IContent"/> item to retrieve Descendants from</param>
+        /// <returns>An Enumerable list of <see cref="IContent"/> objects</returns>
+        public IEnumerable<IContent> GetDescendants(IContent content)
+        {
+            //This is a check to ensure that the path is correct for this entity to avoid problems like: http://issues.umbraco.org/issue/U4-9336 due to data corruption
+            if (content.ValidatePath() == false)
+                throw new InvalidDataException(string.Format("The content item {0} has an invalid path: {1} with parentID: {2}", content.Id, content.Path, content.ParentId));
+
+            using (var uow = UowProvider.GetUnitOfWork(readOnly: true))
+            {
+                var repository = RepositoryFactory.CreateContentRepository(uow);
+
+                var pathMatch = content.Path + ",";
+                var query = Query<IContent>.Builder.Where(x => x.Path.StartsWith(pathMatch) && x.Id != content.Id);
+                return repository.GetByQuery(query);
+            }
+        }
+
+        /// <summary>
+        /// Gets the parent of the current content as an <see cref="IContent"/> item.
+        /// </summary>
+        /// <param name="id">Id of the <see cref="IContent"/> to retrieve the parent from</param>
+        /// <returns>Parent <see cref="IContent"/> object</returns>
+        public IContent GetParent(int id)
+        {
+            var content = GetById(id);
+            return GetParent(content);
+        }
+
+        /// <summary>
+        /// Gets the parent of the current content as an <see cref="IContent"/> item.
+        /// </summary>
+        /// <param name="content"><see cref="IContent"/> to retrieve the parent from</param>
+        /// <returns>Parent <see cref="IContent"/> object</returns>
+        public IContent GetParent(IContent content)
+        {
+            if (content.ParentId == Constants.System.Root || content.ParentId == Constants.System.RecycleBinContent)
+                return null;
+
+            return GetById(content.ParentId);
+        }
+
+        /// <summary>
+        /// Gets the published version of an <see cref="IContent"/> item
+        /// </summary>
+        /// <param name="id">Id of the <see cref="IContent"/> to retrieve version from</param>
+        /// <returns>An <see cref="IContent"/> item</returns>
+        public IContent GetPublishedVersion(int id)
+        {
+            var version = GetVersions(id);
+            return version.FirstOrDefault(x => x.Published);
+        }
+
+        /// <summary>
+        /// Gets the published version of a <see cref="IContent"/> item.
+        /// </summary>
+        /// <param name="content">The content item.</param>
+        /// <returns>The published version, if any; otherwise, null.</returns>
+        public IContent GetPublishedVersion(IContent content)
+        {
+            if (content.Published) return content;
+            return content.HasPublishedVersion
+                ? GetByVersion(content.PublishedVersionGuid)
+                : null;
+        }
+
+        /// <summary>
+        /// Gets a collection of <see cref="IContent"/> objects, which reside at the first level / root
+        /// </summary>
+        /// <returns>An Enumerable list of <see cref="IContent"/> objects</returns>
+        public IEnumerable<IContent> GetRootContent()
+        {
+            using (var uow = UowProvider.GetUnitOfWork(readOnly: true))
+            {
+                var repository = RepositoryFactory.CreateContentRepository(uow);
+
+                var query = Query<IContent>.Builder.Where(x => x.ParentId == Constants.System.Root);
+                return repository.GetByQuery(query);
+            }
+        }
+
+        /// <summary>
+        /// Gets all published content items
+        /// </summary>
+        /// <returns></returns>
+        internal IEnumerable<IContent> GetAllPublished()
+        {
+            //create it once if it is needed (no need for locking here)
+            if (_notTrashedQuery == null)
+            {
+                _notTrashedQuery = Query<IContent>.Builder.Where(x => x.Trashed == false);
+            }
+
+            using (var uow = UowProvider.GetUnitOfWork(readOnly: true))
+            {
+                var repository = RepositoryFactory.CreateContentRepository(uow);
+                return repository.GetByPublishedVersion(_notTrashedQuery);
+            }
+        }
+
+        /// <summary>
+        /// Gets a collection of <see cref="IContent"/> objects, which has an expiration date less than or equal to today.
+        /// </summary>
+        /// <returns>An Enumerable list of <see cref="IContent"/> objects</returns>
+        public IEnumerable<IContent> GetContentForExpiration()
+        {
+            using (var uow = UowProvider.GetUnitOfWork(readOnly: true))
+            {
+                var repository = RepositoryFactory.CreateContentRepository(uow);
+                var query = Query<IContent>.Builder.Where(x => x.ExpireDate <= DateTime.Now);
+                return repository.GetByQuery(query).Where(x => x.HasPublishedVersion);
+            }
+        }
+
+        /// <summary>
+        /// Gets a collection of <see cref="IContent"/> objects, which has a release date less than or equal to today.
+        /// </summary>
+        /// <returns>An Enumerable list of <see cref="IContent"/> objects</returns>
+        public IEnumerable<IContent> GetContentForRelease()
+        {
+            using (var uow = UowProvider.GetUnitOfWork(readOnly: true))
+            {
+                var repository = RepositoryFactory.CreateContentRepository(uow);
+                var query = Query<IContent>.Builder.Where(x => x.Published == false && x.ReleaseDate <= DateTime.Now);
+                return repository.GetByQuery(query);
+            }
+        }
+
+        /// <summary>
+        /// Gets a collection of an <see cref="IContent"/> objects, which resides in the Recycle Bin
+        /// </summary>
+        /// <returns>An Enumerable list of <see cref="IContent"/> objects</returns>
+        public IEnumerable<IContent> GetContentInRecycleBin()
+        {
+            using (var uow = UowProvider.GetUnitOfWork(readOnly: true))
+            {
+                var repository = RepositoryFactory.CreateContentRepository(uow);
+                var query = Query<IContent>.Builder.Where(x => x.Path.StartsWith(Constants.System.RecycleBinContentPathPrefix));
+                return repository.GetByQuery(query);
+            }
+        }
+
+        /// <summary>
+        /// Checks whether an <see cref="IContent"/> item has any children
+        /// </summary>
+        /// <param name="id">Id of the <see cref="IContent"/></param>
+        /// <returns>True if the content has any children otherwise False</returns>
+        public bool HasChildren(int id)
+        {
+            return CountChildren(id) > 0;
+        }
+
+        internal int CountChildren(int id)
+        {
+            using (var uow = UowProvider.GetUnitOfWork(readOnly: true))
+            {
+                var repository = RepositoryFactory.CreateContentRepository(uow);
+                var query = Query<IContent>.Builder.Where(x => x.ParentId == id);
+                return repository.Count(query);
+            }
+        }
+
+        /// <summary>
+        /// Checks whether an <see cref="IContent"/> item has any published versions
+        /// </summary>
+        /// <param name="id">Id of the <see cref="IContent"/></param>
+        /// <returns>True if the content has any published version otherwise False</returns>
+        public bool HasPublishedVersion(int id)
+        {
+            using (var uow = UowProvider.GetUnitOfWork(readOnly: true))
+            {
+                var repository = RepositoryFactory.CreateContentRepository(uow);
+                var query = Query<IContent>.Builder.Where(x => x.Published == true && x.Id == id && x.Trashed == false);
+                return repository.Count(query) > 0;
+            }
+        }
+
+        /// <summary>
+        /// Checks if the passed in <see cref="IContent"/> can be published based on the anscestors publish state.
+        /// </summary>
+        /// <param name="content"><see cref="IContent"/> to check if anscestors are published</param>
+        /// <returns>True if the Content can be published, otherwise False</returns>
+        public bool IsPublishable(IContent content)
+        {
+            int[] ids;
+            if (content.HasIdentity)
+            {
+                // get ids from path (we have identity)
+                // skip the first one that has to be -1 - and we don't care
+                // skip the last one that has to be "this" - and it's ok to stop at the parent
+                ids = content.Path.Split(',').Skip(1).SkipLast().Select(int.Parse).ToArray();
+            }
+            else
+            {
+                // no path yet (no identity), have to move up to parent
+                // skip the first one that has to be -1 - and we don't care
+                // don't skip the last one that is "parent"
+                var parent = GetById(content.ParentId);
+                if (parent == null) return false;
+                ids = parent.Path.Split(',').Skip(1).Select(int.Parse).ToArray();
+            }
+            if (ids.Length == 0)
+                return false;
+
+            // if the first one is recycle bin, fail fast
+            if (ids[0] == Constants.System.RecycleBinContent)
+                return false;
+
+            // fixme - move to repository?
+            using (var uow = UowProvider.GetUnitOfWork(readOnly: true))
+            {
+                var sql = new Sql(@"
+                    SELECT id
+                    FROM umbracoNode
+                    JOIN cmsDocument ON umbracoNode.id=cmsDocument.nodeId AND cmsDocument.published=@0
+                    WHERE umbracoNode.trashed=@1 AND umbracoNode.id IN (@2)",
+                    true, false, ids);
+                var x = uow.Database.Fetch<int>(sql);
+                return ids.Length == x.Count;
+            }
+        }
+
+        /// <summary>
+        /// This will rebuild the xml structures for content in the database.
+        /// </summary>
+        /// <param name="userId">This is not used for anything</param>
+        /// <returns>True if publishing succeeded, otherwise False</returns>
+        /// <remarks>
+        /// This is used for when a document type alias or a document type property is changed, the xml will need to
+        /// be regenerated.
+        /// </remarks>
+        public bool RePublishAll(int userId = 0)
+        {
+            try
+            {
+                RebuildXmlStructures();
+                return true;
+            }
+            catch (Exception ex)
+            {
+                Logger.Error<ContentService>("An error occurred executing RePublishAll", ex);
+                return false;
+            }
+        }
+
+        /// <summary>
+        /// This will rebuild the xml structures for content in the database.
+        /// </summary>
+        /// <param name="contentTypeIds">
+        /// If specified will only rebuild the xml for the content type's specified, otherwise will update the structure
+        /// for all published content.
+        /// </param>
+        internal void RePublishAll(params int[] contentTypeIds)
+        {
+            try
+            {
+                RebuildXmlStructures(contentTypeIds);
+            }
+            catch (Exception ex)
+            {
+                Logger.Error<ContentService>("An error occurred executing RePublishAll", ex);
+            }
+        }
+
+        /// <summary>
+        /// Publishes a single <see cref="IContent"/> object
+        /// </summary>
+        /// <param name="content">The <see cref="IContent"/> to publish</param>
+        /// <param name="userId">Optional Id of the User issueing the publishing</param>
+        /// <returns>True if publishing succeeded, otherwise False</returns>
+        public bool Publish(IContent content, int userId = 0)
+        {
+            var result = SaveAndPublishDo(content, userId);
+            Logger.Info<ContentService>("Call was made to ContentService.Publish, use PublishWithStatus instead since that method will provide more detailed information on the outcome");
+            return result.Success;
+        }
+
+        /// <summary>
+        /// Publishes a <see cref="IContent"/> object and all its children
+        /// </summary>
+        /// <param name="content">The <see cref="IContent"/> to publish along with its children</param>
+        /// <param name="userId">Optional Id of the User issueing the publishing</param>
+        /// <param name="includeUnpublished"></param>
+        /// <returns>The list of statuses for all published items</returns>
+        IEnumerable<Attempt<PublishStatus>> IContentServiceOperations.PublishWithChildren(IContent content, int userId, bool includeUnpublished)
+        {
+            return PublishWithChildrenDo(content, userId, includeUnpublished);
+        }
+
+        /// <summary>
+        /// Saves and Publishes a single <see cref="IContent"/> object
+        /// </summary>
+        /// <param name="content">The <see cref="IContent"/> to save and publish</param>
+        /// <param name="userId">Optional Id of the User issueing the publishing</param>
+        /// <param name="raiseEvents">Optional boolean indicating whether or not to raise save events.</param>
+        /// <returns>True if publishing succeeded, otherwise False</returns>
+        Attempt<PublishStatus> IContentServiceOperations.SaveAndPublish(IContent content, int userId, bool raiseEvents)
+        {
+            return SaveAndPublishDo(content, userId, raiseEvents);
+        }
+
+        /// <summary>
+        /// Deletes an <see cref="IContent"/> object by moving it to the Recycle Bin
+        /// </summary>
+        /// <remarks>Move an item to the Recycle Bin will result in the item being unpublished</remarks>
+        /// <param name="content">The <see cref="IContent"/> to delete</param>
+        /// <param name="userId">Optional Id of the User deleting the Content</param>
+        Attempt<OperationStatus> IContentServiceOperations.MoveToRecycleBin(IContent content, int userId)
+        {
+            return MoveToRecycleBinDo(content, userId, false);
+        }
+
+        /// <summary>
+        /// Deletes an <see cref="IContent"/> object by moving it to the Recycle Bin
+        /// </summary>
+        /// <remarks>Move an item to the Recycle Bin will result in the item being unpublished</remarks>
+        /// <param name="content">The <see cref="IContent"/> to delete</param>
+        /// <param name="userId">Optional Id of the User deleting the Content</param>
+        /// <param name="ignoreDescendants">
+        /// A boolean indicating to ignore this item's descendant list from also being moved to the recycle bin. This is required for the DeleteContentOfTypes method
+        /// because it has already looked up all descendant nodes that will need to be recycled
+        /// TODO: Fix all of this, it will require a reasonable refactor and most of this stuff should be done at the repo level instead of service sub operations
+        /// </param>
+        private Attempt<OperationStatus> MoveToRecycleBinDo(IContent content, int userId, bool ignoreDescendants)
+        {
+            var evtMsgs = EventMessagesFactory.Get();
+            using (new WriteLock(Locker))
+            {
+                using (var uow = UowProvider.GetUnitOfWork())
+                {
+                    //Hack: this ensures that the entity's path is valid and if not it fixes/persists it
+                    //see: http://issues.umbraco.org/issue/U4-9336
+                    content.EnsureValidPath(Logger, entity => GetById(entity.ParentId), QuickUpdate);
+                    var originalPath = content.Path;
+                    var moveEventInfo = new MoveEventInfo<IContent>(content, originalPath, Constants.System.RecycleBinContent);
+                    var moveEventArgs = new MoveEventArgs<IContent>(evtMsgs, moveEventInfo);
+                    if (uow.Events.DispatchCancelable(Trashing, this, moveEventArgs, "Trashing"))
+                    {
+                        uow.Commit();
+                        return OperationStatus.Cancelled(evtMsgs);
+                    }
+                    var moveInfo = new List<MoveEventInfo<IContent>>
+                    {
+                        moveEventInfo
+                    };
+
+                    //get descendents to process of the content item that is being moved to trash - must be done before changing the state below
+                    //must be processed with shallowest levels first
+                    var descendants = ignoreDescendants ? Enumerable.Empty<IContent>() : GetDescendants(content).OrderBy(x => x.Level);
+
+                    //Do the updates for this item
+                    var repository = RepositoryFactory.CreateContentRepository(uow);
+                    //Make sure that published content is unpublished before being moved to the Recycle Bin
+                    if (HasPublishedVersion(content.Id))
+                    {
+                        //TODO: this shouldn't be a 'sub operation', and if it needs to be it cannot raise events and cannot be cancelled!
+                        UnPublish(content, userId);
+                    }
+                    content.WriterId = userId;
+                    content.ChangeTrashedState(true);
+                    repository.AddOrUpdate(content);
+
+                    //Loop through descendants to update their trash state, but ensuring structure by keeping the ParentId
+                    foreach (var descendant in descendants)
+                    {
+                        //TODO: this shouldn't be a 'sub operation', and if it needs to be it cannot raise events and cannot be cancelled!
+                        UnPublish(descendant, userId);
+                        descendant.WriterId = userId;
+                        descendant.ChangeTrashedState(true, descendant.ParentId);
+                        repository.AddOrUpdate(descendant);
+
+                        moveInfo.Add(new MoveEventInfo<IContent>(descendant, descendant.Path, descendant.ParentId));
+                    }
+
+                    moveEventArgs.CanCancel = false;
+                    moveEventArgs.MoveInfoCollection = moveInfo;
+                    uow.Events.Dispatch(Trashed, this, moveEventArgs, "Trashed");
+
+                    Audit(uow, AuditType.Move, "Move Content to Recycle Bin performed by user", userId, content.Id);
+                    uow.Commit();
+                }
+
+                return OperationStatus.Success(evtMsgs);
+            }
+        }
+
+        /// <summary>
+        /// UnPublishes a single <see cref="IContent"/> object
+        /// </summary>
+        /// <param name="content">The <see cref="IContent"/> to publish</param>
+        /// <param name="userId">Optional Id of the User issueing the publishing</param>
+        /// <returns>True if unpublishing succeeded, otherwise False</returns>
+        Attempt<UnPublishStatus> IContentServiceOperations.UnPublish(IContent content, int userId)
+        {
+            return UnPublishDo(content, false, userId);
+        }
+
+        /// <summary>
+        /// Publishes a single <see cref="IContent"/> object
+        /// </summary>
+        /// <param name="content">The <see cref="IContent"/> to publish</param>
+        /// <param name="userId">Optional Id of the User issueing the publishing</param>
+        /// <returns>True if publishing succeeded, otherwise False</returns>
+        public Attempt<PublishStatus> PublishWithStatus(IContent content, int userId = 0)
+        {
+            return ((IContentServiceOperations)this).Publish(content, userId);
+        }
+
+        /// <summary>
+        /// Publishes a <see cref="IContent"/> object and all its children
+        /// </summary>
+        /// <param name="content">The <see cref="IContent"/> to publish along with its children</param>
+        /// <param name="userId">Optional Id of the User issueing the publishing</param>
+        /// <returns>True if publishing succeeded, otherwise False</returns>
+        [Obsolete("Use PublishWithChildrenWithStatus instead, that method will provide more detailed information on the outcome and also allows the includeUnpublished flag")]
+        public bool PublishWithChildren(IContent content, int userId = 0)
+        {
+            var result = PublishWithChildrenDo(content, userId, true);
+
+            //This used to just return false only when the parent content failed, otherwise would always return true so we'll
+            // do the same thing for the moment
+            if (result.All(x => x.Result.ContentItem.Id != content.Id))
+                return false;
+
+            return result.Single(x => x.Result.ContentItem.Id == content.Id).Success;
+        }
+
+        /// <summary>
+        /// Publishes a <see cref="IContent"/> object and all its children
+        /// </summary>
+        /// <param name="content">The <see cref="IContent"/> to publish along with its children</param>
+        /// <param name="userId">Optional Id of the User issueing the publishing</param>
+        /// <param name="includeUnpublished">set to true if you want to also publish children that are currently unpublished</param>
+        /// <returns>True if publishing succeeded, otherwise False</returns>
+        public IEnumerable<Attempt<PublishStatus>> PublishWithChildrenWithStatus(IContent content, int userId = 0, bool includeUnpublished = false)
+        {
+            return ((IContentServiceOperations)this).PublishWithChildren(content, userId, includeUnpublished);
+        }
+
+        /// <summary>
+        /// UnPublishes a single <see cref="IContent"/> object
+        /// </summary>
+        /// <param name="content">The <see cref="IContent"/> to publish</param>
+        /// <param name="userId">Optional Id of the User issueing the publishing</param>
+        /// <returns>True if unpublishing succeeded, otherwise False</returns>
+        public bool UnPublish(IContent content, int userId = 0)
+        {
+            var attempt = ((IContentServiceOperations)this).UnPublish(content, userId);
+            LogHelper.Debug<ContentService>(string.Format("Result of unpublish attempt: {0}", attempt.Result.StatusType));
+            return attempt.Success;
+        }
+
+        /// <summary>
+        /// Saves and Publishes a single <see cref="IContent"/> object
+        /// </summary>
+        /// <param name="content">The <see cref="IContent"/> to save and publish</param>
+        /// <param name="userId">Optional Id of the User issueing the publishing</param>
+        /// <param name="raiseEvents">Optional boolean indicating whether or not to raise save events.</param>
+        /// <returns>True if publishing succeeded, otherwise False</returns>
+        [Obsolete("Use SaveAndPublishWithStatus instead, that method will provide more detailed information on the outcome")]
+        public bool SaveAndPublish(IContent content, int userId = 0, bool raiseEvents = true)
+        {
+            var result = SaveAndPublishDo(content, userId, raiseEvents);
+            return result.Success;
+        }
+
+        /// <summary>
+        /// Saves and Publishes a single <see cref="IContent"/> object
+        /// </summary>
+        /// <param name="content">The <see cref="IContent"/> to save and publish</param>
+        /// <param name="userId">Optional Id of the User issueing the publishing</param>
+        /// <param name="raiseEvents">Optional boolean indicating whether or not to raise save events.</param>
+        /// <returns>True if publishing succeeded, otherwise False</returns>
+        public Attempt<PublishStatus> SaveAndPublishWithStatus(IContent content, int userId = 0, bool raiseEvents = true)
+        {
+            return ((IContentServiceOperations)this).SaveAndPublish(content, userId, raiseEvents);
+        }
+
+        public IContent GetBlueprintById(int id)
+        {
+            using (var uow = UowProvider.GetUnitOfWork(readOnly: true))
+            {
+                var repository = RepositoryFactory.CreateContentBlueprintRepository(uow);
+                var blueprint = repository.Get(id);
+                if (blueprint != null)
+                    ((Content) blueprint).IsBlueprint = true;
+                return blueprint;
+            }
+        }
+
+        public IContent GetBlueprintById(Guid id)
+        {
+            using (var uow = UowProvider.GetUnitOfWork(readOnly: true))
+            {
+                var repository = RepositoryFactory.CreateContentBlueprintRepository(uow);
+                var blueprint = repository.Get(id);
+                if (blueprint != null)
+                    ((Content)blueprint).IsBlueprint = true;
+                return blueprint;
+            }
+        }
+
+        public void SaveBlueprint(IContent content, int userId = 0)
+        {
+            //always ensure the blueprint is at the root
+            if (content.ParentId != -1)
+                content.ParentId = -1;
+
+            ((Content) content).IsBlueprint = true;
+
+            using (new WriteLock(Locker))
+            {
+                using (var uow = UowProvider.GetUnitOfWork())
+                {
+                    if (string.IsNullOrWhiteSpace(content.Name))
+                    {
+                        throw new ArgumentException("Cannot save content blueprint with empty name.");
+                    }
+
+                    var repository = RepositoryFactory.CreateContentBlueprintRepository(uow);
+
+                    if (content.HasIdentity == false)
+                    {
+                        content.CreatorId = userId;
+                    }
+                    content.WriterId = userId;
+
+                    repository.AddOrUpdate(content);
+
+                    uow.Events.Dispatch(SavedBlueprint, this, new SaveEventArgs<IContent>(content), "SavedBlueprint");
+
+                    uow.Commit();
+                }
+            }
+        }
+
+        public void DeleteBlueprint(IContent content, int userId = 0)
+        {
+            using (new WriteLock(Locker))
+            {
+                using (var uow = UowProvider.GetUnitOfWork())
+                {
+                    var repository = RepositoryFactory.CreateContentBlueprintRepository(uow);
+                    repository.Delete(content);
+                    uow.Events.Dispatch(DeletedBlueprint, this, new DeleteEventArgs<IContent>(content), "DeletedBlueprint");
+                    uow.Commit();
+                }
+            }
+        }
+
+        public IContent CreateContentFromBlueprint(IContent blueprint, string name, int userId = 0)
+        {
+            if (blueprint == null) throw new ArgumentNullException("blueprint");
+
+            var contentType = blueprint.ContentType;
+            var content = new Content(name, -1, contentType);
+            content.Path = string.Concat(content.ParentId.ToString(), ",", content.Id);
+
+            content.CreatorId = userId;
+            content.WriterId = userId;
+
+            foreach (var property in blueprint.Properties)
+                content.SetValue(property.Alias, property.Value);
+
+            return content;
+        }
+
+        public void DeleteBlueprintsOfTypes(IEnumerable<int> contentTypeIds, int userId = 0)
+        {
+            using (new WriteLock(Locker))
+            using (var uow = UowProvider.GetUnitOfWork())
+            {
+                var repository = RepositoryFactory.CreateContentBlueprintRepository(uow);
+
+                var contentTypeIdsA = contentTypeIds.ToArray();
+                var query = new Query<IContent>();
+                if (contentTypeIdsA.Length > 0)
+                {
+                    query.Where(x => contentTypeIdsA.Contains(x.ContentTypeId));
+                }
+                var blueprints = repository.GetByQuery(query).Select(x =>
+                {
+                    ((Content) x).IsBlueprint = true;
+                    return x;
+                }).ToArray();
+
+                foreach (var blueprint in blueprints)
+                {
+                    repository.Delete(blueprint);
+                }
+
+                uow.Events.Dispatch(DeletedBlueprint, this, new DeleteEventArgs<IContent>(blueprints), "DeletedBlueprint");
+                uow.Commit();
+            }
+        }
+
+        public void DeleteBlueprintsOfType(int contentTypeId, int userId = 0)
+        {
+            DeleteBlueprintsOfTypes(new[] {contentTypeId}, userId);
+        }
+
+        /// <summary>
+        /// Saves a single <see cref="IContent"/> object
+        /// </summary>
+        /// <param name="content">The <see cref="IContent"/> to save</param>
+        /// <param name="userId">Optional Id of the User saving the Content</param>
+        /// <param name="raiseEvents">Optional boolean indicating whether or not to raise events.</param>
+        public void Save(IContent content, int userId = 0, bool raiseEvents = true)
+        {
+            ((IContentServiceOperations)this).Save(content, userId, raiseEvents);
+        }
+
+        /// <summary>
+        /// Saves a collection of <see cref="IContent"/> objects.
+        /// </summary>
+        /// <param name="contents">Collection of <see cref="IContent"/> to save</param>
+        /// <param name="userId">Optional Id of the User saving the Content</param>
+        /// <param name="raiseEvents">Optional boolean indicating whether or not to raise events.</param>
+        Attempt<OperationStatus> IContentServiceOperations.Save(IEnumerable<IContent> contents, int userId, bool raiseEvents)
+        {
+            var asArray = contents.ToArray();
+
+            var evtMsgs = EventMessagesFactory.Get();
+
+            using (var uow = UowProvider.GetUnitOfWork())
+            {
+                var saveEventArgs = new SaveEventArgs<IContent>(asArray, evtMsgs);
+                if (raiseEvents && uow.Events.DispatchCancelable(Saving, this, saveEventArgs, "Saving"))
+                {
+                    uow.Commit();
+                    return OperationStatus.Cancelled(evtMsgs);
+                }
+
+                // todo - understand what's a lock in a scope?
+                // (though, these locks are refactored in v8)
+                using (new WriteLock(Locker))
+                {
+                    var containsNew = asArray.Any(x => x.HasIdentity == false);
+                    var repository = RepositoryFactory.CreateContentRepository(uow);
+
+                    if (containsNew)
+                    {
+                        foreach (var content in asArray)
+                        {
+                            content.WriterId = userId;
+
+                            //Only change the publish state if the "previous" version was actually published
+                            if (content.Published)
+                                content.ChangePublishedState(PublishedState.Saved);
+
+                            repository.AddOrUpdate(content);
+                            //add or update preview
+                            repository.AddOrUpdatePreviewXml(content, c => _entitySerializer.Serialize(this, _dataTypeService, _userService, c));
+                        }
+                    }
+                    else
+                    {
+                        foreach (var content in asArray)
+                        {
+                            content.WriterId = userId;
+                            repository.AddOrUpdate(content);
+                            //add or update preview
+                            repository.AddOrUpdatePreviewXml(content, c => _entitySerializer.Serialize(this, _dataTypeService, _userService, c));
+                        }
+                    }
+                }
+
+                if (raiseEvents)
+                {
+                    saveEventArgs.CanCancel = false;
+                    uow.Events.Dispatch(Saved, this, saveEventArgs, "Saved");
+                }
+
+                Audit(uow, AuditType.Save, "Bulk Save content performed by user", userId == -1 ? 0 : userId, Constants.System.Root);
+                uow.Commit();
+
+                return OperationStatus.Success(evtMsgs);
+            }
+        }
+
+        /// <summary>
+        /// Permanently deletes an <see cref="IContent"/> object.
+        /// </summary>
+        /// <remarks>
+        /// This method will also delete associated media files, child content and possibly associated domains.
+        /// </remarks>
+        /// <remarks>Please note that this method will completely remove the Content from the database</remarks>
+        /// <param name="content">The <see cref="IContent"/> to delete</param>
+        /// <param name="userId">Optional Id of the User deleting the Content</param>
+        Attempt<OperationStatus> IContentServiceOperations.Delete(IContent content, int userId)
+        {
+            var evtMsgs = EventMessagesFactory.Get();
+
+            using (new WriteLock(Locker))
+            {
+                using (var uow = UowProvider.GetUnitOfWork())
+                {
+                    var deleteEventArgs = new DeleteEventArgs<IContent>(content, evtMsgs);
+                    if (uow.Events.DispatchCancelable(Deleting, this, deleteEventArgs, "Deleting"))
+                    {
+                        uow.Commit();
+                        return OperationStatus.Cancelled(evtMsgs);
+                    }
+
+                    //Make sure that published content is unpublished before being deleted
+                    if (HasPublishedVersion(content.Id))
+                    {
+                        UnPublish(content, userId);
+                    }
+
+                    //Delete children before deleting the 'possible parent'
+                    var children = GetChildren(content.Id);
+                    foreach (var child in children)
+                    {
+                        Delete(child, userId);
+                    }
+
+                    var repository = RepositoryFactory.CreateContentRepository(uow);
+
+                    repository.Delete(content);
+
+                    deleteEventArgs.CanCancel = false;
+                    uow.Events.Dispatch(Deleted, this, deleteEventArgs, "Deleted");
+
+                    Audit(uow, AuditType.Delete, "Delete Content performed by user", userId, content.Id);
+                    uow.Commit();
+                }
+
+                return OperationStatus.Success(evtMsgs);
+            }
+        }
+
+        /// <summary>
+        /// Publishes a single <see cref="IContent"/> object
+        /// </summary>
+        /// <param name="content">The <see cref="IContent"/> to publish</param>
+        /// <param name="userId">Optional Id of the User issueing the publishing</param>
+        /// <returns>The published status attempt</returns>
+        Attempt<PublishStatus> IContentServiceOperations.Publish(IContent content, int userId)
+        {
+            return SaveAndPublishDo(content, userId);
+        }
+
+        /// <summary>
+        /// Saves a single <see cref="IContent"/> object
+        /// </summary>
+        /// <param name="content">The <see cref="IContent"/> to save</param>
+        /// <param name="userId">Optional Id of the User saving the Content</param>
+        /// <param name="raiseEvents">Optional boolean indicating whether or not to raise events.</param>
+        Attempt<OperationStatus> IContentServiceOperations.Save(IContent content, int userId, bool raiseEvents)
+        {
+            return Save(content, true, userId, raiseEvents);
+        }
+
+        /// <summary>
+        /// Saves a collection of <see cref="IContent"/> objects.
+        /// </summary>
+        /// <remarks>
+        /// If the collection of content contains new objects that references eachother by Id or ParentId,
+        /// then use the overload Save method with a collection of Lazy <see cref="IContent"/>.
+        /// </remarks>
+        /// <param name="contents">Collection of <see cref="IContent"/> to save</param>
+        /// <param name="userId">Optional Id of the User saving the Content</param>
+        /// <param name="raiseEvents">Optional boolean indicating whether or not to raise events.</param>
+        public void Save(IEnumerable<IContent> contents, int userId = 0, bool raiseEvents = true)
+        {
+            ((IContentServiceOperations)this).Save(contents, userId, raiseEvents);
+        }
+
+        /// <summary>
+        /// Deletes all content of the specified types. All Descendants of deleted content that is not of these types is moved to Recycle Bin.
+        /// </summary>
+        /// <param name="contentTypeIds">Id of the <see cref="IContentType"/></param>
+        /// <param name="userId">Optional Id of the user issueing the delete operation</param>
+        public void DeleteContentOfTypes(IEnumerable<int> contentTypeIds, int userId = 0)
+        {
+            using (new WriteLock(Locker))
+            using (var uow = UowProvider.GetUnitOfWork())
+            {
+                var repository = RepositoryFactory.CreateContentRepository(uow);
+
+                //track the 'root' items of the collection of nodes discovered to delete, we need to use
+                //these items to lookup descendants that are not of this doc type so they can be transfered
+                //to the recycle bin
+                IDictionary<string, IContent> rootItems;
+                var contentToDelete = this.TrackDeletionsForDeleteContentOfTypes(contentTypeIds, repository, out rootItems).ToArray();
+
+                if (uow.Events.DispatchCancelable(Deleting, this, new DeleteEventArgs<IContent>(contentToDelete), "Deleting"))
+                {
+                    uow.Commit();
+                    return;
+                }
+
+                //Determine the items that will need to be recycled (that are children of these content items but not of these content types)
+                var contentToRecycle = this.TrackTrashedForDeleteContentOfTypes(contentTypeIds, rootItems, repository);
+
+                //move each item to the bin starting with the deepest items
+                foreach (var child in contentToRecycle.OrderByDescending(x => x.Level))
+                {
+                    MoveToRecycleBinDo(child, userId, true);
+                }
+
+                foreach (var content in contentToDelete)
+                {
+                    Delete(content, userId);
+                }
+
+                Audit(uow, AuditType.Delete,
+                    string.Format("Delete Content of Types {0} performed by user", string.Join(",", contentTypeIds)),
+                    userId, Constants.System.Root);
+                uow.Commit();
+            }
+        }
+
+        /// <summary>
+        /// Deletes all content of specified type. All children of deleted content is moved to Recycle Bin.
+        /// </summary>
+        /// <remarks>This needs extra care and attention as its potentially a dangerous and extensive operation</remarks>
+        /// <param name="contentTypeId">Id of the <see cref="IContentType"/></param>
+        /// <param name="userId">Optional Id of the user issueing the delete operation</param>
+        public void DeleteContentOfType(int contentTypeId, int userId = 0)
+        {
+            DeleteContentOfTypes(new[] {contentTypeId}, userId);
+        }
+
+        /// <summary>
+        /// Permanently deletes an <see cref="IContent"/> object as well as all of its Children.
+        /// </summary>
+        /// <remarks>
+        /// This method will also delete associated media files, child content and possibly associated domains.
+        /// </remarks>
+        /// <remarks>Please note that this method will completely remove the Content from the database</remarks>
+        /// <param name="content">The <see cref="IContent"/> to delete</param>
+        /// <param name="userId">Optional Id of the User deleting the Content</param>
+        public void Delete(IContent content, int userId = 0)
+        {
+            ((IContentServiceOperations)this).Delete(content, userId);
+        }
+
+        /// <summary>
+        /// Permanently deletes versions from an <see cref="IContent"/> object prior to a specific date.
+        /// This method will never delete the latest version of a content item.
+        /// </summary>
+        /// <param name="id">Id of the <see cref="IContent"/> object to delete versions from</param>
+        /// <param name="versionDate">Latest version date</param>
+        /// <param name="userId">Optional Id of the User deleting versions of a Content object</param>
+        public void DeleteVersions(int id, DateTime versionDate, int userId = 0)
+        {
+            using (var uow = UowProvider.GetUnitOfWork())
+            {
+                var deleteRevisionsEventArgs = new DeleteRevisionsEventArgs(id, dateToRetain: versionDate);
+                if (uow.Events.DispatchCancelable(DeletingVersions, this, deleteRevisionsEventArgs, "DeletingVersions"))
+                {
+                    uow.Commit();
+                    return;
+                }
+
+                var repository = RepositoryFactory.CreateContentRepository(uow);
+                repository.DeleteVersions(id, versionDate);
+                deleteRevisionsEventArgs.CanCancel = false;
+                uow.Events.Dispatch(DeletedVersions, this, deleteRevisionsEventArgs, "DeletedVersions");
+
+                Audit(uow, AuditType.Delete, "Delete Content by version date performed by user", userId, Constants.System.Root);
+                uow.Commit();
+            }
+        }
+
+        /// <summary>
+        /// Permanently deletes specific version(s) from an <see cref="IContent"/> object.
+        /// This method will never delete the latest version of a content item.
+        /// </summary>
+        /// <param name="id">Id of the <see cref="IContent"/> object to delete a version from</param>
+        /// <param name="versionId">Id of the version to delete</param>
+        /// <param name="deletePriorVersions">Boolean indicating whether to delete versions prior to the versionId</param>
+        /// <param name="userId">Optional Id of the User deleting versions of a Content object</param>
+        public void DeleteVersion(int id, Guid versionId, bool deletePriorVersions, int userId = 0)
+        {
+            using (new WriteLock(Locker))
+            {
+                using (var uow = UowProvider.GetUnitOfWork())
+                {
+                    if (uow.Events.DispatchCancelable(DeletingVersions, this, new DeleteRevisionsEventArgs(id, specificVersion: versionId), "DeletingVersions"))
+                    {
+                        uow.Commit();
+                        return;
+                    }
+
+                    if (deletePriorVersions)
+                    {
+                        var content = GetByVersion(versionId);
+                        DeleteVersions(id, content.UpdateDate, userId);
+                    }
+
+                    var repository = RepositoryFactory.CreateContentRepository(uow);
+                    repository.DeleteVersion(versionId);
+
+                    uow.Events.Dispatch(DeletedVersions, this, new DeleteRevisionsEventArgs(id, false, specificVersion: versionId), "DeletedVersions");
+
+                    Audit(uow, AuditType.Delete, "Delete Content by version performed by user", userId, Constants.System.Root);
+                    uow.Commit();
+                }
+            }
+        }
+
+        /// <summary>
+        /// Deletes an <see cref="IContent"/> object by moving it to the Recycle Bin
+        /// </summary>
+        /// <remarks>Move an item to the Recycle Bin will result in the item being unpublished</remarks>
+        /// <param name="content">The <see cref="IContent"/> to delete</param>
+        /// <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);
+        }
+
+        /// <summary>
+        /// Moves an <see cref="IContent"/> object to a new location by changing its parent id.
+        /// </summary>
+        /// <remarks>
+        /// If the <see cref="IContent"/> object is already published it will be
+        /// published after being moved to its new location. Otherwise it'll just
+        /// be saved with a new parent id.
+        /// </remarks>
+        /// <param name="content">The <see cref="IContent"/> to move</param>
+        /// <param name="parentId">Id of the Content's new Parent</param>
+        /// <param name="userId">Optional Id of the User moving the Content</param>
+        public void Move(IContent content, int parentId, int userId = 0)
+        {
+            using (new WriteLock(Locker))
+            {
+                //This ensures that the correct method is called if this method is used to Move to recycle bin.
+                if (parentId == Constants.System.RecycleBinContent)
+                {
+                    MoveToRecycleBin(content, userId);
+                    return;
+                }
+
+                using (var uow = UowProvider.GetUnitOfWork())
+                {
+                    var moveEventInfo = new MoveEventInfo<IContent>(content, content.Path, parentId);
+                    var moveEventArgs = new MoveEventArgs<IContent>(moveEventInfo);
+                    if (uow.Events.DispatchCancelable(Moving, this, moveEventArgs, "Moving"))
+                    {
+                        uow.Commit();
+                        return;
+                    }
+
+                    //used to track all the moved entities to be given to the event
+                    var moveInfo = new List<MoveEventInfo<IContent>>();
+
+                    //call private method that does the recursive moving
+                    PerformMove(content, parentId, userId, moveInfo);
+
+                    moveEventArgs.MoveInfoCollection = moveInfo;
+                    moveEventArgs.CanCancel = false;
+                    uow.Events.Dispatch(Moved, this, moveEventArgs, "Moved");
+
+                    Audit(uow, AuditType.Move, "Move Content performed by user", userId, content.Id);
+                    uow.Commit();
+                }
+            }
+        }
+
+        /// <summary>
+        /// Empties the Recycle Bin by deleting all <see cref="IContent"/> that resides in the bin
+        /// </summary>
+        [EditorBrowsable(EditorBrowsableState.Never)]
+        [Obsolete("Use EmptyRecycleBin with explicit indication of user ID instead")]
+        public void EmptyRecycleBin() => EmptyRecycleBin(0);
+
+        /// <summary>
+        /// Empties the Recycle Bin by deleting all <see cref="IContent"/> that resides in the bin
+        /// </summary>
+        /// <param name="userId">Optional Id of the User emptying the Recycle Bin</param>
+        public void EmptyRecycleBin(int userId = 0)
+        {
+            using (new WriteLock(Locker))
+            {
+                var nodeObjectType = Constants.ObjectTypes.DocumentGuid;
+
+                using (var uow = UowProvider.GetUnitOfWork())
+                {
+                    var repository = RepositoryFactory.CreateContentRepository(uow);
+
+                    //Create a dictionary of ids -> dictionary of property aliases + values
+                    var entities = repository.GetEntitiesInRecycleBin()
+                        .ToDictionary(
+                            key => key.Id,
+                            val => (IEnumerable<Property>)val.Properties);
+
+                    var files = ((ContentRepository)repository).GetFilesInRecycleBinForUploadField();
+
+                    var recycleBinEventArgs = new RecycleBinEventArgs(nodeObjectType, entities, files);
+                    if (uow.Events.DispatchCancelable(EmptyingRecycleBin, this, recycleBinEventArgs))
+                    {
+                        uow.Commit();
+                        return;
+                    }
+
+                    var success = repository.EmptyRecycleBin();
+                    recycleBinEventArgs.CanCancel = false;
+                    recycleBinEventArgs.RecycleBinEmptiedSuccessfully = success;
+                    uow.Events.Dispatch(EmptiedRecycleBin, this, recycleBinEventArgs);
+
+                    Audit(uow, AuditType.Delete, "Empty Content Recycle Bin performed by user", userId, Constants.System.RecycleBinContent);
+                    uow.Commit();
+                }
+            }
+        }
+
+        /// <summary>
+        /// Copies an <see cref="IContent"/> object by creating a new Content object of the same type and copies all data from the current
+        /// to the new copy which is returned. Recursively copies all children.
+        /// </summary>
+        /// <param name="content">The <see cref="IContent"/> to copy</param>
+        /// <param name="parentId">Id of the Content's new Parent</param>
+        /// <param name="relateToOriginal">Boolean indicating whether the copy should be related to the original</param>
+        /// <param name="userId">Optional Id of the User copying the Content</param>
+        /// <returns>The newly created <see cref="IContent"/> object</returns>
+        public IContent Copy(IContent content, int parentId, bool relateToOriginal, int userId = 0)
+        {
+            return Copy(content, parentId, relateToOriginal, true, userId);
+        }
+
+        /// <summary>
+        /// Copies an <see cref="IContent"/> object by creating a new Content object of the same type and copies all data from the current
+        /// to the new copy which is returned.
+        /// </summary>
+        /// <param name="content">The <see cref="IContent"/> to copy</param>
+        /// <param name="parentId">Id of the Content's new Parent</param>
+        /// <param name="relateToOriginal">Boolean indicating whether the copy should be related to the original</param>
+        /// <param name="recursive">A value indicating whether to recursively copy children.</param>
+        /// <param name="userId">Optional Id of the User copying the Content</param>
+        /// <returns>The newly created <see cref="IContent"/> object</returns>
+        public IContent Copy(IContent content, int parentId, bool relateToOriginal, bool recursive, int userId = 0)
+        {
+            //TODO: This all needs to be managed correctly so that the logic is submitted in one
+            // transaction, the CRUD needs to be moved to the repo
+
+            using (new WriteLock(Locker))
+            {
+                var copy = content.DeepCloneWithResetIdentities();
+                copy.ParentId = parentId;
+
+                // A copy should never be set to published automatically even if the original was.
+                copy.ChangePublishedState(PublishedState.Unpublished);
+
+                using (var uow = UowProvider.GetUnitOfWork())
+                {
+                    var copyEventArgs = new CopyEventArgs<IContent>(content, copy, true, parentId, relateToOriginal);
+                    if (uow.Events.DispatchCancelable(Copying, this, copyEventArgs))
+                    {
+                        uow.Commit();
+                        return null;
+                    }
+
+                    var repository = RepositoryFactory.CreateContentRepository(uow);
+
+                    // Update the create author and last edit author
+                    copy.CreatorId = userId;
+                    copy.WriterId = userId;
+
+                    //get the current permissions, if there are any explicit ones they need to be copied
+                    var currentPermissions = GetPermissionsForEntity(content);
+                    currentPermissions.RemoveWhere(p => p.IsDefaultPermissions);
+
+                    repository.AddOrUpdate(copy);
+                    repository.AddOrUpdatePreviewXml(copy, c => _entitySerializer.Serialize(this, _dataTypeService, _userService, c));
+
+                    //add permissions
+                    if (currentPermissions.Count > 0)
+                    {
+                        var permissionSet = new ContentPermissionSet(copy, currentPermissions);
+                        repository.AddOrUpdatePermissions(permissionSet);
+                    }
+
+                    uow.Commit(); // todo - this should flush, not commit
+
+                    //Special case for the associated tags
+                    //TODO: Move this to the repository layer in a single transaction!
+                    //don't copy tags data in tags table if the item is in the recycle bin
+                    if (parentId != Constants.System.RecycleBinContent)
+                    {
+                        var tags = uow.Database.Fetch<TagRelationshipDto>("WHERE nodeId = @Id", new { Id = content.Id });
+                        foreach (var tag in tags)
+                            uow.Database.Insert(new TagRelationshipDto
+                            {
+                                NodeId = copy.Id, TagId = tag.TagId, PropertyTypeId = tag.PropertyTypeId
+                            });
+                    }
+                    uow.Commit(); // todo - this should flush, not commit
+
+                    if (recursive)
+                    {
+                        //Look for children and copy those as well
+                        var children = GetChildren(content.Id);
+                        foreach (var child in children)
+                        {
+                            //TODO: This shouldn't recurse back to this method, it should be done in a private method
+                            // that doesn't have a nested lock and so we can perform the entire operation in one commit.
+                            Copy(child, copy.Id, relateToOriginal, true, userId);
+                        }
+                    }
+                    copyEventArgs.CanCancel = false;
+                    uow.Events.Dispatch(Copied, this, copyEventArgs);
+                    Audit(uow, AuditType.Copy, "Copy Content performed by user", userId, content.Id);
+                    uow.Commit();
+                }
+
+                return copy;
+            }
+        }
+
+
+        /// <summary>
+        /// Sends an <see cref="IContent"/> to Publication, which executes handlers and events for the 'Send to Publication' action.
+        /// </summary>
+        /// <param name="content">The <see cref="IContent"/> to send to publication</param>
+        /// <param name="userId">Optional Id of the User issueing the send to publication</param>
+        /// <returns>True if sending publication was succesfull otherwise false</returns>
+        public bool SendToPublication(IContent content, int userId = 0)
+        {
+            using (var uow = UowProvider.GetUnitOfWork())
+            {
+                var sendToPublishEventArgs = new SendToPublishEventArgs<IContent>(content);
+                if (uow.Events.DispatchCancelable(SendingToPublish, this, sendToPublishEventArgs))
+                {
+                    uow.Commit();
+                    return false;
+                }
+
+                //Save before raising event
+                Save(content, userId);
+                sendToPublishEventArgs.CanCancel = false;
+                uow.Events.Dispatch(SentToPublish, this, sendToPublishEventArgs);
+
+                Audit(uow, AuditType.SendToPublish, "Send to Publish performed by user", content.WriterId, content.Id);
+                uow.Commit();
+
+                return true;
+            }
+        }
+
+        /// <summary>
+        /// Rollback an <see cref="IContent"/> object to a previous version.
+        /// This will create a new version, which is a copy of all the old data.
+        /// </summary>
+        /// <remarks>
+        /// The way data is stored actually only allows us to rollback on properties
+        /// and not data like Name and Alias of the Content.
+        /// </remarks>
+        /// <param name="id">Id of the <see cref="IContent"/>being rolled back</param>
+        /// <param name="versionId">Id of the version to rollback to</param>
+        /// <param name="userId">Optional Id of the User issueing the rollback of the Content</param>
+        /// <returns>The newly created <see cref="IContent"/> object</returns>
+        public IContent Rollback(int id, Guid versionId, int userId = 0)
+        {
+            var content = GetByVersion(versionId);
+
+            using (var uow = UowProvider.GetUnitOfWork())
+            {
+                var rollbackEventArgs = new RollbackEventArgs<IContent>(content);
+                if (uow.Events.DispatchCancelable(RollingBack, this, rollbackEventArgs))
+                {
+                    uow.Commit();
+                    return content;
+                }
+
+                var repository = RepositoryFactory.CreateContentRepository(uow);
+
+                content.WriterId = userId;
+                content.CreatorId = userId;
+                content.ChangePublishedState(PublishedState.Unpublished);
+
+                repository.AddOrUpdate(content);
+                repository.AddOrUpdatePreviewXml(content, c => _entitySerializer.Serialize(this, _dataTypeService, _userService, c));
+                rollbackEventArgs.CanCancel = false;
+                uow.Events.Dispatch(RolledBack, this, rollbackEventArgs);
+
+                Audit(uow, AuditType.RollBack, "Content rollback performed by user", content.WriterId, content.Id);
+                uow.Commit();
+            }
+
+            return content;
+        }
+
+        /// <summary>
+        /// Sorts a collection of <see cref="IContent"/> objects by updating the SortOrder according
+        /// to the ordering of items in the passed in <see cref="IEnumerable{T}"/>.
+        /// </summary>
+        /// <remarks>
+        /// Using this method will ensure that the Published-state is maintained upon sorting
+        /// so the cache is updated accordingly - as needed.
+        /// </remarks>
+        /// <param name="items"></param>
+        /// <param name="userId"></param>
+        /// <param name="raiseEvents"></param>
+        /// <returns>True if sorting succeeded, otherwise False</returns>
+        public bool Sort(IEnumerable<IContent> items, int userId = 0, bool raiseEvents = true)
+        {
+            var shouldBePublished = new List<IContent>();
+            var shouldBeSaved = new List<IContent>();
+
+            using (new WriteLock(Locker))
+            {
+                using (var uow = UowProvider.GetUnitOfWork())
+                {
+                    var asArray = items.ToArray();
+                    var saveEventArgs = new SaveEventArgs<IContent>(asArray);
+                    if (raiseEvents && uow.Events.DispatchCancelable(Saving, this, saveEventArgs, "Saving"))
+                    {
+                        uow.Commit();
+                        return false;
+                    }
+
+                    var repository = RepositoryFactory.CreateContentRepository(uow);
+
+                    var i = 0;
+                    foreach (var content in asArray)
+                    {
+                        //If the current sort order equals that of the content
+                        //we don't need to update it, so just increment the sort order
+                        //and continue.
+                        if (content.SortOrder == i)
+                        {
+                            i++;
+                            continue;
+                        }
+
+                        content.SortOrder = i;
+                        content.WriterId = userId;
+                        i++;
+
+                        if (content.Published)
+                        {
+                            //TODO: This should not be an inner operation, but if we do this, it cannot raise events and cannot be cancellable!
+                            var published = _publishingStrategy.Publish(uow, content, userId).Success;
+                            shouldBePublished.Add(content);
+                        }
+                        else
+                            shouldBeSaved.Add(content);
+
+                        repository.AddOrUpdate(content);
+                        //add or update a preview
+                        repository.AddOrUpdatePreviewXml(content, c => _entitySerializer.Serialize(this, _dataTypeService, _userService, c));
+                    }
+
+                    foreach (var content in shouldBePublished)
+                    {
+                        //Create and Save ContentXml DTO
+                        repository.AddOrUpdateContentXml(content, c => _entitySerializer.Serialize(this, _dataTypeService, _userService, c));
+                    }
+
+                    if (raiseEvents)
+                    {
+                        saveEventArgs.CanCancel = false;
+                        uow.Events.Dispatch(Saved, this, saveEventArgs, "Saved");
+                    }
+
+                    if (shouldBePublished.Any())
+                    {
+                        //TODO: This should not be an inner operation, but if we do this, it cannot raise events and cannot be cancellable!
+                        _publishingStrategy.PublishingFinalized(uow, shouldBePublished, false);
+                    }
+
+                    Audit(uow, AuditType.Sort, "Sorting content performed by user", userId, 0);
+                    uow.Commit();
+                }
+            }
+
+            return true;
+        }
+
+        /// <summary>
+        /// Sorts a collection of <see cref="IContent"/> objects by updating the SortOrder according
+        /// to the ordering of node Ids passed in.
+        /// </summary>
+        /// <remarks>
+        /// Using this method will ensure that the Published-state is maintained upon sorting
+        /// so the cache is updated accordingly - as needed.
+        /// </remarks>
+        /// <param name="ids"></param>
+        /// <param name="userId"></param>
+        /// <param name="raiseEvents"></param>
+        /// <returns>True if sorting succeeded, otherwise False</returns>
+        public bool Sort(int[] ids, int userId = 0, bool raiseEvents = true)
+        {
+            var shouldBePublished = new List<IContent>();
+            var shouldBeSaved = new List<IContent>();
+
+            using (new WriteLock(Locker))
+            {
+                var allContent = GetByIds(ids).ToDictionary(x => x.Id, x => x);
+                if (allContent.Any() == false)
+                {
+                    return false;
+                }
+                var items = ids.Select(x => allContent[x]).ToArray();
+
+                using (var uow = UowProvider.GetUnitOfWork())
+                {
+                    var saveEventArgs = new SaveEventArgs<IContent>(items);
+                    if (raiseEvents && uow.Events.DispatchCancelable(Saving, this, saveEventArgs, "Saving"))
+                    {
+                        uow.Commit();
+                        return false;
+                    }
+
+                    var repository = RepositoryFactory.CreateContentRepository(uow);
+
+                    var i = 0;
+                    foreach (var content in items)
+                    {
+                        //If the current sort order equals that of the content
+                        //we don't need to update it, so just increment the sort order
+                        //and continue.
+                        if (content.SortOrder == i)
+                        {
+                            i++;
+                            continue;
+                        }
+
+                        content.SortOrder = i;
+                        content.WriterId = userId;
+                        i++;
+
+                        if (content.Published)
+                        {
+                            //TODO: This should not be an inner operation, but if we do this, it cannot raise events and cannot be cancellable!
+                            var published = _publishingStrategy.Publish(uow, content, userId).Success;
+                            shouldBePublished.Add(content);
+                        }
+                        else
+                            shouldBeSaved.Add(content);
+
+                        repository.AddOrUpdate(content);
+                        //add or update a preview
+                        repository.AddOrUpdatePreviewXml(content, c => _entitySerializer.Serialize(this, _dataTypeService, _userService, c));
+                    }
+
+                    foreach (var content in shouldBePublished)
+                    {
+                        //Create and Save ContentXml DTO
+                        repository.AddOrUpdateContentXml(content, c => _entitySerializer.Serialize(this, _dataTypeService, _userService, c));
+                    }
+
+                    if (raiseEvents)
+                    {
+                        saveEventArgs.CanCancel = false;
+                        uow.Events.Dispatch(Saved, this, saveEventArgs, "Saved");
+                    }
+
+                    if (shouldBePublished.Any())
+                    {
+                        //TODO: This should not be an inner operation, but if we do this, it cannot raise events and cannot be cancellable!
+                        _publishingStrategy.PublishingFinalized(uow, shouldBePublished, false);
+                    }
+
+                    Audit(uow, AuditType.Sort, "Sort child items performed by user", userId, items.First().ParentId);
+                    uow.Commit();
+                }
+            }
+
+            return true;
+        }
+
+        public IEnumerable<IContent> GetBlueprintsForContentTypes(params int[] documentTypeIds)
+        {
+            using (var uow = UowProvider.GetUnitOfWork(readOnly: true))
+            {
+                var repository = RepositoryFactory.CreateContentBlueprintRepository(uow);
+
+                var query = new Query<IContent>();
+                if (documentTypeIds.Length > 0)
+                {
+                    query.Where(x => documentTypeIds.Contains(x.ContentTypeId));
+                }
+                return repository.GetByQuery(query).Select(x =>
+                {
+                    ((Content) x).IsBlueprint = true;
+                    return x;
+                });
+            }
+        }
+
+        /// <summary>
+        /// Gets paged content descendants as XML by path
+        /// </summary>
+        /// <param name="path">Path starts with</param>
+        /// <param name="pageIndex">Page number</param>
+        /// <param name="pageSize">Page size</param>
+        /// <param name="totalRecords">Total records the query would return without paging</param>
+        /// <returns>A paged enumerable of XML entries of content items</returns>
+        public IEnumerable<XElement> GetPagedXmlEntries(string path, long pageIndex, int pageSize, out long totalRecords)
+        {
+            Mandate.ParameterCondition(pageIndex >= 0, "pageIndex");
+            Mandate.ParameterCondition(pageSize > 0, "pageSize");
+
+            using (var uow = UowProvider.GetUnitOfWork(readOnly: true))
+            {
+                var repository = RepositoryFactory.CreateContentRepository(uow);
+                var contents = repository.GetPagedXmlEntriesByPath(path, pageIndex, pageSize,
+                    //This order by is VERY important! This allows us to figure out what is implicitly not published, see ContentRepository.BuildXmlCache and
+                    // UmbracoContentIndexer.PerformIndexAll which uses the logic based on this sort order
+                    new[] { "level", "parentID", "sortOrder" },
+                    out totalRecords);
+                return contents;
+            }
+        }
+
+        /// <summary>
+        /// This builds the Xml document used for the XML cache
+        /// </summary>
+        /// <returns></returns>
+        public XmlDocument BuildXmlCache()
+        {
+            using (var uow = UowProvider.GetUnitOfWork())
+            {
+                var repository = RepositoryFactory.CreateContentRepository(uow);
+                var result = repository.BuildXmlCache();
+                uow.Commit();
+                return result;
+            }
+        }
+
+        public XmlDocument BuildPreviewXmlCache()
+        {
+            using (var uow = UowProvider.GetUnitOfWork())
+            {
+                var repository = RepositoryFactory.CreateContentRepository(uow);
+                var result = repository.BuildPreviewXmlCache();
+                uow.Commit();
+                return result;
+            }
+        }
+
+        /// <summary>
+        /// Rebuilds all xml content in the cmsContentXml table for all documents
+        /// </summary>
+        /// <param name="contentTypeIds">
+        /// Only rebuild the xml structures for the content type ids passed in, if none then rebuilds the structures
+        /// for all content
+        /// </param>
+        public void RebuildXmlStructures(params int[] contentTypeIds)
+        {
+            using (var uow = UowProvider.GetUnitOfWork())
+            {
+                var repository = RepositoryFactory.CreateContentRepository(uow);
+
+                repository.RebuildXmlStructures(
+                    content => _entitySerializer.Serialize(this, _dataTypeService, _userService, content),
+                    contentTypeIds: contentTypeIds.Length == 0 ? null : contentTypeIds);
+
+                Audit(uow, AuditType.Publish, "ContentService.RebuildXmlStructures completed, the xml has been regenerated in the database", 0, Constants.System.Root);
+                uow.Commit();
+            }
+        }
+
+        #region Internal Methods
+
+        /// <summary>
+        /// Gets a collection of <see cref="IContent"/> descendants by the first Parent.
+        /// </summary>
+        /// <param name="content"><see cref="IContent"/> item to retrieve Descendants from</param>
+        /// <returns>An Enumerable list of <see cref="IContent"/> objects</returns>
+        internal IEnumerable<IContent> GetPublishedDescendants(IContent content)
+        {
+            using (var uow = UowProvider.GetUnitOfWork(readOnly: true))
+            {
+                var repository = RepositoryFactory.CreateContentRepository(uow);
+
+                var query = Query<IContent>.Builder.Where(x => x.Id != content.Id && x.Path.StartsWith(content.Path) && x.Trashed == false);
+                return repository.GetByPublishedVersion(query);
+            }
+        }
+
+        #endregion
+
+        #region Private Methods
+
+        /// <summary>
+        /// Hack: This is used to fix some data if an entity's properties are invalid/corrupt
+        /// </summary>
+        /// <param name="content"></param>
+        private void QuickUpdate(IContent content)
+        {
+            if (content == null) throw new ArgumentNullException("content");
+            if (content.HasIdentity == false) throw new InvalidOperationException("Cannot update an entity without an Identity");
+
+            using (var uow = UowProvider.GetUnitOfWork())
+            {
+                var repository = RepositoryFactory.CreateContentRepository(uow);
+                repository.AddOrUpdate(content);
+                uow.Commit();
+            }
+        }
+
+        private void Audit(IScopeUnitOfWork uow, AuditType type, string message, int userId, int objectId)
+        {
+            var auditRepo = RepositoryFactory.CreateAuditRepository(uow);
+            auditRepo.AddOrUpdate(new AuditItem(objectId, message, type, userId));
+        }
+
+        //TODO: All of this needs to be moved to the repository
+        private void PerformMove(IContent content, int parentId, int userId, ICollection<MoveEventInfo<IContent>> moveInfo)
+        {
+            //add a tracking item to use in the Moved event
+            moveInfo.Add(new MoveEventInfo<IContent>(content, content.Path, parentId));
+
+            content.WriterId = userId;
+            if (parentId == Constants.System.Root)
+            {
+                content.Path = string.Concat(Constants.System.Root, ",", content.Id);
+                content.Level = 1;
+            }
+            else
+            {
+                var parent = GetById(parentId);
+                content.Path = string.Concat(parent.Path, ",", content.Id);
+                content.Level = parent.Level + 1;
+            }
+
+            //If Content is being moved away from Recycle Bin, its state should be un-trashed
+            if (content.Trashed && parentId != Constants.System.RecycleBinContent)
+            {
+                content.ChangeTrashedState(false, parentId);
+            }
+            else
+            {
+                content.ParentId = parentId;
+            }
+
+            //If Content is published, it should be (re)published from its new location
+            if (content.Published)
+            {
+                //If Content is Publishable its saved and published
+                //otherwise we save the content without changing the publish state, and generate new xml because the Path, Level and Parent has changed.
+                if (IsPublishable(content))
+                {
+                    //TODO: This is raising events, probably not desirable as this costs performance for event listeners like Examine
+                    SaveAndPublish(content, userId);
+                }
+                else
+                {
+                    //TODO: This is raising events, probably not desirable as this costs performance for event listeners like Examine
+                    Save(content, false, userId);
+
+                    //TODO: This shouldn't be here! This needs to be part of the repository logic but in order to fix this we need to
+                    // change how this method calls "Save" as it needs to save using an internal method
+                    using (var uow = UowProvider.GetUnitOfWork())
+                    {
+                        var xml = _entitySerializer.Serialize(this, _dataTypeService, _userService, content);
+
+                        var poco = new ContentXmlDto { NodeId = content.Id, Xml = xml.ToDataString() };
+                        var exists =
+                            uow.Database.FirstOrDefault<ContentXmlDto>("WHERE nodeId = @Id", new { Id = content.Id }) !=
+                            null;
+                        int result = exists
+                                         ? uow.Database.Update(poco)
+                                         : Convert.ToInt32(uow.Database.Insert(poco));
+                        uow.Commit();
+                    }
+                }
+            }
+            else
+            {
+                //TODO: This is raising events, probably not desirable as this costs performance for event listeners like Examine
+                Save(content, userId);
+            }
+
+            //Ensure that Path and Level is updated on children
+            var children = GetChildren(content.Id).ToArray();
+            if (children.Any())
+            {
+                foreach (var child in children)
+                {
+                    PerformMove(child, content.Id, userId, moveInfo);
+                }
+            }
+        }
+
+        /// <summary>
+        /// Publishes a <see cref="IContent"/> object and all its children
+        /// </summary>
+        /// <param name="content">The <see cref="IContent"/> to publish along with its children</param>
+        /// <param name="userId">Optional Id of the User issueing the publishing</param>
+        /// <param name="includeUnpublished">If set to true, this will also publish descendants that are completely unpublished, normally this will only publish children that have previously been published</param>
+        /// <returns>
+        /// A list of publish statues. If the parent document is not valid or cannot be published because it's parent(s) is not published
+        /// then the list will only contain one status item, otherwise it will contain status items for it and all of it's descendants that
+        /// are to be published.
+        /// </returns>
+        private IEnumerable<Attempt<PublishStatus>> PublishWithChildrenDo(
+            IContent content, int userId = 0, bool includeUnpublished = false)
+        {
+            if (content == null) throw new ArgumentNullException("content");
+
+            var evtMsgs = EventMessagesFactory.Get();
+
+            using (new WriteLock(Locker))
+            {
+                //Hack: this ensures that the entity's path is valid and if not it fixes/persists it
+                //see: http://issues.umbraco.org/issue/U4-9336
+                content.EnsureValidPath(Logger, entity => GetById(entity.ParentId), QuickUpdate);
+
+                var result = new List<Attempt<PublishStatus>>();
+
+                //Check if parent is published (although not if its a root node) - if parent isn't published this Content cannot be published
+                if (content.ParentId != Constants.System.Root && content.ParentId != Constants.System.RecycleBinContent && IsPublishable(content) == false)
+                {
+                    Logger.Info<ContentService>(
+                        string.Format(
+                            "Content '{0}' with Id '{1}' could not be published because its parent or one of its ancestors is not published.",
+                            content.Name, content.Id));
+                    result.Add(Attempt.Fail(new PublishStatus(content, PublishStatusType.FailedPathNotPublished, evtMsgs)));
+                    return result;
+                }
+
+                //Content contains invalid property values and can therefore not be published - fire event?
+                if (!content.IsValid())
+                {
+                    Logger.Info<ContentService>(
+                        string.Format("Content '{0}' with Id '{1}' could not be published because of invalid properties.",
+                                      content.Name, content.Id));
+                    result.Add(
+                        Attempt.Fail(
+                            new PublishStatus(content, PublishStatusType.FailedContentInvalid, evtMsgs)
+                            {
+                                InvalidProperties = ((ContentBase)content).LastInvalidProperties
+                            }));
+                    return result;
+                }
+
+                //Consider creating a Path query instead of recursive method:
+                //var query = Query<IContent>.Builder.Where(x => x.Path.StartsWith(content.Path));
+
+                var updated = new List<IContent>();
+                var list = new List<IContent>();
+                list.Add(content); //include parent item
+                list.AddRange(GetDescendants(content));
+
+                var internalStrategy = _publishingStrategy;
+
+                using (var uow = UowProvider.GetUnitOfWork())
+                {
+                    //Publish and then update the database with new status
+                    var publishedOutcome = internalStrategy.PublishWithChildren(uow, list, userId, includeUnpublished).ToArray();
+                    var published = publishedOutcome
+                        .Where(x => x.Success || x.Result.StatusType == PublishStatusType.SuccessAlreadyPublished)
+                        // ensure proper order (for events) - cannot publish a child before its parent!
+                        .OrderBy(x => x.Result.ContentItem.Level)
+                        .ThenBy(x => x.Result.ContentItem.SortOrder);
+
+                    var repository = RepositoryFactory.CreateContentRepository(uow);
+
+                    //NOTE The Publish with subpages-dialog was used more as a republish-type-thing, so we'll have to include PublishStatusType.SuccessAlreadyPublished
+                    //in the updated-list, so the Published event is triggered with the expected set of pages and the xml is updated.
+                    foreach (var item in published)
+                    {
+                        item.Result.ContentItem.WriterId = userId;
+                        repository.AddOrUpdate(item.Result.ContentItem);
+                        //add or update a preview
+                        repository.AddOrUpdatePreviewXml(item.Result.ContentItem, c => _entitySerializer.Serialize(this, _dataTypeService, _userService, c));
+                        //add or update the published xml
+                        repository.AddOrUpdateContentXml(item.Result.ContentItem, c => _entitySerializer.Serialize(this, _dataTypeService, _userService, c));
+                        updated.Add(item.Result.ContentItem);
+                    }
+
+                    //Save xml to db and call following method to fire event:
+                    _publishingStrategy.PublishingFinalized(uow, updated, false);
+
+                    Audit(uow, AuditType.Publish, "Publish with Children performed by user", userId, content.Id);
+                    uow.Commit();
+
+                    return publishedOutcome;
+                }
+            }
+        }
+
+        /// <summary>
+        /// UnPublishes a single <see cref="IContent"/> object
+        /// </summary>
+        /// <param name="content">The <see cref="IContent"/> to publish</param>
+        /// <param name="omitCacheRefresh">Optional boolean to avoid having the cache refreshed when calling this Unpublish method. By default this method will update the cache.</param>
+        /// <param name="userId">Optional Id of the User issueing the publishing</param>
+        /// <returns>True if unpublishing succeeded, otherwise False</returns>
+        private Attempt<UnPublishStatus> UnPublishDo(IContent content, bool omitCacheRefresh = false, int userId = 0)
+        {
+            var newest = GetById(content.Id); // ensure we have the newest version
+            if (content.Version != newest.Version) // but use the original object if it's already the newest version
+                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
+            }
+
+            using (var uow = UowProvider.GetUnitOfWork())
+            {
+                var unpublished = _publishingStrategy.UnPublish(uow, content, userId);
+                if (unpublished == false)
+                {
+                    uow.Commit();
+                    return Attempt.Fail(new UnPublishStatus(content, UnPublishedStatusType.FailedCancelledByEvent, evtMsgs));
+                }
+
+                var repository = RepositoryFactory.CreateContentRepository(uow);
+
+                content.WriterId = userId;
+                repository.AddOrUpdate(content);
+                // is published is not newest, reset the published flag on published version
+                if (published.Version != content.Version)
+                    repository.ClearPublished(published);
+                repository.DeleteContentXml(content);
+
+                //Delete xml from db? and call following method to fire event through PublishingStrategy to update cache
+                if (omitCacheRefresh == false)
+                    _publishingStrategy.UnPublishingFinalized(uow, content);
+
+                Audit(uow, AuditType.UnPublish, "UnPublish performed by user", userId, content.Id);
+                uow.Commit();
+            }
+
+            return Attempt.Succeed(new UnPublishStatus(content, UnPublishedStatusType.Success, evtMsgs));
+        }
+
+        /// <summary>
+        /// Saves and Publishes a single <see cref="IContent"/> object
+        /// </summary>
+        /// <param name="content">The <see cref="IContent"/> to save and publish</param>
+        /// <param name="userId">Optional Id of the User issueing the publishing</param>
+        /// <param name="raiseEvents">Optional boolean indicating whether or not to raise save events.</param>
+        /// <returns>True if publishing succeeded, otherwise False</returns>
+        private Attempt<PublishStatus> SaveAndPublishDo(IContent content, int userId = 0, bool raiseEvents = true)
+        {
+            var evtMsgs = EventMessagesFactory.Get();
+
+            using (new WriteLock(Locker))
+            {
+                using (var uow = UowProvider.GetUnitOfWork())
+                {
+                    var saveEventArgs = new SaveEventArgs<IContent>(content, evtMsgs);
+                    if (raiseEvents && uow.Events.DispatchCancelable(Saving, this, saveEventArgs, "Saving"))
+                    {
+                        uow.Commit();
+                        return Attempt.Fail(new PublishStatus(content, PublishStatusType.FailedCancelledByEvent, evtMsgs));
+                    }
+
+                    //Has this content item previously been published? If so, we don't need to refresh the children
+                    var previouslyPublished = content.HasIdentity && HasPublishedVersion(content.Id); //content might not have an id
+                    var publishStatus = new PublishStatus(content, PublishStatusType.Success, evtMsgs); //initially set to success
+
+                    //Check if parent is published (although not if its a root node) - if parent isn't published this Content cannot be published
+                    publishStatus.StatusType = CheckAndLogIsPublishable(content);
+                    //if it is not successful, then check if the props are valid
+                    if ((int)publishStatus.StatusType < 10)
+                    {
+                        //Content contains invalid property values and can therefore not be published - fire event?
+                        publishStatus.StatusType = CheckAndLogIsValid(content);
+                        //set the invalid properties (if there are any)
+                        publishStatus.InvalidProperties = ((ContentBase)content).LastInvalidProperties;
+                    }
+                    //if we're still successful, then publish using the strategy
+                    if (publishStatus.StatusType == PublishStatusType.Success)
+                    {
+                        //Publish and then update the database with new status
+                        var publishResult = _publishingStrategy.Publish(uow, content, userId);
+                        //set the status type to the publish result
+                        publishStatus.StatusType = publishResult.Result.StatusType;
+                    }
+
+                    //we are successfully published if our publishStatus is still Successful
+                    bool published = publishStatus.StatusType == PublishStatusType.Success;
+
+                    var repository = RepositoryFactory.CreateContentRepository(uow);
+
+                    if (published == false)
+                    {
+                        content.ChangePublishedState(PublishedState.Saved);
+                    }
+                    //Since this is the Save and Publish method, the content should be saved even though the publish fails or isn't allowed
+                    if (content.HasIdentity == false)
+                    {
+                        content.CreatorId = userId;
+                    }
+                    content.WriterId = userId;
+
+                    repository.AddOrUpdate(content);
+                    repository.AddOrUpdatePreviewXml(content, c => _entitySerializer.Serialize(this, _dataTypeService, _userService, c));
+
+                    if (published)
+                    {
+                        //Content Xml
+                        repository.AddOrUpdateContentXml(content, c => _entitySerializer.Serialize(this, _dataTypeService, _userService, c));
+                    }
+
+                    if (raiseEvents)
+                    {
+                        saveEventArgs.CanCancel = false;
+                        uow.Events.Dispatch(Saved, this, saveEventArgs, "Saved");
+                    }
+
+                    //Save xml to db and call following method to fire event through PublishingStrategy to update cache
+                    if (published)
+                    {
+                        _publishingStrategy.PublishingFinalized(uow, content);
+                    }
+
+                    //We need to check if children and their publish state to ensure that we 'republish' content that was previously published
+                    if (published && previouslyPublished == false && HasChildren(content.Id))
+                    {
+                    //TODO: Horrible for performance if there are lots of descendents! We should page if anything but this is crazy
+                        var descendants = GetPublishedDescendants(content);
+                        _publishingStrategy.PublishingFinalized(uow, descendants, false);
+                    }
+
+                    uow.Commit();
+
+                    if (publishStatus.StatusType == PublishStatusType.Success)
+                    {
+                        Audit(uow, AuditType.Publish, "Save and Publish performed by user", userId, content.Id);
+                    }
+                    else
+                    {
+                        Audit(uow, AuditType.Save, "Save performed by user", userId, content.Id);
+                    }
+                    uow.Commit();
+
+                    return Attempt.If(publishStatus.StatusType == PublishStatusType.Success, publishStatus);
+                }
+            }
+        }
+
+        /// <summary>
+        /// Saves a single <see cref="IContent"/> object
+        /// </summary>
+        /// <param name="content">The <see cref="IContent"/> to save</param>
+        /// <param name="changeState">Boolean indicating whether or not to change the Published state upon saving</param>
+        /// <param name="userId">Optional Id of the User saving the Content</param>
+        /// <param name="raiseEvents">Optional boolean indicating whether or not to raise events.</param>
+        private Attempt<OperationStatus> Save(IContent content, bool changeState, int userId = 0, bool raiseEvents = true)
+        {
+            var evtMsgs = EventMessagesFactory.Get();
+
+            using (new WriteLock(Locker))
+            {
+                var currVersion = content.Version;
+
+                using (var uow = UowProvider.GetUnitOfWork())
+                {
+                    var saveEventArgs = new SaveEventArgs<IContent>(content, evtMsgs);
+                    if (raiseEvents && uow.Events.DispatchCancelable(Saving, this, saveEventArgs, "Saving"))
+                    {
+                        uow.Commit();
+                        return OperationStatus.Cancelled(evtMsgs);
+                    }
+
+                    if (string.IsNullOrWhiteSpace(content.Name))
+                    {
+                        throw new ArgumentException("Cannot save content with empty name.");
+                    }
+
+                    var repository = RepositoryFactory.CreateContentRepository(uow);
+
+                    if (content.HasIdentity == false)
+                    {
+                        content.CreatorId = userId;
+                    }
+                    content.WriterId = userId;
+
+                    //Only change the publish state if the "previous" version was actually published or marked as unpublished
+                    if (changeState && (content.Published || ((Content)content).PublishedState == PublishedState.Unpublished))
+                        content.ChangePublishedState(PublishedState.Saved);
+
+                    repository.AddOrUpdate(content);
+
+                    //Generate a new preview
+                    repository.AddOrUpdatePreviewXml(content, c => _entitySerializer.Serialize(this, _dataTypeService, _userService, c));
+
+                    if (raiseEvents)
+                    {
+                        saveEventArgs.CanCancel = false;
+                        uow.Events.Dispatch(Saved, this, saveEventArgs, "Saved");
+                    }
+
+                    Audit(uow, AuditType.Save, "Save Content performed by user", userId, content.Id);
+                    uow.Commit();
+                }
+
+                return currVersion == content.Version
+                    ? OperationStatus.NoOperation(evtMsgs)
+                    : OperationStatus.Success(evtMsgs);
+            }
+        }
+
+        private PublishStatusType CheckAndLogIsPublishable(IContent content)
+        {
+            //Check if parent is published (although not if its a root node) - if parent isn't published this Content cannot be published
+            if (content.ParentId != Constants.System.Root && content.ParentId != Constants.System.RecycleBinContent && IsPublishable(content) == false)
+            {
+                Logger.Info<ContentService>(
+                    string.Format(
+                        "Content '{0}' with Id '{1}' could not be published because its parent is not published.",
+                        content.Name, content.Id));
+                return PublishStatusType.FailedPathNotPublished;
+            }
+
+            if (content.ExpireDate.HasValue && content.ExpireDate.Value > DateTime.MinValue && DateTime.Now > content.ExpireDate.Value)
+            {
+                Logger.Info<ContentService>(
+                    string.Format(
+                        "Content '{0}' with Id '{1}' has expired and could not be published.",
+                        content.Name, content.Id));
+                return PublishStatusType.FailedHasExpired;
+            }
+
+            if (content.ReleaseDate.HasValue && content.ReleaseDate.Value > DateTime.MinValue && content.ReleaseDate.Value > DateTime.Now)
+            {
+                Logger.Info<ContentService>(
+                    string.Format(
+                        "Content '{0}' with Id '{1}' is awaiting release and could not be published.",
+                        content.Name, content.Id));
+                return PublishStatusType.FailedAwaitingRelease;
+            }
+
+            return PublishStatusType.Success;
+        }
+
+        private PublishStatusType CheckAndLogIsValid(IContent content)
+        {
+            //Content contains invalid property values and can therefore not be published - fire event?
+            if (content.IsValid() == false)
+            {
+                Logger.Info<ContentService>(
+                    string.Format(
+                        "Content '{0}' with Id '{1}' could not be published because of invalid properties.",
+                        content.Name, content.Id));
+                return PublishStatusType.FailedContentInvalid;
+            }
+
+            return PublishStatusType.Success;
+        }
+
+        private IContentType FindContentTypeByAlias(string contentTypeAlias)
+        {
+            using (var uow = UowProvider.GetUnitOfWork(readOnly: true))
+            {
+                var repository = RepositoryFactory.CreateContentTypeRepository(uow);
+
+                var query = Query<IContentType>.Builder.Where(x => x.Alias == contentTypeAlias);
+                var types = repository.GetByQuery(query);
+
+                if (types.Any() == false)
+                    throw new Exception(
+                        string.Format("No ContentType matching the passed in Alias: '{0}' was found",
+                                      contentTypeAlias));
+
+                var contentType = types.First();
+
+                if (contentType == null)
+                    throw new Exception(string.Format("ContentType matching the passed in Alias: '{0}' was null",
+                                                      contentTypeAlias));
+                return contentType;
+            }
+        }
+
+        #endregion
+
+        #region Proxy Event Handlers
+        /// <summary>
+        /// Occurs before publish.
+        /// </summary>
+        /// <remarks>Proxy to the real event on the <see cref="PublishingStrategy"/></remarks>
+        public static event TypedEventHandler<IPublishingStrategy, PublishEventArgs<IContent>> Publishing
+        {
+            add { PublishingStrategy.Publishing += value; }
+            remove { PublishingStrategy.Publishing -= value; }
+        }
+
+        /// <summary>
+        /// Occurs after publish.
+        /// </summary>
+        /// <remarks>Proxy to the real event on the <see cref="PublishingStrategy"/></remarks>
+        public static event TypedEventHandler<IPublishingStrategy, PublishEventArgs<IContent>> Published
+        {
+            add { PublishingStrategy.Published += value; }
+            remove { PublishingStrategy.Published -= value; }
+        }
+        /// <summary>
+        /// Occurs before unpublish.
+        /// </summary>
+        /// <remarks>Proxy to the real event on the <see cref="PublishingStrategy"/></remarks>
+        public static event TypedEventHandler<IPublishingStrategy, PublishEventArgs<IContent>> UnPublishing
+        {
+            add { PublishingStrategy.UnPublishing += value; }
+            remove { PublishingStrategy.UnPublishing -= value; }
+        }
+
+        /// <summary>
+        /// Occurs after unpublish.
+        /// </summary>
+        /// <remarks>Proxy to the real event on the <see cref="PublishingStrategy"/></remarks>
+        public static event TypedEventHandler<IPublishingStrategy, PublishEventArgs<IContent>> UnPublished
+        {
+            add { PublishingStrategy.UnPublished += value; }
+            remove { PublishingStrategy.UnPublished -= value; }
+        }
+        #endregion
+
+        #region Event Handlers
+        /// <summary>
+        /// Occurs before Delete
+        /// </summary>
+        public static event TypedEventHandler<IContentService, DeleteEventArgs<IContent>> Deleting;
+
+        /// <summary>
+        /// Occurs after Delete
+        /// </summary>
+        public static event TypedEventHandler<IContentService, DeleteEventArgs<IContent>> Deleted;
+
+        /// <summary>
+        /// Occurs before Delete Versions
+        /// </summary>
+        public static event TypedEventHandler<IContentService, DeleteRevisionsEventArgs> DeletingVersions;
+
+        /// <summary>
+        /// Occurs after Delete Versions
+        /// </summary>
+        public static event TypedEventHandler<IContentService, DeleteRevisionsEventArgs> DeletedVersions;
+
+        /// <summary>
+        /// Occurs before Save
+        /// </summary>
+        public static event TypedEventHandler<IContentService, SaveEventArgs<IContent>> Saving;
+
+        /// <summary>
+        /// Occurs after Save
+        /// </summary>
+        public static event TypedEventHandler<IContentService, SaveEventArgs<IContent>> Saved;
+
+        /// <summary>
+        /// Occurs before Create
+        /// </summary>
+        [Obsolete("Use the Created event instead, the Creating and Created events both offer the same functionality, Creating event has been deprecated.")]
+        public static event TypedEventHandler<IContentService, NewEventArgs<IContent>> Creating;
+
+        /// <summary>
+        /// Occurs after Create
+        /// </summary>
+        /// <remarks>
+        /// Please note that the Content object has been created, but might not have been saved
+        /// so it does not have an identity yet (meaning no Id has been set).
+        /// </remarks>
+        public static event TypedEventHandler<IContentService, NewEventArgs<IContent>> Created;
+
+        /// <summary>
+        /// Occurs before Copy
+        /// </summary>
+        public static event TypedEventHandler<IContentService, CopyEventArgs<IContent>> Copying;
+
+        /// <summary>
+        /// Occurs after Copy
+        /// </summary>
+        public static event TypedEventHandler<IContentService, CopyEventArgs<IContent>> Copied;
+
+        /// <summary>
+        /// Occurs before Content is moved to Recycle Bin
+        /// </summary>
+        public static event TypedEventHandler<IContentService, MoveEventArgs<IContent>> Trashing;
+
+        /// <summary>
+        /// Occurs after Content is moved to Recycle Bin
+        /// </summary>
+        public static event TypedEventHandler<IContentService, MoveEventArgs<IContent>> Trashed;
+
+        /// <summary>
+        /// Occurs before Move
+        /// </summary>
+        public static event TypedEventHandler<IContentService, MoveEventArgs<IContent>> Moving;
+
+        /// <summary>
+        /// Occurs after Move
+        /// </summary>
+        public static event TypedEventHandler<IContentService, MoveEventArgs<IContent>> Moved;
+
+        /// <summary>
+        /// Occurs before Rollback
+        /// </summary>
+        public static event TypedEventHandler<IContentService, RollbackEventArgs<IContent>> RollingBack;
+
+        /// <summary>
+        /// Occurs after Rollback
+        /// </summary>
+        public static event TypedEventHandler<IContentService, RollbackEventArgs<IContent>> RolledBack;
+
+        /// <summary>
+        /// Occurs before Send to Publish
+        /// </summary>
+        public static event TypedEventHandler<IContentService, SendToPublishEventArgs<IContent>> SendingToPublish;
+
+        /// <summary>
+        /// Occurs after Send to Publish
+        /// </summary>
+        public static event TypedEventHandler<IContentService, SendToPublishEventArgs<IContent>> SentToPublish;
+
+        /// <summary>
+        /// Occurs before the Recycle Bin is emptied
+        /// </summary>
+        public static event TypedEventHandler<IContentService, RecycleBinEventArgs> EmptyingRecycleBin;
+
+        /// <summary>
+        /// Occurs after the Recycle Bin has been Emptied
+        /// </summary>
+        public static event TypedEventHandler<IContentService, RecycleBinEventArgs> EmptiedRecycleBin;
+
+        /// <summary>
+        /// Occurs after a blueprint has been saved.
+        /// </summary>
+        public static event TypedEventHandler<IContentService, SaveEventArgs<IContent>> SavedBlueprint;
+
+        /// <summary>
+        /// Occurs after a blueprint has been deleted.
+        /// </summary>
+        public static event TypedEventHandler<IContentService, DeleteEventArgs<IContent>> DeletedBlueprint;
+
+        #endregion
+    }
+}
diff --git a/src/Umbraco.Web/Editors/ContentController.cs b/src/Umbraco.Web/Editors/ContentController.cs
index 1ac8318f9c..8bb7af0077 100644
--- a/src/Umbraco.Web/Editors/ContentController.cs
+++ b/src/Umbraco.Web/Editors/ContentController.cs
@@ -1,1219 +1,1223 @@
-using System;
-using System.Collections.Generic;
-using System.Globalization;
-using System.IO;
-using System.Linq;
-using System.Net;
-using System.Net.Http;
-using System.Text;
-using System.Web.Http;
-using System.Web.Http.Controllers;
-using System.Web.Http.ModelBinding;
-using AutoMapper;
-using Umbraco.Core;
-using Umbraco.Core.Logging;
-using Umbraco.Core.Models;
-using Umbraco.Core.Models.Membership;
-using Umbraco.Core.Persistence.DatabaseModelDefinitions;
-using Umbraco.Core.Publishing;
-using Umbraco.Core.Services;
-using Umbraco.Web.Models.ContentEditing;
-using Umbraco.Web.Models.Mapping;
-using Umbraco.Web.Mvc;
-using Umbraco.Web.WebApi;
-using Umbraco.Web.WebApi.Binders;
-using Umbraco.Web.WebApi.Filters;
-using Umbraco.Core.Events;
-using Constants = Umbraco.Core.Constants;
-using umbraco.cms.businesslogic;
-using System.Collections;
-using umbraco;
-
-namespace Umbraco.Web.Editors
-{
-    /// <summary>
-    /// The API controller used for editing content
-    /// </summary>
-    /// <remarks>
-    /// This controller is decorated with the UmbracoApplicationAuthorizeAttribute which means that any user requesting
-    /// access to ALL of the methods on this controller will need access to the content application.
-    /// </remarks>
-    [PluginController("UmbracoApi")]
-    [UmbracoApplicationAuthorize(Constants.Applications.Content)]
-    [ContentControllerConfiguration]
-    public class ContentController : ContentControllerBase
-    {
-        /// <summary>
-        /// Constructor
-        /// </summary>
-        public ContentController()
-                : this(UmbracoContext.Current)
-        {
-        }
-
-        /// <summary>
-        /// Constructor
-        /// </summary>
-        /// <param name="umbracoContext"></param>
-        public ContentController(UmbracoContext umbracoContext)
-                : base(umbracoContext)
-        {
-        }
-
-        /// <summary>
-        /// Configures this controller with a custom action selector
-        /// </summary>
-        private class ContentControllerConfigurationAttribute : Attribute, IControllerConfiguration
-        {
-            public void Initialize(HttpControllerSettings controllerSettings, HttpControllerDescriptor controllerDescriptor)
-            {
-                controllerSettings.Services.Replace(typeof(IHttpActionSelector), new ParameterSwapControllerActionSelector(
-                    new ParameterSwapControllerActionSelector.ParameterSwapInfo("GetNiceUrl", "id", typeof(int), typeof(Guid), typeof(Udi)),
-                    new ParameterSwapControllerActionSelector.ParameterSwapInfo("GetById", "id", typeof(int), typeof(Guid), typeof(Udi))
-                ));
-            }
-        }
-
-        /// <summary>
-        /// Return content for the specified ids
-        /// </summary>
-        /// <param name="ids"></param>
-        /// <returns></returns>
-        [FilterAllowedOutgoingContent(typeof(IEnumerable<ContentItemDisplay>))]
-        public IEnumerable<ContentItemDisplay> GetByIds([FromUri]int[] ids)
-        {
-            var foundContent = Services.ContentService.GetByIds(ids);
-            return foundContent.Select(content => AutoMapperExtensions.MapWithUmbracoContext<IContent, ContentItemDisplay>(content, UmbracoContext));
-        }
-
-        /// <summary>
-        /// Updates the permissions for a content item for a particular user group
-        /// </summary>
-        /// <param name="saveModel"></param>
-        /// <returns></returns>
-        /// <remarks>
-        /// Permission check is done for letter 'R' which is for <see cref="ActionRights"/> which the user must have access to to update
-        /// </remarks>
-        [EnsureUserPermissionForContent("saveModel.ContentId", 'R')]
-        public IEnumerable<AssignedUserGroupPermissions> PostSaveUserGroupPermissions(UserGroupPermissionsSave saveModel)
-        {
-            if (saveModel.ContentId <= 0) throw new HttpResponseException(Request.CreateResponse(HttpStatusCode.NotFound));
-
-            //TODO: Should non-admins be alowed to set granular permissions?
-
-            var content = Services.ContentService.GetById(saveModel.ContentId);
-            if (content == null) throw new HttpResponseException(Request.CreateResponse(HttpStatusCode.NotFound));
-
-            //current permissions explicitly assigned to this content item
-            var contentPermissions = Services.ContentService.GetPermissionsForEntity(content)
-                .ToDictionary(x => x.UserGroupId, x => x);
-
-            var allUserGroups = Services.UserService.GetAllUserGroups().ToArray();
-
-            //loop through each user group
-            foreach (var userGroup in allUserGroups)
-            {
-                //check if there's a permission set posted up for this user group
-                IEnumerable<string> groupPermissions;
-                if (saveModel.AssignedPermissions.TryGetValue(userGroup.Id, out groupPermissions))
-                {
-                    //create a string collection of the assigned letters
-                    var groupPermissionCodes = groupPermissions.ToArray();
-
-                    //check if there are no permissions assigned for this group save model, if that is the case we want to reset the permissions
-                    //for this group/node which will go back to the defaults
-                    if (groupPermissionCodes.Length == 0)
-                    {
-                        Services.UserService.RemoveUserGroupPermissions(userGroup.Id, content.Id);
-                    }
-                    //check if they are the defaults, if so we should just remove them if they exist since it's more overhead having them stored
-                    else if (userGroup.Permissions.UnsortedSequenceEqual(groupPermissionCodes))
-                    {
-                        //only remove them if they are actually currently assigned
-                        if (contentPermissions.ContainsKey(userGroup.Id))
-                        {
-                            //remove these permissions from this node for this group since the ones being assigned are the same as the defaults
-                            Services.UserService.RemoveUserGroupPermissions(userGroup.Id, content.Id);
-                        }
-                    }
-                    //if they are different we need to update, otherwise there's nothing to update
-                    else if (contentPermissions.ContainsKey(userGroup.Id) == false || contentPermissions[userGroup.Id].AssignedPermissions.UnsortedSequenceEqual(groupPermissionCodes) == false)
-                    {
-
-                        Services.UserService.ReplaceUserGroupPermissions(userGroup.Id, groupPermissionCodes.Select(x => x[0]), content.Id);
-                    }
-                }
-            }
-
-            return GetDetailedPermissions(content, allUserGroups);
-        }
-
-        /// <summary>
-        /// Returns the user group permissions for user groups assigned to this node
-        /// </summary>
-        /// <param name="contentId"></param>
-        /// <returns></returns>
-        /// <remarks>
-        /// Permission check is done for letter 'R' which is for <see cref="ActionRights"/> which the user must have access to to view
-        /// </remarks>
-        [EnsureUserPermissionForContent("contentId", 'R')]
-        public IEnumerable<AssignedUserGroupPermissions> GetDetailedPermissions(int contentId)
-        {
-            if (contentId <= 0) throw new HttpResponseException(Request.CreateResponse(HttpStatusCode.NotFound));
-            var content = Services.ContentService.GetById(contentId);
-            if (content == null) throw new HttpResponseException(Request.CreateResponse(HttpStatusCode.NotFound));
-
-            //TODO: Should non-admins be able to see detailed permissions?
-
-            var allUserGroups = Services.UserService.GetAllUserGroups();
-
-            return GetDetailedPermissions(content, allUserGroups);
-        }
-
-        private IEnumerable<AssignedUserGroupPermissions> GetDetailedPermissions(IContent content, IEnumerable<IUserGroup> allUserGroups)
-        {
-            //get all user groups and map their default permissions to the AssignedUserGroupPermissions model.
-            //we do this because not all groups will have true assigned permissions for this node so if they don't have assigned permissions, we need to show the defaults.
-
-            var defaultPermissionsByGroup = Mapper.Map<IEnumerable<AssignedUserGroupPermissions>>(allUserGroups).ToArray();
-
-            var defaultPermissionsAsDictionary = defaultPermissionsByGroup
-                .ToDictionary(x => Convert.ToInt32(x.Id), x => x);
-
-            //get the actual assigned permissions
-            var assignedPermissionsByGroup = Services.ContentService.GetPermissionsForEntity(content).ToArray();
-
-            //iterate over assigned and update the defaults with the real values
-            foreach (var assignedGroupPermission in assignedPermissionsByGroup)
-            {
-                var defaultUserGroupPermissions = defaultPermissionsAsDictionary[assignedGroupPermission.UserGroupId];
-
-                //clone the default permissions model to the assigned ones
-                defaultUserGroupPermissions.AssignedPermissions = AssignedUserGroupPermissions.ClonePermissions(defaultUserGroupPermissions.DefaultPermissions);
-
-                //since there is custom permissions assigned to this node for this group, we need to clear all of the default permissions
-                //and we'll re-check it if it's one of the explicitly assigned ones
-                foreach (var permission in defaultUserGroupPermissions.AssignedPermissions.SelectMany(x => x.Value))
-                {
-                    permission.Checked = false;
-                    permission.Checked = assignedGroupPermission.AssignedPermissions.Contains(permission.PermissionCode, StringComparer.InvariantCulture);
-                }
-
-            }
-
-            return defaultPermissionsByGroup;
-        }
-
-        /// <summary>
-        /// Returns an item to be used to display the recycle bin for content
-        /// </summary>
-        /// <returns></returns>
-        public ContentItemDisplay GetRecycleBin()
-        {
-            var display = new ContentItemDisplay
-            {
-                Id = Constants.System.RecycleBinContent,
-                Alias = "recycleBin",
-                ParentId = -1,
-                Name = Services.TextService.Localize("general/recycleBin"),
-                ContentTypeAlias = "recycleBin",
-                CreateDate = DateTime.Now,
-                IsContainer = true,
-                Path = "-1," + Constants.System.RecycleBinContent
-            };
-
-            TabsAndPropertiesResolver<IContent>.AddListView(display, "content", Services.DataTypeService, Services.TextService);
-
-            return display;
-        }
-
-        public ContentItemDisplay GetBlueprintById(int id)
-        {
-            var foundContent = Services.ContentService.GetBlueprintById(id);
-            if (foundContent == null)
-            {
-                HandleContentNotFound(id);
-            }
-
-            var content = AutoMapperExtensions.MapWithUmbracoContext<IContent, ContentItemDisplay>(foundContent, UmbracoContext);
-
-            SetupBlueprint(content, foundContent);
-
-            return content;
-        }
-
-        private static void SetupBlueprint(ContentItemDisplay content, IContent persistedContent)
-        {
-            content.AllowPreview = false;
-
-            //set a custom path since the tree that renders this has the content type id as the parent
-            content.Path = string.Format("-1,{0},{1}", persistedContent.ContentTypeId, content.Id);
-
-            content.AllowedActions = new[] { "A" };
-            content.IsBlueprint = true;
-
-            var excludeProps = new[] { "_umb_urls", "_umb_releasedate", "_umb_expiredate", "_umb_template" };
-            var propsTab = content.Tabs.Last();
-            propsTab.Properties = propsTab.Properties
-                .Where(p => excludeProps.Contains(p.Alias) == false);
-        }
-
-        /// <summary>
-        /// Gets the content json for the content id
-        /// </summary>
-        /// <param name="id"></param>
-        /// <returns></returns>
-        [OutgoingEditorModelEvent]
-        [EnsureUserPermissionForContent("id")]
-        public ContentItemDisplay GetById(int id)
-        {
-            var foundContent = GetObjectFromRequest(() => Services.ContentService.GetById(id));
-            if (foundContent == null)
-            {
-                HandleContentNotFound(id);
-            }
-
-            var content = AutoMapperExtensions.MapWithUmbracoContext<IContent, ContentItemDisplay>(foundContent, UmbracoContext);
-            return content;
-        }
-
-        /// <summary>
-        /// Gets the content json for the content id
-        /// </summary>
-        /// <param name="id"></param>
-        /// <returns></returns>
-        [OutgoingEditorModelEvent]
-        [EnsureUserPermissionForContent("id")]
-        public ContentItemDisplay GetById(Guid id)
-        {
-            var foundContent = GetObjectFromRequest(() => Services.ContentService.GetById(id));
-            if (foundContent == null)
-            {
-                HandleContentNotFound(id);
-            }
-
-            var content = AutoMapperExtensions.MapWithUmbracoContext<IContent, ContentItemDisplay>(foundContent, UmbracoContext);
-            return content;
-        }
-
-        /// <summary>
-        /// Gets the content json for the content id
-        /// </summary>
-        /// <param name="id"></param>
-        /// <returns></returns>
-        [OutgoingEditorModelEvent]
-        [EnsureUserPermissionForContent("id")]
-        public ContentItemDisplay GetById(Udi id)
-        {
-            var guidUdi = id as GuidUdi;
-            if (guidUdi != null)
-            {
-                return GetById(guidUdi.Guid);
-            }
-
-            throw new HttpResponseException(HttpStatusCode.NotFound);
-        }
-
-        [EnsureUserPermissionForContent("id")]
-        public ContentItemDisplay GetWithTreeDefinition(int id)
-        {
-            var foundContent = GetObjectFromRequest(() => Services.ContentService.GetById(id));
-            if (foundContent == null)
-            {
-                HandleContentNotFound(id);
-            }
-
-            var content = AutoMapperExtensions.MapWithUmbracoContext<IContent, ContentItemDisplay>(foundContent, UmbracoContext);
-            return content;
-        }
-
-        /// <summary>
-        /// Gets an empty content item for the
-        /// </summary>
-        /// <param name="contentTypeAlias"></param>
-        /// <param name="parentId"></param>
-        /// <returns>
-        /// If this is a container type, we'll remove the umbContainerView tab for a new item since
-        /// it cannot actually list children if it doesn't exist yet.
-        /// </returns>
-        [OutgoingEditorModelEvent]
-        public ContentItemDisplay GetEmpty(string contentTypeAlias, int parentId)
-        {
-            var contentType = Services.ContentTypeService.GetContentType(contentTypeAlias);
-            if (contentType == null)
-            {
-                throw new HttpResponseException(HttpStatusCode.NotFound);
-            }
-
-            var emptyContent = Services.ContentService.CreateContent("", parentId, contentType.Alias, UmbracoUser.Id);
-            var mapped = AutoMapperExtensions.MapWithUmbracoContext<IContent, ContentItemDisplay>(emptyContent, UmbracoContext);
-            // translate the content type name if applicable
-            mapped.ContentTypeName = Services.TextService.UmbracoDictionaryTranslate(mapped.ContentTypeName);
-            // if your user type doesn't have access to the Settings section it would not get this property mapped
-            if(mapped.DocumentType != null)
-                mapped.DocumentType.Name = Services.TextService.UmbracoDictionaryTranslate(mapped.DocumentType.Name);
-
-            //remove this tab if it exists: umbContainerView
-            var containerTab = mapped.Tabs.FirstOrDefault(x => x.Alias == Constants.Conventions.PropertyGroups.ListViewGroupName);
-            mapped.Tabs = mapped.Tabs.Except(new[] { containerTab });
-            return mapped;
-        }
-
-        [OutgoingEditorModelEvent]
-        public ContentItemDisplay GetEmpty(int blueprintId, int parentId)
-        {
-            var blueprint = Services.ContentService.GetBlueprintById(blueprintId);
-            if (blueprint == null)
-            {
-                throw new HttpResponseException(HttpStatusCode.NotFound);
-            }
-
-            blueprint.Id = 0;
-            blueprint.Name = string.Empty;
-            blueprint.ParentId = parentId;
-
-            var mapped = Mapper.Map<ContentItemDisplay>(blueprint);
-
-            //remove this tab if it exists: umbContainerView
-            var containerTab = mapped.Tabs.FirstOrDefault(x => x.Alias == Constants.Conventions.PropertyGroups.ListViewGroupName);
-            mapped.Tabs = mapped.Tabs.Except(new[] { containerTab });
-            return mapped;
-        }
-
-        /// <summary>
-        /// Gets the Url for a given node ID
-        /// </summary>
-        /// <param name="id"></param>
-        /// <returns></returns>
-        public HttpResponseMessage GetNiceUrl(int id)
-        {
-            var url = Umbraco.NiceUrl(id);
-            var response = Request.CreateResponse(HttpStatusCode.OK);
-            response.Content = new StringContent(url, Encoding.UTF8, "application/json");
-            return response;
-        }
-
-        /// <summary>
-        /// Gets the Url for a given node ID
-        /// </summary>
-        /// <param name="id"></param>
-        /// <returns></returns>
-        public HttpResponseMessage GetNiceUrl(Guid id)
-        {
-            var url = Umbraco.UrlProvider.GetUrl(id);
-            var response = Request.CreateResponse(HttpStatusCode.OK);
-            response.Content = new StringContent(url, Encoding.UTF8, "application/json");
-            return response;
-        }
-
-        /// <summary>
-        /// Gets the Url for a given node ID
-        /// </summary>
-        /// <param name="id"></param>
-        /// <returns></returns>
-        public HttpResponseMessage GetNiceUrl(Udi id)
-        {
-            var guidUdi = id as GuidUdi;
-            if (guidUdi != null)
-            {
-                return GetNiceUrl(guidUdi.Guid);
-            }
-            throw new HttpResponseException(HttpStatusCode.NotFound);
-        }
-
-        /// <summary>
-        /// Gets the children for the content id passed in
-        /// </summary>
-        /// <returns></returns>
-        [FilterAllowedOutgoingContent(typeof(IEnumerable<ContentItemBasic<ContentPropertyBasic, IContent>>), "Items")]
-        public PagedResult<ContentItemBasic<ContentPropertyBasic, IContent>> GetChildren(
-                int id,
-                int pageNumber = 0,  //TODO: This should be '1' as it's not the index
-                int pageSize = 0,
-                string orderBy = "SortOrder",
-                Direction orderDirection = Direction.Ascending,
-                bool orderBySystemField = true,
-                string filter = "")
-        {
-            return GetChildren(id, null, pageNumber, pageSize, orderBy, orderDirection, orderBySystemField, filter);
-        }
-
-        /// <summary>
-        /// Gets the children for the content id passed in
-        /// </summary>
-        /// <returns></returns>
-        [FilterAllowedOutgoingContent(typeof(IEnumerable<ContentItemBasic<ContentPropertyBasic, IContent>>), "Items")]
-        public PagedResult<ContentItemBasic<ContentPropertyBasic, IContent>> GetChildren(
-                int id,
-                string includeProperties,
-                int pageNumber = 0,  //TODO: This should be '1' as it's not the index
-                int pageSize = 0,
-                string orderBy = "SortOrder",
-                Direction orderDirection = Direction.Ascending,
-                bool orderBySystemField = true,
-                string filter = "")
-        {
-            long totalChildren;
-            IContent[] children;
-            if (pageNumber > 0 && pageSize > 0)
-            {
-                children = Services.ContentService
-                 .GetPagedChildren(id, (pageNumber - 1), pageSize, out totalChildren
-                 , orderBy, orderDirection, orderBySystemField, filter).ToArray();
-            }
-            else
-            {
-                children = Services.ContentService.GetChildren(id).ToArray();
-                totalChildren = children.Length;
-            }
-
-            if (totalChildren == 0)
-            {
-                return new PagedResult<ContentItemBasic<ContentPropertyBasic, IContent>>(0, 0, 0);
-            }
-
-            var pagedResult = new PagedResult<ContentItemBasic<ContentPropertyBasic, IContent>>(totalChildren, pageNumber, pageSize);
-            pagedResult.Items = children.Select(content =>
-                Mapper.Map<IContent, ContentItemBasic<ContentPropertyBasic, IContent>>(content,
-                    opts =>
-                    {
-                        // if there's a list of property aliases to map - we will make sure to store this in the mapping context.
-                        if (String.IsNullOrWhiteSpace(includeProperties) == false)
-                        {
-                            opts.Items["IncludeProperties"] = includeProperties.Split(new[] { ", ", "," }, StringSplitOptions.RemoveEmptyEntries);
-                        }
-                    }));
-
-            return pagedResult;
-        }
-
-        [Obsolete("Dont use this, it is incorrectly named, use HasPermission instead")]
-        public bool GetHasPermission(string permissionToCheck, int nodeId)
-        {
-            return HasPermission(permissionToCheck, nodeId);
-        }
-
-        /// <summary>
-        /// Returns permissions for all nodes passed in for the current user
-        /// TODO: This should be moved to the CurrentUserController?
-        /// </summary>
-        /// <param name="nodeIds"></param>
-        /// <returns></returns>
-        [HttpPost]
-        public Dictionary<int, string[]> GetPermissions(int[] nodeIds)
-        {
-            var permissions = Services.UserService
-                    .GetPermissions(Security.CurrentUser, nodeIds);
-
-            var permissionsDictionary = new Dictionary<int, string[]>();
-            foreach (var nodeId in nodeIds)
-            {
-                var aggregatePerms = permissions.GetAllPermissions(nodeId).ToArray();
-                permissionsDictionary.Add(nodeId, aggregatePerms);
-            }
-
-            return permissionsDictionary;
-        }
-
-        /// <summary>
-        /// Checks a nodes permission for the current user
-        /// TODO: This should be moved to the CurrentUserController?
-        /// </summary>
-        /// <param name="permissionToCheck"></param>
-        /// <param name="nodeId"></param>
-        /// <returns></returns>
-        [HttpGet]
-        public bool HasPermission(string permissionToCheck, int nodeId)
-        {
-            var p = Services.UserService.GetPermissions(Security.CurrentUser, nodeId).GetAllPermissions();
-            if (p.Contains(permissionToCheck.ToString(CultureInfo.InvariantCulture)))
-            {
-                return true;
-            }
-
-            return false;
-        }
-
-        /// <summary>
-        /// Creates a blueprint from a content item
-        /// </summary>
-        /// <param name="contentId">The content id to copy</param>
-        /// <param name="name">The name of the blueprint</param>
-        /// <returns></returns>
-        [HttpPost]
-        public SimpleNotificationModel CreateBlueprintFromContent([FromUri]int contentId, [FromUri]string name)
-        {
-            if (string.IsNullOrWhiteSpace(name)) throw new ArgumentException("Value cannot be null or whitespace.", "name");
-
-            var content = Services.ContentService.GetById(contentId);
-            if (content == null)
-                throw new HttpResponseException(Request.CreateResponse(HttpStatusCode.NotFound));
-
-            EnsureUniqueName(name, content, "name");
-
-            var blueprint = Services.ContentService.CreateContentFromBlueprint(content, name, Security.CurrentUser.Id);
-
-            Services.ContentService.SaveBlueprint(blueprint, Security.CurrentUser.Id);
-
-            var notificationModel = new SimpleNotificationModel();
-            notificationModel.AddSuccessNotification(
-                Services.TextService.Localize("blueprints/createdBlueprintHeading"),
-                Services.TextService.Localize("blueprints/createdBlueprintMessage", new[] { content.Name })
-            );
-
-            return notificationModel;
-        }
-
-        private void EnsureUniqueName(string name, IContent content, string modelName)
-        {
-            var existing = Services.ContentService.GetBlueprintsForContentTypes(content.ContentTypeId);
-            if (existing.Any(x => x.Name == name && x.Id != content.Id))
-            {
-                ModelState.AddModelError(modelName, Services.TextService.Localize("blueprints/duplicateBlueprintMessage"));
-                throw new HttpResponseException(Request.CreateValidationErrorResponse(ModelState));
-            }
-        }
-
-        /// <summary>
-        /// Saves content
-        /// </summary>
-        /// <returns></returns>
-        [FileUploadCleanupFilter]
-        [ContentPostValidate]
-        public ContentItemDisplay PostSaveBlueprint(
-            [ModelBinder(typeof(BlueprintItemBinder))] ContentItemSave contentItem)
-        {
-            var contentItemDisplay = PostSaveInternal(contentItem,
-                content =>
-                {
-                    EnsureUniqueName(content.Name, content, "Name");
-
-                    Services.ContentService.SaveBlueprint(contentItem.PersistedContent, Security.CurrentUser.Id);
-                    //we need to reuse the underlying logic so return the result that it wants
-                    return Attempt<OperationStatus>.Succeed(new OperationStatus(OperationStatusType.Success, new EventMessages()));
-                });
-            SetupBlueprint(contentItemDisplay, contentItemDisplay.PersistedContent);
-
-            return contentItemDisplay;
-        }
-
-        /// <summary>
-        /// Saves content
-        /// </summary>
-        /// <returns></returns>
-        [FileUploadCleanupFilter]
-        [ContentPostValidate]
-        [OutgoingEditorModelEvent]
-        public ContentItemDisplay PostSave(
-                [ModelBinder(typeof(ContentItemBinder))]
-                                ContentItemSave contentItem)
-        {
-            return PostSaveInternal(contentItem,
-                content => Services.ContentService.WithResult().Save(contentItem.PersistedContent, Security.CurrentUser.Id));
-        }
-
-        private ContentItemDisplay PostSaveInternal(ContentItemSave contentItem, Func<IContent, Attempt<OperationStatus>> saveMethod)
-        {
-            //Recent versions of IE/Edge may send in the full clientside file path instead of just the file name.
-            //To ensure similar behavior across all browsers no matter what they do - we strip the FileName property of all
-            //uploaded files to being *only* the actual file name (as it should be).
-            if (contentItem.UploadedFiles != null && contentItem.UploadedFiles.Any())
-            {
-                foreach (var file in contentItem.UploadedFiles)
-                {
-                    file.FileName = Path.GetFileName(file.FileName);
-                }
-            }
-
-            //If we've reached here it means:
-            // * Our model has been bound
-            // * and validated
-            // * any file attachments have been saved to their temporary location for us to use
-            // * we have a reference to the DTO object and the persisted object
-            // * Permissions are valid
-            MapPropertyValues(contentItem);
-
-            //We need to manually check the validation results here because:
-            // * We still need to save the entity even if there are validation value errors
-            // * Depending on if the entity is new, and if there are non property validation errors (i.e. the name is null)
-            //      then we cannot continue saving, we can only display errors
-            // * If there are validation errors and they were attempting to publish, we can only save, NOT publish and display
-            //      a message indicating this
-            if (ModelState.IsValid == false)
-            {
-                if (ValidationHelper.ModelHasRequiredForPersistenceErrors(contentItem) && IsCreatingAction(contentItem.Action))
-                {
-                    //ok, so the absolute mandatory data is invalid and it's new, we cannot actually continue!
-                    // add the modelstate to the outgoing object and throw a validation message
-                    var forDisplay = AutoMapperExtensions.MapWithUmbracoContext<IContent, ContentItemDisplay>(contentItem.PersistedContent, UmbracoContext);
-                    forDisplay.Errors = ModelState.ToErrorDictionary();
-                    throw new HttpResponseException(Request.CreateValidationErrorResponse(forDisplay));
-
-                }
-
-                //if the model state is not valid we cannot publish so change it to save
-                switch (contentItem.Action)
-                {
-                    case ContentSaveAction.Publish:
-                        contentItem.Action = ContentSaveAction.Save;
-                        break;
-                    case ContentSaveAction.PublishNew:
-                        contentItem.Action = ContentSaveAction.SaveNew;
-                        break;
-                }
-            }
-
-            //initialize this to successful
-            var publishStatus = Attempt<PublishStatus>.Succeed();
-            var wasCancelled = false;
-
-            if (contentItem.Action == ContentSaveAction.Save || contentItem.Action == ContentSaveAction.SaveNew)
-            {
-                //save the item
-                var saveResult = saveMethod(contentItem.PersistedContent);
-
-                wasCancelled = saveResult.Success == false && saveResult.Result.StatusType == OperationStatusType.FailedCancelledByEvent;
-            }
-            else if (contentItem.Action == ContentSaveAction.SendPublish || contentItem.Action == ContentSaveAction.SendPublishNew)
-            {
-                var sendResult = Services.ContentService.SendToPublication(contentItem.PersistedContent, Security.CurrentUser.Id);
-                wasCancelled = sendResult == false;
-            }
-            else
-            {
-                //publish the item and check if it worked, if not we will show a diff msg below
-                publishStatus = Services.ContentService.SaveAndPublishWithStatus(contentItem.PersistedContent, Security.CurrentUser.Id);
-                wasCancelled = publishStatus.Result.StatusType == PublishStatusType.FailedCancelledByEvent;
-            }
-
-            //return the updated model
-            var display = AutoMapperExtensions.MapWithUmbracoContext<IContent, ContentItemDisplay>(contentItem.PersistedContent, UmbracoContext);
-
-            //lasty, if it is not valid, add the modelstate to the outgoing object and throw a 403
-            HandleInvalidModelState(display);
-
-            //put the correct msgs in
-            switch (contentItem.Action)
-            {
-                case ContentSaveAction.Save:
-                case ContentSaveAction.SaveNew:
-                    if (wasCancelled == false)
-                    {
-                        display.AddSuccessNotification(
-                            Services.TextService.Localize("speechBubbles/editContentSavedHeader"),
-                            contentItem.ReleaseDate.HasValue
-                                ? Services.TextService.Localize("speechBubbles/editContentSavedWithReleaseDateText", new [] { contentItem.ReleaseDate.Value.ToLongDateString(), contentItem.ReleaseDate.Value.ToShortTimeString() })
-                                : Services.TextService.Localize("speechBubbles/editContentSavedText")
-                        );
-                    }
-                    else
-                    {
-                        AddCancelMessage(display);
-                    }
-                    break;
-                case ContentSaveAction.SendPublish:
-                case ContentSaveAction.SendPublishNew:
-                    if (wasCancelled == false)
-                    {
-                        display.AddSuccessNotification(
-                            Services.TextService.Localize("speechBubbles/editContentSendToPublish"),
-                            Services.TextService.Localize("speechBubbles/editContentSendToPublishText"));
-                    }
-                    else
-                    {
-                        AddCancelMessage(display);
-                    }
-                    break;
-                case ContentSaveAction.Publish:
-                case ContentSaveAction.PublishNew:
-                    ShowMessageForPublishStatus(publishStatus.Result, display, contentItem.ExpireDate);
-                    break;
-            }
-
-            //If the item is new and the operation was cancelled, we need to return a different
-            // status code so the UI can handle it since it won't be able to redirect since there
-            // is no Id to redirect to!
-            if (wasCancelled && IsCreatingAction(contentItem.Action))
-            {
-                throw new HttpResponseException(Request.CreateValidationErrorResponse(display));
-            }
-
-            display.PersistedContent = contentItem.PersistedContent;
-
-            return display;
-        }
-
-        /// <summary>
-        /// Publishes a document with a given ID
-        /// </summary>
-        /// <param name="id"></param>
-        /// <returns></returns>
-        /// <remarks>
-        /// The CanAccessContentAuthorize attribute will deny access to this method if the current user
-        /// does not have Publish access to this node.
-        /// </remarks>
-        ///
-        [EnsureUserPermissionForContent("id", 'U')]
-        public HttpResponseMessage PostPublishById(int id)
-        {
-            var foundContent = GetObjectFromRequest(() => Services.ContentService.GetById(id));
-
-            if (foundContent == null)
-            {
-                return HandleContentNotFound(id, false);
-            }
-
-            var publishResult = Services.ContentService.PublishWithStatus(foundContent, Security.CurrentUser.Id);
-            if (publishResult.Success == false)
-            {
-                var notificationModel = new SimpleNotificationModel();
-                ShowMessageForPublishStatus(publishResult.Result, notificationModel, foundContent.ExpireDate);
-                return Request.CreateValidationErrorResponse(notificationModel);
-            }
-
-            //return ok
-            return Request.CreateResponse(HttpStatusCode.OK);
-
-        }
-
-        [HttpDelete]
-        [HttpPost]
-        public HttpResponseMessage DeleteBlueprint(int id)
-        {
-            var found = Services.ContentService.GetBlueprintById(id);
-
-            if (found == null)
-            {
-                return HandleContentNotFound(id, false);
-            }
-
-            Services.ContentService.DeleteBlueprint(found);
-
-            return Request.CreateResponse(HttpStatusCode.OK);
-        }
-
-        /// <summary>
-        /// Moves an item to the recycle bin, if it is already there then it will permanently delete it
-        /// </summary>
-        /// <param name="id"></param>
-        /// <returns></returns>
-        /// <remarks>
-        /// The CanAccessContentAuthorize attribute will deny access to this method if the current user
-        /// does not have Delete access to this node.
-        /// </remarks>
-        [EnsureUserPermissionForContent("id", 'D')]
-        [HttpDelete]
-        [HttpPost]
-        public HttpResponseMessage DeleteById(int id)
-        {
-            var foundContent = GetObjectFromRequest(() => Services.ContentService.GetById(id));
-
-            if (foundContent == null)
-            {
-                return HandleContentNotFound(id, false);
-            }
-
-            //if the current item is in the recycle bin
-            if (foundContent.IsInRecycleBin() == false)
-            {
-                var moveResult = Services.ContentService.WithResult().MoveToRecycleBin(foundContent, Security.CurrentUser.Id);
-                if (moveResult == false)
-                {
-                    //returning an object of INotificationModel will ensure that any pending
-                    // notification messages are added to the response.
-                    return Request.CreateValidationErrorResponse(new SimpleNotificationModel());
-                }
-            }
-            else
-            {
-                var deleteResult = Services.ContentService.WithResult().Delete(foundContent, Security.CurrentUser.Id);
-                if (deleteResult == false)
-                {
-                    //returning an object of INotificationModel will ensure that any pending
-                    // notification messages are added to the response.
-                    return Request.CreateValidationErrorResponse(new SimpleNotificationModel());
-                }
-            }
-
-            return Request.CreateResponse(HttpStatusCode.OK);
-        }
-
-        /// <summary>
-        /// Empties the recycle bin
-        /// </summary>
-        /// <returns></returns>
-        /// <remarks>
-        /// attributed with EnsureUserPermissionForContent to verify the user has access to the recycle bin
-        /// </remarks>
-        [HttpDelete]
-        [HttpPost]
-        [EnsureUserPermissionForContent(Constants.System.RecycleBinContent, 'D')]
-        public HttpResponseMessage EmptyRecycleBin()
-        {
-            Services.ContentService.EmptyRecycleBin(Security.CurrentUser.Id);
-
-            return Request.CreateNotificationSuccessResponse(Services.TextService.Localize("defaultdialogs/recycleBinIsEmpty"));
-        }
-
-        /// <summary>
-        /// Change the sort order for content
-        /// </summary>
-        /// <param name="sorted"></param>
-        /// <returns></returns>
-        [EnsureUserPermissionForContent("sorted.ParentId", 'S')]
-        public HttpResponseMessage PostSort(ContentSortOrder sorted)
-        {
-            if (sorted == null)
-            {
-                return Request.CreateResponse(HttpStatusCode.NotFound);
-            }
-
-            //if there's nothing to sort just return ok
-            if (sorted.IdSortOrder.Length == 0)
-            {
-                return Request.CreateResponse(HttpStatusCode.OK);
-            }
-
-            try
-            {
-                var contentService = Services.ContentService;
-
-                // Save content with new sort order and update content xml in db accordingly
-                if (contentService.Sort(sorted.IdSortOrder, Security.CurrentUser.Id) == false)
-                {
-                    LogHelper.Warn<ContentController>("Content sorting failed, this was probably caused by an event being cancelled");
-                    return Request.CreateValidationErrorResponse("Content sorting failed, this was probably caused by an event being cancelled");
-                }
-                return Request.CreateResponse(HttpStatusCode.OK);
-            }
-            catch (Exception ex)
-            {
-                LogHelper.Error<ContentController>("Could not update content sort order", ex);
-                throw;
-            }
-        }
-
-        /// <summary>
-        /// Change the sort order for media
-        /// </summary>
-        /// <param name="move"></param>
-        /// <returns></returns>
-        [EnsureUserPermissionForContent("move.ParentId", 'M')]
-        public HttpResponseMessage PostMove(MoveOrCopy move)
-        {
-            var toMove = ValidateMoveOrCopy(move);
-
-            Services.ContentService.Move(toMove, move.ParentId, Security.CurrentUser.Id);
-
-            var response = Request.CreateResponse(HttpStatusCode.OK);
-            response.Content = new StringContent(toMove.Path, Encoding.UTF8, "application/json");
-            return response;
-        }
-
-        /// <summary>
-        /// Copies a content item and places the copy as a child of a given parent Id
-        /// </summary>
-        /// <param name="copy"></param>
-        /// <returns></returns>
-        [EnsureUserPermissionForContent("copy.ParentId", 'C')]
-        public HttpResponseMessage PostCopy(MoveOrCopy copy)
-        {
-            var toCopy = ValidateMoveOrCopy(copy);
-
-            var c = Services.ContentService.Copy(toCopy, copy.ParentId, copy.RelateToOriginal, copy.Recursive, Security.CurrentUser.Id);
-
-            var response = Request.CreateResponse(HttpStatusCode.OK);
-            response.Content = new StringContent(c.Path, Encoding.UTF8, "application/json");
-            return response;
-        }
-
-        /// <summary>
-        /// Unpublishes a node with a given Id and returns the unpublished entity
-        /// </summary>
-        /// <param name="id"></param>
-        /// <returns></returns>
-        [EnsureUserPermissionForContent("id", 'U')]
-        [OutgoingEditorModelEvent]
-        public ContentItemDisplay PostUnPublish(int id)
-        {
-            var foundContent = GetObjectFromRequest(() => Services.ContentService.GetById(id));
-
-            if (foundContent == null)
-                HandleContentNotFound(id);
-
-            var unpublishResult = Services.ContentService.WithResult().UnPublish(foundContent, Security.CurrentUser.Id);
-
-            var content = AutoMapperExtensions.MapWithUmbracoContext<IContent, ContentItemDisplay>(foundContent, UmbracoContext);
-
-            if (unpublishResult == false)
-            {
-                AddCancelMessage(content);
-                throw new HttpResponseException(Request.CreateValidationErrorResponse(content));
-            }
-            else
-            {
-                content.AddSuccessNotification(Services.TextService.Localize("content/unPublish"), Services.TextService.Localize("speechBubbles/contentUnpublished"));
-                return content;
-            }
-        }
-
-        /// <summary>
-        /// Maps the dto property values to the persisted model
-        /// </summary>
-        /// <param name="contentItem"></param>
-        private void MapPropertyValues(ContentItemSave contentItem)
-        {
-            UpdateName(contentItem);
-
-            //TODO: We need to support 'send to publish'
-
-            contentItem.PersistedContent.ExpireDate = contentItem.ExpireDate;
-            contentItem.PersistedContent.ReleaseDate = contentItem.ReleaseDate;
-            //only set the template if it didn't change
-            var templateChanged = (contentItem.PersistedContent.Template == null && contentItem.TemplateAlias.IsNullOrWhiteSpace() == false)
-                                                        || (contentItem.PersistedContent.Template != null && contentItem.PersistedContent.Template.Alias != contentItem.TemplateAlias)
-                                                        || (contentItem.PersistedContent.Template != null && contentItem.TemplateAlias.IsNullOrWhiteSpace());
-            if (templateChanged)
-            {
-                var template = Services.FileService.GetTemplate(contentItem.TemplateAlias);
-                if (template == null && contentItem.TemplateAlias.IsNullOrWhiteSpace() == false)
-                {
-                    //ModelState.AddModelError("Template", "No template exists with the specified alias: " + contentItem.TemplateAlias);
-                    LogHelper.Warn<ContentController>("No template exists with the specified alias: " + contentItem.TemplateAlias);
-                }
-                else
-                {
-                    //NOTE: this could be null if there was a template and the posted template is null, this should remove the assigned template
-                    contentItem.PersistedContent.Template = template;
-                }
-            }
-
-            base.MapPropertyValues(contentItem);
-        }
-
-        /// <summary>
-        /// Ensures the item can be moved/copied to the new location
-        /// </summary>
-        /// <param name="model"></param>
-        /// <returns></returns>
-        private IContent ValidateMoveOrCopy(MoveOrCopy model)
-        {
-            if (model == null)
-            {
-                throw new HttpResponseException(HttpStatusCode.NotFound);
-            }
-
-            var contentService = Services.ContentService;
-            var toMove = contentService.GetById(model.Id);
-            if (toMove == null)
-            {
-                throw new HttpResponseException(HttpStatusCode.NotFound);
-            }
-            if (model.ParentId < 0)
-            {
-                //cannot move if the content item is not allowed at the root
-                if (toMove.ContentType.AllowedAsRoot == false)
-                {
-                    throw new HttpResponseException(
-                            Request.CreateNotificationValidationErrorResponse(
-                                    Services.TextService.Localize("moveOrCopy/notAllowedAtRoot")));
-                }
-            }
-            else
-            {
-                var parent = contentService.GetById(model.ParentId);
-                if (parent == null)
-                {
-                    throw new HttpResponseException(HttpStatusCode.NotFound);
-                }
-
-                //check if the item is allowed under this one
-                if (parent.ContentType.AllowedContentTypes.Select(x => x.Id).ToArray()
-                        .Any(x => x.Value == toMove.ContentType.Id) == false)
-                {
-                    throw new HttpResponseException(
-                            Request.CreateNotificationValidationErrorResponse(
-                                    Services.TextService.Localize("moveOrCopy/notAllowedByContentType")));
-                }
-
-                // Check on paths
-                if ((string.Format(",{0},", parent.Path)).IndexOf(string.Format(",{0},", toMove.Id), StringComparison.Ordinal) > -1)
-                {
-                    throw new HttpResponseException(
-                            Request.CreateNotificationValidationErrorResponse(
-                                    Services.TextService.Localize("moveOrCopy/notAllowedByPath")));
-                }
-            }
-
-            return toMove;
-        }
-
-        private void ShowMessageForPublishStatus(PublishStatus status, INotificationModel display, DateTime? expireDate)
-        {
-            switch (status.StatusType)
-            {
-                case PublishStatusType.Success:
-                case PublishStatusType.SuccessAlreadyPublished:
-                    display.AddSuccessNotification(
-                            Services.TextService.Localize("speechBubbles/editContentPublishedHeader"),
-                            expireDate.HasValue
-                                ? Services.TextService.Localize("speechBubbles/editContentPublishedWithExpireDateText", new [] { expireDate.Value.ToLongDateString(), expireDate.Value.ToShortTimeString() })
-                                : Services.TextService.Localize("speechBubbles/editContentPublishedText")
-                    );
-                    break;
-                case PublishStatusType.FailedPathNotPublished:
-                    display.AddWarningNotification(
-                            Services.TextService.Localize("publish"),
-                            Services.TextService.Localize("publish/contentPublishedFailedByParent",
-                                    new[] { string.Format("{0} ({1})", status.ContentItem.Name, status.ContentItem.Id) }).Trim());
-                    break;
-                case PublishStatusType.FailedCancelledByEvent:
-                    AddCancelMessage(display, "publish", "speechBubbles/contentPublishedFailedByEvent");
-                    break;
-                case PublishStatusType.FailedAwaitingRelease:
-                    display.AddWarningNotification(
-                            Services.TextService.Localize("publish"),
-                            Services.TextService.Localize("publish/contentPublishedFailedAwaitingRelease",
-                                    new[] { string.Format("{0} ({1})", status.ContentItem.Name, status.ContentItem.Id) }).Trim());
-                    break;
-                case PublishStatusType.FailedHasExpired:
-                    display.AddWarningNotification(
-                            Services.TextService.Localize("publish"),
-                            Services.TextService.Localize("publish/contentPublishedFailedExpired",
-                                    new[]
-                                    {
-                                                                string.Format("{0} ({1})", status.ContentItem.Name, status.ContentItem.Id),
-                                    }).Trim());
-                    break;
-                case PublishStatusType.FailedIsTrashed:
-                    //TODO: We should add proper error messaging for this!
-                    break;
-                case PublishStatusType.FailedContentInvalid:
-                    display.AddWarningNotification(
-                            Services.TextService.Localize("publish"),
-                            Services.TextService.Localize("publish/contentPublishedFailedInvalid",
-                                    new[]
-                                    {
-                                                                string.Format("{0} ({1})", status.ContentItem.Name, status.ContentItem.Id),
-                                                                string.Join(",", status.InvalidProperties.Select(x => x.Alias))
-                                    }).Trim());
-                    break;
-                default:
-                    throw new IndexOutOfRangeException();
-            }
-        }
-
-
-        /// <summary>
-        /// Performs a permissions check for the user to check if it has access to the node based on
-        /// start node and/or permissions for the node
-        /// </summary>
-        /// <param name="storage">The storage to add the content item to so it can be reused</param>
-        /// <param name="user"></param>
-        /// <param name="userService"></param>
-        /// <param name="contentService"></param>
-        /// <param name="entityService"></param>
-        /// <param name="nodeId">The content to lookup, if the contentItem is not specified</param>
-        /// <param name="permissionsToCheck"></param>
-        /// <param name="contentItem">Specifies the already resolved content item to check against</param>
-        /// <returns></returns>
-        internal static bool CheckPermissions(
-                IDictionary<string, object> storage,
-                IUser user,
-                IUserService userService,
-                IContentService contentService,
-                IEntityService entityService,
-                int nodeId,
-                char[] permissionsToCheck = null,
-                IContent contentItem = null)
-        {
-            if (storage == null) throw new ArgumentNullException("storage");
-            if (user == null) throw new ArgumentNullException("user");
-            if (userService == null) throw new ArgumentNullException("userService");
-            if (contentService == null) throw new ArgumentNullException("contentService");
-            if (entityService == null) throw new ArgumentNullException("entityService");
-
-            if (contentItem == null && nodeId != Constants.System.Root && nodeId != Constants.System.RecycleBinContent)
-            {
-                contentItem = contentService.GetById(nodeId);
-                //put the content item into storage so it can be retreived
-                // in the controller (saves a lookup)
-                storage[typeof(IContent).ToString()] = contentItem;
-            }
-
-            if (contentItem == null && nodeId != Constants.System.Root && nodeId != Constants.System.RecycleBinContent)
-            {
-                throw new HttpResponseException(HttpStatusCode.NotFound);
-            }
-
-            var hasPathAccess = (nodeId == Constants.System.Root)
-                ? user.HasContentRootAccess(entityService)
-                : (nodeId == Constants.System.RecycleBinContent)
-                    ? user.HasContentBinAccess(entityService)
-                    : user.HasPathAccess(contentItem, entityService);
-
-            if (hasPathAccess == false)
-            {
-                return false;
-            }
-
-            if (permissionsToCheck == null || permissionsToCheck.Length == 0)
-            {
-                return true;
-            }
-
-            //get the implicit/inherited permissions for the user for this path,
-            //if there is no content item for this id, than just use the id as the path (i.e. -1 or -20)
-            var path = contentItem != null ? contentItem.Path : nodeId.ToString();
-            var permission = userService.GetPermissionsForPath(user, path);
-
-            var allowed = true;
-            foreach (var p in permissionsToCheck)
-            {
-                if (permission == null
-                    || permission.GetAllPermissions().Contains(p.ToString(CultureInfo.InvariantCulture)) == false)
-                {
-                    allowed = false;
-                }
-            }
-            return allowed;
-        }
-
-        [EnsureUserPermissionForContent("contentId", 'F')]
-        public IEnumerable<NotifySetting> GetNotificationOptions(int contentId)
-        {
-            var notifications = new List<NotifySetting>();
-            if (contentId <= 0) throw new HttpResponseException(Request.CreateResponse(HttpStatusCode.NotFound));
-
-            var content = Services.ContentService.GetById(contentId);
-            if (content == null) throw new HttpResponseException(Request.CreateResponse(HttpStatusCode.NotFound));
-
-            var actionList = ActionsResolver.Current.Actions;
-            foreach (var a in actionList)
-            {
-                if (a.ShowInNotifier)
-                {
-                    NotifySetting n = new NotifySetting
-                    {
-                        Name = ui.Text("actions", a.Alias),
-                        Checked = (UmbracoUser.GetNotifications(content.Path).IndexOf(a.Letter) > -1),
-                        NotifyCode = a.Letter.ToString()
-                    };
-                    notifications.Add(n);
-                }
-            }
-            return notifications;
-        }
-
-        public void PostNotificationOptions(int contentId, string notifyOptions = "")
-        {
-            if (contentId <= 0) throw new HttpResponseException(Request.CreateResponse(HttpStatusCode.NotFound));
-            var content = Services.ContentService.GetById(contentId);
-
-            if (content == null) throw new HttpResponseException(Request.CreateResponse(HttpStatusCode.NotFound));
-            var node = new CMSNode(contentId);
-
-            global::umbraco.cms.businesslogic.workflow.Notification.UpdateNotifications(UmbracoUser, node, notifyOptions ?? "");
-        }
-    }
-}
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.IO;
+using System.Linq;
+using System.Net;
+using System.Net.Http;
+using System.Text;
+using System.Web.Http;
+using System.Web.Http.Controllers;
+using System.Web.Http.ModelBinding;
+using AutoMapper;
+using Umbraco.Core;
+using Umbraco.Core.Logging;
+using Umbraco.Core.Models;
+using Umbraco.Core.Models.Membership;
+using Umbraco.Core.Persistence.DatabaseModelDefinitions;
+using Umbraco.Core.Publishing;
+using Umbraco.Core.Services;
+using Umbraco.Web.Models.ContentEditing;
+using Umbraco.Web.Models.Mapping;
+using Umbraco.Web.Mvc;
+using Umbraco.Web.WebApi;
+using Umbraco.Web.WebApi.Binders;
+using Umbraco.Web.WebApi.Filters;
+using Umbraco.Core.Events;
+using Constants = Umbraco.Core.Constants;
+using umbraco.cms.businesslogic;
+using System.Collections;
+using umbraco;
+
+namespace Umbraco.Web.Editors
+{
+    /// <summary>
+    /// The API controller used for editing content
+    /// </summary>
+    /// <remarks>
+    /// This controller is decorated with the UmbracoApplicationAuthorizeAttribute which means that any user requesting
+    /// access to ALL of the methods on this controller will need access to the content application.
+    /// </remarks>
+    [PluginController("UmbracoApi")]
+    [UmbracoApplicationAuthorize(Constants.Applications.Content)]
+    [ContentControllerConfiguration]
+    public class ContentController : ContentControllerBase
+    {
+        /// <summary>
+        /// Constructor
+        /// </summary>
+        public ContentController()
+                : this(UmbracoContext.Current)
+        {
+        }
+
+        /// <summary>
+        /// Constructor
+        /// </summary>
+        /// <param name="umbracoContext"></param>
+        public ContentController(UmbracoContext umbracoContext)
+                : base(umbracoContext)
+        {
+        }
+
+        /// <summary>
+        /// Configures this controller with a custom action selector
+        /// </summary>
+        private class ContentControllerConfigurationAttribute : Attribute, IControllerConfiguration
+        {
+            public void Initialize(HttpControllerSettings controllerSettings, HttpControllerDescriptor controllerDescriptor)
+            {
+                controllerSettings.Services.Replace(typeof(IHttpActionSelector), new ParameterSwapControllerActionSelector(
+                    new ParameterSwapControllerActionSelector.ParameterSwapInfo("GetNiceUrl", "id", typeof(int), typeof(Guid), typeof(Udi)),
+                    new ParameterSwapControllerActionSelector.ParameterSwapInfo("GetById", "id", typeof(int), typeof(Guid), typeof(Udi))
+                ));
+            }
+        }
+
+        /// <summary>
+        /// Return content for the specified ids
+        /// </summary>
+        /// <param name="ids"></param>
+        /// <returns></returns>
+        [FilterAllowedOutgoingContent(typeof(IEnumerable<ContentItemDisplay>))]
+        public IEnumerable<ContentItemDisplay> GetByIds([FromUri]int[] ids)
+        {
+            var foundContent = Services.ContentService.GetByIds(ids);
+            return foundContent.Select(content => AutoMapperExtensions.MapWithUmbracoContext<IContent, ContentItemDisplay>(content, UmbracoContext));
+        }
+
+        /// <summary>
+        /// Updates the permissions for a content item for a particular user group
+        /// </summary>
+        /// <param name="saveModel"></param>
+        /// <returns></returns>
+        /// <remarks>
+        /// Permission check is done for letter 'R' which is for <see cref="ActionRights"/> which the user must have access to to update
+        /// </remarks>
+        [EnsureUserPermissionForContent("saveModel.ContentId", 'R')]
+        public IEnumerable<AssignedUserGroupPermissions> PostSaveUserGroupPermissions(UserGroupPermissionsSave saveModel)
+        {
+            if (saveModel.ContentId <= 0) throw new HttpResponseException(Request.CreateResponse(HttpStatusCode.NotFound));
+
+            //TODO: Should non-admins be alowed to set granular permissions?
+
+            var content = Services.ContentService.GetById(saveModel.ContentId);
+            if (content == null) throw new HttpResponseException(Request.CreateResponse(HttpStatusCode.NotFound));
+
+            //current permissions explicitly assigned to this content item
+            var contentPermissions = Services.ContentService.GetPermissionsForEntity(content)
+                .ToDictionary(x => x.UserGroupId, x => x);
+
+            var allUserGroups = Services.UserService.GetAllUserGroups().ToArray();
+
+            //loop through each user group
+            foreach (var userGroup in allUserGroups)
+            {
+                //check if there's a permission set posted up for this user group
+                IEnumerable<string> groupPermissions;
+                if (saveModel.AssignedPermissions.TryGetValue(userGroup.Id, out groupPermissions))
+                {
+                    //create a string collection of the assigned letters
+                    var groupPermissionCodes = groupPermissions.ToArray();
+
+                    //check if there are no permissions assigned for this group save model, if that is the case we want to reset the permissions
+                    //for this group/node which will go back to the defaults
+                    if (groupPermissionCodes.Length == 0)
+                    {
+                        Services.UserService.RemoveUserGroupPermissions(userGroup.Id, content.Id);
+                    }
+                    //check if they are the defaults, if so we should just remove them if they exist since it's more overhead having them stored
+                    else if (userGroup.Permissions.UnsortedSequenceEqual(groupPermissionCodes))
+                    {
+                        //only remove them if they are actually currently assigned
+                        if (contentPermissions.ContainsKey(userGroup.Id))
+                        {
+                            //remove these permissions from this node for this group since the ones being assigned are the same as the defaults
+                            Services.UserService.RemoveUserGroupPermissions(userGroup.Id, content.Id);
+                        }
+                    }
+                    //if they are different we need to update, otherwise there's nothing to update
+                    else if (contentPermissions.ContainsKey(userGroup.Id) == false || contentPermissions[userGroup.Id].AssignedPermissions.UnsortedSequenceEqual(groupPermissionCodes) == false)
+                    {
+
+                        Services.UserService.ReplaceUserGroupPermissions(userGroup.Id, groupPermissionCodes.Select(x => x[0]), content.Id);
+                    }
+                }
+            }
+
+            return GetDetailedPermissions(content, allUserGroups);
+        }
+
+        /// <summary>
+        /// Returns the user group permissions for user groups assigned to this node
+        /// </summary>
+        /// <param name="contentId"></param>
+        /// <returns></returns>
+        /// <remarks>
+        /// Permission check is done for letter 'R' which is for <see cref="ActionRights"/> which the user must have access to to view
+        /// </remarks>
+        [EnsureUserPermissionForContent("contentId", 'R')]
+        public IEnumerable<AssignedUserGroupPermissions> GetDetailedPermissions(int contentId)
+        {
+            if (contentId <= 0) throw new HttpResponseException(Request.CreateResponse(HttpStatusCode.NotFound));
+            var content = Services.ContentService.GetById(contentId);
+            if (content == null) throw new HttpResponseException(Request.CreateResponse(HttpStatusCode.NotFound));
+
+            //TODO: Should non-admins be able to see detailed permissions?
+
+            var allUserGroups = Services.UserService.GetAllUserGroups();
+
+            return GetDetailedPermissions(content, allUserGroups);
+        }
+
+        private IEnumerable<AssignedUserGroupPermissions> GetDetailedPermissions(IContent content, IEnumerable<IUserGroup> allUserGroups)
+        {
+            //get all user groups and map their default permissions to the AssignedUserGroupPermissions model.
+            //we do this because not all groups will have true assigned permissions for this node so if they don't have assigned permissions, we need to show the defaults.
+
+            var defaultPermissionsByGroup = Mapper.Map<IEnumerable<AssignedUserGroupPermissions>>(allUserGroups).ToArray();
+
+            var defaultPermissionsAsDictionary = defaultPermissionsByGroup
+                .ToDictionary(x => Convert.ToInt32(x.Id), x => x);
+
+            //get the actual assigned permissions
+            var assignedPermissionsByGroup = Services.ContentService.GetPermissionsForEntity(content).ToArray();
+
+            //iterate over assigned and update the defaults with the real values
+            foreach (var assignedGroupPermission in assignedPermissionsByGroup)
+            {
+                var defaultUserGroupPermissions = defaultPermissionsAsDictionary[assignedGroupPermission.UserGroupId];
+
+                //clone the default permissions model to the assigned ones
+                defaultUserGroupPermissions.AssignedPermissions = AssignedUserGroupPermissions.ClonePermissions(defaultUserGroupPermissions.DefaultPermissions);
+
+                //since there is custom permissions assigned to this node for this group, we need to clear all of the default permissions
+                //and we'll re-check it if it's one of the explicitly assigned ones
+                foreach (var permission in defaultUserGroupPermissions.AssignedPermissions.SelectMany(x => x.Value))
+                {
+                    permission.Checked = false;
+                    permission.Checked = assignedGroupPermission.AssignedPermissions.Contains(permission.PermissionCode, StringComparer.InvariantCulture);
+                }
+
+            }
+
+            return defaultPermissionsByGroup;
+        }
+
+        /// <summary>
+        /// Returns an item to be used to display the recycle bin for content
+        /// </summary>
+        /// <returns></returns>
+        public ContentItemDisplay GetRecycleBin()
+        {
+            var display = new ContentItemDisplay
+            {
+                Id = Constants.System.RecycleBinContent,
+                Alias = "recycleBin",
+                ParentId = -1,
+                Name = Services.TextService.Localize("general/recycleBin"),
+                ContentTypeAlias = "recycleBin",
+                CreateDate = DateTime.Now,
+                IsContainer = true,
+                Path = "-1," + Constants.System.RecycleBinContent
+            };
+
+            TabsAndPropertiesResolver<IContent>.AddListView(display, "content", Services.DataTypeService, Services.TextService);
+
+            return display;
+        }
+
+        public ContentItemDisplay GetBlueprintById(int id)
+        {
+            var foundContent = Services.ContentService.GetBlueprintById(id);
+            if (foundContent == null)
+            {
+                HandleContentNotFound(id);
+            }
+
+            var content = AutoMapperExtensions.MapWithUmbracoContext<IContent, ContentItemDisplay>(foundContent, UmbracoContext);
+
+            SetupBlueprint(content, foundContent);
+
+            return content;
+        }
+
+        private static void SetupBlueprint(ContentItemDisplay content, IContent persistedContent)
+        {
+            content.AllowPreview = false;
+
+            //set a custom path since the tree that renders this has the content type id as the parent
+            content.Path = string.Format("-1,{0},{1}", persistedContent.ContentTypeId, content.Id);
+
+            content.AllowedActions = new[] { "A" };
+            content.IsBlueprint = true;
+
+            var excludeProps = new[] { "_umb_urls", "_umb_releasedate", "_umb_expiredate", "_umb_template" };
+            var propsTab = content.Tabs.Last();
+            propsTab.Properties = propsTab.Properties
+                .Where(p => excludeProps.Contains(p.Alias) == false);
+        }
+
+        /// <summary>
+        /// Gets the content json for the content id
+        /// </summary>
+        /// <param name="id"></param>
+        /// <returns></returns>
+        [OutgoingEditorModelEvent]
+        [EnsureUserPermissionForContent("id")]
+        public ContentItemDisplay GetById(int id)
+        {
+            var foundContent = GetObjectFromRequest(() => Services.ContentService.GetById(id));
+            if (foundContent == null)
+            {
+                HandleContentNotFound(id);
+            }
+
+            var content = AutoMapperExtensions.MapWithUmbracoContext<IContent, ContentItemDisplay>(foundContent, UmbracoContext);
+            return content;
+        }
+
+        /// <summary>
+        /// Gets the content json for the content id
+        /// </summary>
+        /// <param name="id"></param>
+        /// <returns></returns>
+        [OutgoingEditorModelEvent]
+        [EnsureUserPermissionForContent("id")]
+        public ContentItemDisplay GetById(Guid id)
+        {
+            var foundContent = GetObjectFromRequest(() => Services.ContentService.GetById(id));
+            if (foundContent == null)
+            {
+                HandleContentNotFound(id);
+            }
+
+            var content = AutoMapperExtensions.MapWithUmbracoContext<IContent, ContentItemDisplay>(foundContent, UmbracoContext);
+            return content;
+        }
+
+        /// <summary>
+        /// Gets the content json for the content id
+        /// </summary>
+        /// <param name="id"></param>
+        /// <returns></returns>
+        [OutgoingEditorModelEvent]
+        [EnsureUserPermissionForContent("id")]
+        public ContentItemDisplay GetById(Udi id)
+        {
+            var guidUdi = id as GuidUdi;
+            if (guidUdi != null)
+            {
+                return GetById(guidUdi.Guid);
+            }
+
+            throw new HttpResponseException(HttpStatusCode.NotFound);
+        }
+
+        [EnsureUserPermissionForContent("id")]
+        public ContentItemDisplay GetWithTreeDefinition(int id)
+        {
+            var foundContent = GetObjectFromRequest(() => Services.ContentService.GetById(id));
+            if (foundContent == null)
+            {
+                HandleContentNotFound(id);
+            }
+
+            var content = AutoMapperExtensions.MapWithUmbracoContext<IContent, ContentItemDisplay>(foundContent, UmbracoContext);
+            return content;
+        }
+
+        /// <summary>
+        /// Gets an empty content item for the
+        /// </summary>
+        /// <param name="contentTypeAlias"></param>
+        /// <param name="parentId"></param>
+        /// <returns>
+        /// If this is a container type, we'll remove the umbContainerView tab for a new item since
+        /// it cannot actually list children if it doesn't exist yet.
+        /// </returns>
+        [OutgoingEditorModelEvent]
+        public ContentItemDisplay GetEmpty(string contentTypeAlias, int parentId)
+        {
+            var contentType = Services.ContentTypeService.GetContentType(contentTypeAlias);
+            if (contentType == null)
+            {
+                throw new HttpResponseException(HttpStatusCode.NotFound);
+            }
+
+            var emptyContent = Services.ContentService.CreateContent("", parentId, contentType.Alias, UmbracoUser.Id);
+            var mapped = AutoMapperExtensions.MapWithUmbracoContext<IContent, ContentItemDisplay>(emptyContent, UmbracoContext);
+            // translate the content type name if applicable
+            mapped.ContentTypeName = Services.TextService.UmbracoDictionaryTranslate(mapped.ContentTypeName);
+            // if your user type doesn't have access to the Settings section it would not get this property mapped
+            if(mapped.DocumentType != null)
+                mapped.DocumentType.Name = Services.TextService.UmbracoDictionaryTranslate(mapped.DocumentType.Name);
+
+            //remove this tab if it exists: umbContainerView
+            var containerTab = mapped.Tabs.FirstOrDefault(x => x.Alias == Constants.Conventions.PropertyGroups.ListViewGroupName);
+            mapped.Tabs = mapped.Tabs.Except(new[] { containerTab });
+            return mapped;
+        }
+
+        [OutgoingEditorModelEvent]
+        public ContentItemDisplay GetEmpty(int blueprintId, int parentId)
+        {
+            var blueprint = Services.ContentService.GetBlueprintById(blueprintId);
+            if (blueprint == null)
+            {
+                throw new HttpResponseException(HttpStatusCode.NotFound);
+            }
+
+            blueprint.Id = 0;
+            blueprint.Name = string.Empty;
+            blueprint.ParentId = parentId;
+
+            var mapped = Mapper.Map<ContentItemDisplay>(blueprint);
+
+            //remove this tab if it exists: umbContainerView
+            var containerTab = mapped.Tabs.FirstOrDefault(x => x.Alias == Constants.Conventions.PropertyGroups.ListViewGroupName);
+            mapped.Tabs = mapped.Tabs.Except(new[] { containerTab });
+            return mapped;
+        }
+
+        /// <summary>
+        /// Gets the Url for a given node ID
+        /// </summary>
+        /// <param name="id"></param>
+        /// <returns></returns>
+        public HttpResponseMessage GetNiceUrl(int id)
+        {
+            var url = Umbraco.NiceUrl(id);
+            var response = Request.CreateResponse(HttpStatusCode.OK);
+            response.Content = new StringContent(url, Encoding.UTF8, "application/json");
+            return response;
+        }
+
+        /// <summary>
+        /// Gets the Url for a given node ID
+        /// </summary>
+        /// <param name="id"></param>
+        /// <returns></returns>
+        public HttpResponseMessage GetNiceUrl(Guid id)
+        {
+            var url = Umbraco.UrlProvider.GetUrl(id);
+            var response = Request.CreateResponse(HttpStatusCode.OK);
+            response.Content = new StringContent(url, Encoding.UTF8, "application/json");
+            return response;
+        }
+
+        /// <summary>
+        /// Gets the Url for a given node ID
+        /// </summary>
+        /// <param name="id"></param>
+        /// <returns></returns>
+        public HttpResponseMessage GetNiceUrl(Udi id)
+        {
+            var guidUdi = id as GuidUdi;
+            if (guidUdi != null)
+            {
+                return GetNiceUrl(guidUdi.Guid);
+            }
+            throw new HttpResponseException(HttpStatusCode.NotFound);
+        }
+
+        /// <summary>
+        /// Gets the children for the content id passed in
+        /// </summary>
+        /// <returns></returns>
+        [FilterAllowedOutgoingContent(typeof(IEnumerable<ContentItemBasic<ContentPropertyBasic, IContent>>), "Items")]
+        public PagedResult<ContentItemBasic<ContentPropertyBasic, IContent>> GetChildren(
+                int id,
+                int pageNumber = 0,  //TODO: This should be '1' as it's not the index
+                int pageSize = 0,
+                string orderBy = "SortOrder",
+                Direction orderDirection = Direction.Ascending,
+                bool orderBySystemField = true,
+                string filter = "")
+        {
+            return GetChildren(id, null, pageNumber, pageSize, orderBy, orderDirection, orderBySystemField, filter);
+        }
+
+        /// <summary>
+        /// Gets the children for the content id passed in
+        /// </summary>
+        /// <returns></returns>
+        [FilterAllowedOutgoingContent(typeof(IEnumerable<ContentItemBasic<ContentPropertyBasic, IContent>>), "Items")]
+        public PagedResult<ContentItemBasic<ContentPropertyBasic, IContent>> GetChildren(
+                int id,
+                string includeProperties,
+                int pageNumber = 0,  //TODO: This should be '1' as it's not the index
+                int pageSize = 0,
+                string orderBy = "SortOrder",
+                Direction orderDirection = Direction.Ascending,
+                bool orderBySystemField = true,
+                string filter = "")
+        {
+            long totalChildren;
+            IContent[] children;
+            if (pageNumber > 0 && pageSize > 0)
+            {
+                children = Services.ContentService
+                 .GetPagedChildren(id, (pageNumber - 1), pageSize, out totalChildren
+                 , orderBy, orderDirection, orderBySystemField, filter).ToArray();
+            }
+            else
+            {
+                children = Services.ContentService.GetChildren(id).ToArray();
+                totalChildren = children.Length;
+            }
+
+            if (totalChildren == 0)
+            {
+                return new PagedResult<ContentItemBasic<ContentPropertyBasic, IContent>>(0, 0, 0);
+            }
+
+            var pagedResult = new PagedResult<ContentItemBasic<ContentPropertyBasic, IContent>>(totalChildren, pageNumber, pageSize);
+            pagedResult.Items = children.Select(content =>
+                Mapper.Map<IContent, ContentItemBasic<ContentPropertyBasic, IContent>>(content,
+                    opts =>
+                    {
+                        // if there's a list of property aliases to map - we will make sure to store this in the mapping context.
+                        if (String.IsNullOrWhiteSpace(includeProperties) == false)
+                        {
+                            opts.Items["IncludeProperties"] = includeProperties.Split(new[] { ", ", "," }, StringSplitOptions.RemoveEmptyEntries);
+                        }
+                    }));
+
+            return pagedResult;
+        }
+
+        [Obsolete("Dont use this, it is incorrectly named, use HasPermission instead")]
+        public bool GetHasPermission(string permissionToCheck, int nodeId)
+        {
+            return HasPermission(permissionToCheck, nodeId);
+        }
+
+        /// <summary>
+        /// Returns permissions for all nodes passed in for the current user
+        /// TODO: This should be moved to the CurrentUserController?
+        /// </summary>
+        /// <param name="nodeIds"></param>
+        /// <returns></returns>
+        [HttpPost]
+        public Dictionary<int, string[]> GetPermissions(int[] nodeIds)
+        {
+            var permissions = Services.UserService
+                    .GetPermissions(Security.CurrentUser, nodeIds);
+
+            var permissionsDictionary = new Dictionary<int, string[]>();
+            foreach (var nodeId in nodeIds)
+            {
+                var aggregatePerms = permissions.GetAllPermissions(nodeId).ToArray();
+                permissionsDictionary.Add(nodeId, aggregatePerms);
+            }
+
+            return permissionsDictionary;
+        }
+
+        /// <summary>
+        /// Checks a nodes permission for the current user
+        /// TODO: This should be moved to the CurrentUserController?
+        /// </summary>
+        /// <param name="permissionToCheck"></param>
+        /// <param name="nodeId"></param>
+        /// <returns></returns>
+        [HttpGet]
+        public bool HasPermission(string permissionToCheck, int nodeId)
+        {
+            var p = Services.UserService.GetPermissions(Security.CurrentUser, nodeId).GetAllPermissions();
+            if (p.Contains(permissionToCheck.ToString(CultureInfo.InvariantCulture)))
+            {
+                return true;
+            }
+
+            return false;
+        }
+
+        /// <summary>
+        /// Creates a blueprint from a content item
+        /// </summary>
+        /// <param name="contentId">The content id to copy</param>
+        /// <param name="name">The name of the blueprint</param>
+        /// <returns></returns>
+        [HttpPost]
+        public SimpleNotificationModel CreateBlueprintFromContent([FromUri]int contentId, [FromUri]string name)
+        {
+            if (string.IsNullOrWhiteSpace(name)) throw new ArgumentException("Value cannot be null or whitespace.", "name");
+
+            var content = Services.ContentService.GetById(contentId);
+            if (content == null)
+                throw new HttpResponseException(Request.CreateResponse(HttpStatusCode.NotFound));
+
+            EnsureUniqueName(name, content, "name");
+
+            var blueprint = Services.ContentService.CreateContentFromBlueprint(content, name, Security.CurrentUser.Id);
+
+            Services.ContentService.SaveBlueprint(blueprint, Security.CurrentUser.Id);
+
+            var notificationModel = new SimpleNotificationModel();
+            notificationModel.AddSuccessNotification(
+                Services.TextService.Localize("blueprints/createdBlueprintHeading"),
+                Services.TextService.Localize("blueprints/createdBlueprintMessage", new[] { content.Name })
+            );
+
+            return notificationModel;
+        }
+
+        private void EnsureUniqueName(string name, IContent content, string modelName)
+        {
+            var existing = Services.ContentService.GetBlueprintsForContentTypes(content.ContentTypeId);
+            if (existing.Any(x => x.Name == name && x.Id != content.Id))
+            {
+                ModelState.AddModelError(modelName, Services.TextService.Localize("blueprints/duplicateBlueprintMessage"));
+                throw new HttpResponseException(Request.CreateValidationErrorResponse(ModelState));
+            }
+        }
+
+        /// <summary>
+        /// Saves content
+        /// </summary>
+        /// <returns></returns>
+        [FileUploadCleanupFilter]
+        [ContentPostValidate]
+        public ContentItemDisplay PostSaveBlueprint(
+            [ModelBinder(typeof(BlueprintItemBinder))] ContentItemSave contentItem)
+        {
+            var contentItemDisplay = PostSaveInternal(contentItem,
+                content =>
+                {
+                    EnsureUniqueName(content.Name, content, "Name");
+
+                    Services.ContentService.SaveBlueprint(contentItem.PersistedContent, Security.CurrentUser.Id);
+                    //we need to reuse the underlying logic so return the result that it wants
+                    return Attempt<OperationStatus>.Succeed(new OperationStatus(OperationStatusType.Success, new EventMessages()));
+                });
+            SetupBlueprint(contentItemDisplay, contentItemDisplay.PersistedContent);
+
+            return contentItemDisplay;
+        }
+
+        /// <summary>
+        /// Saves content
+        /// </summary>
+        /// <returns></returns>
+        [FileUploadCleanupFilter]
+        [ContentPostValidate]
+        [OutgoingEditorModelEvent]
+        public ContentItemDisplay PostSave(
+                [ModelBinder(typeof(ContentItemBinder))]
+                                ContentItemSave contentItem)
+        {
+            return PostSaveInternal(contentItem,
+                content => Services.ContentService.WithResult().Save(contentItem.PersistedContent, Security.CurrentUser.Id));
+        }
+
+        private ContentItemDisplay PostSaveInternal(ContentItemSave contentItem, Func<IContent, Attempt<OperationStatus>> saveMethod)
+        {
+            //Recent versions of IE/Edge may send in the full clientside file path instead of just the file name.
+            //To ensure similar behavior across all browsers no matter what they do - we strip the FileName property of all
+            //uploaded files to being *only* the actual file name (as it should be).
+            if (contentItem.UploadedFiles != null && contentItem.UploadedFiles.Any())
+            {
+                foreach (var file in contentItem.UploadedFiles)
+                {
+                    file.FileName = Path.GetFileName(file.FileName);
+                }
+            }
+
+            //If we've reached here it means:
+            // * Our model has been bound
+            // * and validated
+            // * any file attachments have been saved to their temporary location for us to use
+            // * we have a reference to the DTO object and the persisted object
+            // * Permissions are valid
+            MapPropertyValues(contentItem);
+
+            //We need to manually check the validation results here because:
+            // * We still need to save the entity even if there are validation value errors
+            // * Depending on if the entity is new, and if there are non property validation errors (i.e. the name is null)
+            //      then we cannot continue saving, we can only display errors
+            // * If there are validation errors and they were attempting to publish, we can only save, NOT publish and display
+            //      a message indicating this
+            if (ModelState.IsValid == false)
+            {
+                if (ValidationHelper.ModelHasRequiredForPersistenceErrors(contentItem) && IsCreatingAction(contentItem.Action))
+                {
+                    //ok, so the absolute mandatory data is invalid and it's new, we cannot actually continue!
+                    // add the modelstate to the outgoing object and throw a validation message
+                    var forDisplay = AutoMapperExtensions.MapWithUmbracoContext<IContent, ContentItemDisplay>(contentItem.PersistedContent, UmbracoContext);
+                    forDisplay.Errors = ModelState.ToErrorDictionary();
+                    throw new HttpResponseException(Request.CreateValidationErrorResponse(forDisplay));
+
+                }
+
+                //if the model state is not valid we cannot publish so change it to save
+                switch (contentItem.Action)
+                {
+                    case ContentSaveAction.Publish:
+                        contentItem.Action = ContentSaveAction.Save;
+                        break;
+                    case ContentSaveAction.PublishNew:
+                        contentItem.Action = ContentSaveAction.SaveNew;
+                        break;
+                }
+            }
+
+            //initialize this to successful
+            var publishStatus = Attempt<PublishStatus>.Succeed();
+            var wasCancelled = false;   //tracks if the operation was cancelled
+            var noop = false;           //tracks if the operation performed no operation (nothing to save)
+
+            if (contentItem.Action == ContentSaveAction.Save || contentItem.Action == ContentSaveAction.SaveNew)
+            {
+                //save the item
+                var saveResult = saveMethod(contentItem.PersistedContent);
+
+                wasCancelled = saveResult.Success == false && saveResult.Result.StatusType == OperationStatusType.FailedCancelledByEvent;
+                noop = saveResult.Result.StatusType == OperationStatusType.NoOperation;
+            }
+            else if (contentItem.Action == ContentSaveAction.SendPublish || contentItem.Action == ContentSaveAction.SendPublishNew)
+            {
+                var sendResult = Services.ContentService.SendToPublication(contentItem.PersistedContent, Security.CurrentUser.Id);
+                wasCancelled = sendResult == false;
+            }
+            else
+            {
+                //publish the item and check if it worked, if not we will show a diff msg below
+                publishStatus = Services.ContentService.SaveAndPublishWithStatus(contentItem.PersistedContent, Security.CurrentUser.Id);
+                wasCancelled = publishStatus.Result.StatusType == PublishStatusType.FailedCancelledByEvent;
+            }
+
+            //return the updated model
+            var display = AutoMapperExtensions.MapWithUmbracoContext<IContent, ContentItemDisplay>(contentItem.PersistedContent, UmbracoContext);
+
+            //lasty, if it is not valid, add the modelstate to the outgoing object and throw a 403
+            HandleInvalidModelState(display);
+
+            //put the correct msgs in
+            switch (contentItem.Action)
+            {
+                case ContentSaveAction.Save:
+                case ContentSaveAction.SaveNew:
+                    if (wasCancelled)
+                    {
+                        AddCancelMessage(display);
+                        
+                    }
+                    else if (noop == false)
+                    {
+                        display.AddSuccessNotification(
+                            Services.TextService.Localize("speechBubbles/editContentSavedHeader"),
+                            contentItem.ReleaseDate.HasValue
+                                ? Services.TextService.Localize("speechBubbles/editContentSavedWithReleaseDateText", new[] { contentItem.ReleaseDate.Value.ToLongDateString(), contentItem.ReleaseDate.Value.ToShortTimeString() })
+                                : Services.TextService.Localize("speechBubbles/editContentSavedText")
+                        );
+                    }
+                    break;
+                case ContentSaveAction.SendPublish:
+                case ContentSaveAction.SendPublishNew:
+                    if (wasCancelled)
+                    {
+                        AddCancelMessage(display);
+                    }
+                    else if (noop == false)
+                    {
+                        display.AddSuccessNotification(
+                            Services.TextService.Localize("speechBubbles/editContentSendToPublish"),
+                            Services.TextService.Localize("speechBubbles/editContentSendToPublishText"));
+                    }
+
+                    break;
+                case ContentSaveAction.Publish:
+                case ContentSaveAction.PublishNew:
+                    ShowMessageForPublishStatus(publishStatus.Result, display, contentItem.ExpireDate);
+                    break;
+            }
+
+            //If the item is new and the operation was cancelled, we need to return a different
+            // status code so the UI can handle it since it won't be able to redirect since there
+            // is no Id to redirect to!
+            if (wasCancelled && IsCreatingAction(contentItem.Action))
+            {
+                throw new HttpResponseException(Request.CreateValidationErrorResponse(display));
+            }
+
+            display.PersistedContent = contentItem.PersistedContent;
+
+            return display;
+        }
+
+        /// <summary>
+        /// Publishes a document with a given ID
+        /// </summary>
+        /// <param name="id"></param>
+        /// <returns></returns>
+        /// <remarks>
+        /// The CanAccessContentAuthorize attribute will deny access to this method if the current user
+        /// does not have Publish access to this node.
+        /// </remarks>
+        ///
+        [EnsureUserPermissionForContent("id", 'U')]
+        public HttpResponseMessage PostPublishById(int id)
+        {
+            var foundContent = GetObjectFromRequest(() => Services.ContentService.GetById(id));
+
+            if (foundContent == null)
+            {
+                return HandleContentNotFound(id, false);
+            }
+
+            var publishResult = Services.ContentService.PublishWithStatus(foundContent, Security.CurrentUser.Id);
+            if (publishResult.Success == false)
+            {
+                var notificationModel = new SimpleNotificationModel();
+                ShowMessageForPublishStatus(publishResult.Result, notificationModel, foundContent.ExpireDate);
+                return Request.CreateValidationErrorResponse(notificationModel);
+            }
+
+            //return ok
+            return Request.CreateResponse(HttpStatusCode.OK);
+
+        }
+
+        [HttpDelete]
+        [HttpPost]
+        public HttpResponseMessage DeleteBlueprint(int id)
+        {
+            var found = Services.ContentService.GetBlueprintById(id);
+
+            if (found == null)
+            {
+                return HandleContentNotFound(id, false);
+            }
+
+            Services.ContentService.DeleteBlueprint(found);
+
+            return Request.CreateResponse(HttpStatusCode.OK);
+        }
+
+        /// <summary>
+        /// Moves an item to the recycle bin, if it is already there then it will permanently delete it
+        /// </summary>
+        /// <param name="id"></param>
+        /// <returns></returns>
+        /// <remarks>
+        /// The CanAccessContentAuthorize attribute will deny access to this method if the current user
+        /// does not have Delete access to this node.
+        /// </remarks>
+        [EnsureUserPermissionForContent("id", 'D')]
+        [HttpDelete]
+        [HttpPost]
+        public HttpResponseMessage DeleteById(int id)
+        {
+            var foundContent = GetObjectFromRequest(() => Services.ContentService.GetById(id));
+
+            if (foundContent == null)
+            {
+                return HandleContentNotFound(id, false);
+            }
+
+            //if the current item is in the recycle bin
+            if (foundContent.IsInRecycleBin() == false)
+            {
+                var moveResult = Services.ContentService.WithResult().MoveToRecycleBin(foundContent, Security.CurrentUser.Id);
+                if (moveResult == false)
+                {
+                    //returning an object of INotificationModel will ensure that any pending
+                    // notification messages are added to the response.
+                    return Request.CreateValidationErrorResponse(new SimpleNotificationModel());
+                }
+            }
+            else
+            {
+                var deleteResult = Services.ContentService.WithResult().Delete(foundContent, Security.CurrentUser.Id);
+                if (deleteResult == false)
+                {
+                    //returning an object of INotificationModel will ensure that any pending
+                    // notification messages are added to the response.
+                    return Request.CreateValidationErrorResponse(new SimpleNotificationModel());
+                }
+            }
+
+            return Request.CreateResponse(HttpStatusCode.OK);
+        }
+
+        /// <summary>
+        /// Empties the recycle bin
+        /// </summary>
+        /// <returns></returns>
+        /// <remarks>
+        /// attributed with EnsureUserPermissionForContent to verify the user has access to the recycle bin
+        /// </remarks>
+        [HttpDelete]
+        [HttpPost]
+        [EnsureUserPermissionForContent(Constants.System.RecycleBinContent, 'D')]
+        public HttpResponseMessage EmptyRecycleBin()
+        {
+            Services.ContentService.EmptyRecycleBin(Security.CurrentUser.Id);
+
+            return Request.CreateNotificationSuccessResponse(Services.TextService.Localize("defaultdialogs/recycleBinIsEmpty"));
+        }
+
+        /// <summary>
+        /// Change the sort order for content
+        /// </summary>
+        /// <param name="sorted"></param>
+        /// <returns></returns>
+        [EnsureUserPermissionForContent("sorted.ParentId", 'S')]
+        public HttpResponseMessage PostSort(ContentSortOrder sorted)
+        {
+            if (sorted == null)
+            {
+                return Request.CreateResponse(HttpStatusCode.NotFound);
+            }
+
+            //if there's nothing to sort just return ok
+            if (sorted.IdSortOrder.Length == 0)
+            {
+                return Request.CreateResponse(HttpStatusCode.OK);
+            }
+
+            try
+            {
+                var contentService = Services.ContentService;
+
+                // Save content with new sort order and update content xml in db accordingly
+                if (contentService.Sort(sorted.IdSortOrder, Security.CurrentUser.Id) == false)
+                {
+                    LogHelper.Warn<ContentController>("Content sorting failed, this was probably caused by an event being cancelled");
+                    return Request.CreateValidationErrorResponse("Content sorting failed, this was probably caused by an event being cancelled");
+                }
+                return Request.CreateResponse(HttpStatusCode.OK);
+            }
+            catch (Exception ex)
+            {
+                LogHelper.Error<ContentController>("Could not update content sort order", ex);
+                throw;
+            }
+        }
+
+        /// <summary>
+        /// Change the sort order for media
+        /// </summary>
+        /// <param name="move"></param>
+        /// <returns></returns>
+        [EnsureUserPermissionForContent("move.ParentId", 'M')]
+        public HttpResponseMessage PostMove(MoveOrCopy move)
+        {
+            var toMove = ValidateMoveOrCopy(move);
+
+            Services.ContentService.Move(toMove, move.ParentId, Security.CurrentUser.Id);
+
+            var response = Request.CreateResponse(HttpStatusCode.OK);
+            response.Content = new StringContent(toMove.Path, Encoding.UTF8, "application/json");
+            return response;
+        }
+
+        /// <summary>
+        /// Copies a content item and places the copy as a child of a given parent Id
+        /// </summary>
+        /// <param name="copy"></param>
+        /// <returns></returns>
+        [EnsureUserPermissionForContent("copy.ParentId", 'C')]
+        public HttpResponseMessage PostCopy(MoveOrCopy copy)
+        {
+            var toCopy = ValidateMoveOrCopy(copy);
+
+            var c = Services.ContentService.Copy(toCopy, copy.ParentId, copy.RelateToOriginal, copy.Recursive, Security.CurrentUser.Id);
+
+            var response = Request.CreateResponse(HttpStatusCode.OK);
+            response.Content = new StringContent(c.Path, Encoding.UTF8, "application/json");
+            return response;
+        }
+
+        /// <summary>
+        /// Unpublishes a node with a given Id and returns the unpublished entity
+        /// </summary>
+        /// <param name="id"></param>
+        /// <returns></returns>
+        [EnsureUserPermissionForContent("id", 'U')]
+        [OutgoingEditorModelEvent]
+        public ContentItemDisplay PostUnPublish(int id)
+        {
+            var foundContent = GetObjectFromRequest(() => Services.ContentService.GetById(id));
+
+            if (foundContent == null)
+                HandleContentNotFound(id);
+
+            var unpublishResult = Services.ContentService.WithResult().UnPublish(foundContent, Security.CurrentUser.Id);
+
+            var content = AutoMapperExtensions.MapWithUmbracoContext<IContent, ContentItemDisplay>(foundContent, UmbracoContext);
+
+            if (unpublishResult == false)
+            {
+                AddCancelMessage(content);
+                throw new HttpResponseException(Request.CreateValidationErrorResponse(content));
+            }
+            else
+            {
+                content.AddSuccessNotification(Services.TextService.Localize("content/unPublish"), Services.TextService.Localize("speechBubbles/contentUnpublished"));
+                return content;
+            }
+        }
+
+        /// <summary>
+        /// Maps the dto property values to the persisted model
+        /// </summary>
+        /// <param name="contentItem"></param>
+        private void MapPropertyValues(ContentItemSave contentItem)
+        {
+            UpdateName(contentItem);
+
+            //TODO: We need to support 'send to publish'
+
+            contentItem.PersistedContent.ExpireDate = contentItem.ExpireDate;
+            contentItem.PersistedContent.ReleaseDate = contentItem.ReleaseDate;
+            //only set the template if it didn't change
+            var templateChanged = (contentItem.PersistedContent.Template == null && contentItem.TemplateAlias.IsNullOrWhiteSpace() == false)
+                                                        || (contentItem.PersistedContent.Template != null && contentItem.PersistedContent.Template.Alias != contentItem.TemplateAlias)
+                                                        || (contentItem.PersistedContent.Template != null && contentItem.TemplateAlias.IsNullOrWhiteSpace());
+            if (templateChanged)
+            {
+                var template = Services.FileService.GetTemplate(contentItem.TemplateAlias);
+                if (template == null && contentItem.TemplateAlias.IsNullOrWhiteSpace() == false)
+                {
+                    //ModelState.AddModelError("Template", "No template exists with the specified alias: " + contentItem.TemplateAlias);
+                    LogHelper.Warn<ContentController>("No template exists with the specified alias: " + contentItem.TemplateAlias);
+                }
+                else
+                {
+                    //NOTE: this could be null if there was a template and the posted template is null, this should remove the assigned template
+                    contentItem.PersistedContent.Template = template;
+                }
+            }
+
+            base.MapPropertyValues(contentItem);
+        }
+
+        /// <summary>
+        /// Ensures the item can be moved/copied to the new location
+        /// </summary>
+        /// <param name="model"></param>
+        /// <returns></returns>
+        private IContent ValidateMoveOrCopy(MoveOrCopy model)
+        {
+            if (model == null)
+            {
+                throw new HttpResponseException(HttpStatusCode.NotFound);
+            }
+
+            var contentService = Services.ContentService;
+            var toMove = contentService.GetById(model.Id);
+            if (toMove == null)
+            {
+                throw new HttpResponseException(HttpStatusCode.NotFound);
+            }
+            if (model.ParentId < 0)
+            {
+                //cannot move if the content item is not allowed at the root
+                if (toMove.ContentType.AllowedAsRoot == false)
+                {
+                    throw new HttpResponseException(
+                            Request.CreateNotificationValidationErrorResponse(
+                                    Services.TextService.Localize("moveOrCopy/notAllowedAtRoot")));
+                }
+            }
+            else
+            {
+                var parent = contentService.GetById(model.ParentId);
+                if (parent == null)
+                {
+                    throw new HttpResponseException(HttpStatusCode.NotFound);
+                }
+
+                //check if the item is allowed under this one
+                if (parent.ContentType.AllowedContentTypes.Select(x => x.Id).ToArray()
+                        .Any(x => x.Value == toMove.ContentType.Id) == false)
+                {
+                    throw new HttpResponseException(
+                            Request.CreateNotificationValidationErrorResponse(
+                                    Services.TextService.Localize("moveOrCopy/notAllowedByContentType")));
+                }
+
+                // Check on paths
+                if ((string.Format(",{0},", parent.Path)).IndexOf(string.Format(",{0},", toMove.Id), StringComparison.Ordinal) > -1)
+                {
+                    throw new HttpResponseException(
+                            Request.CreateNotificationValidationErrorResponse(
+                                    Services.TextService.Localize("moveOrCopy/notAllowedByPath")));
+                }
+            }
+
+            return toMove;
+        }
+
+        private void ShowMessageForPublishStatus(PublishStatus status, INotificationModel display, DateTime? expireDate)
+        {
+            switch (status.StatusType)
+            {
+                case PublishStatusType.Success:
+                case PublishStatusType.SuccessAlreadyPublished:
+                    display.AddSuccessNotification(
+                            Services.TextService.Localize("speechBubbles/editContentPublishedHeader"),
+                            expireDate.HasValue
+                                ? Services.TextService.Localize("speechBubbles/editContentPublishedWithExpireDateText", new [] { expireDate.Value.ToLongDateString(), expireDate.Value.ToShortTimeString() })
+                                : Services.TextService.Localize("speechBubbles/editContentPublishedText")
+                    );
+                    break;
+                case PublishStatusType.FailedPathNotPublished:
+                    display.AddWarningNotification(
+                            Services.TextService.Localize("publish"),
+                            Services.TextService.Localize("publish/contentPublishedFailedByParent",
+                                    new[] { string.Format("{0} ({1})", status.ContentItem.Name, status.ContentItem.Id) }).Trim());
+                    break;
+                case PublishStatusType.FailedCancelledByEvent:
+                    AddCancelMessage(display, "publish", "speechBubbles/contentPublishedFailedByEvent");
+                    break;
+                case PublishStatusType.FailedAwaitingRelease:
+                    display.AddWarningNotification(
+                            Services.TextService.Localize("publish"),
+                            Services.TextService.Localize("publish/contentPublishedFailedAwaitingRelease",
+                                    new[] { string.Format("{0} ({1})", status.ContentItem.Name, status.ContentItem.Id) }).Trim());
+                    break;
+                case PublishStatusType.FailedHasExpired:
+                    display.AddWarningNotification(
+                            Services.TextService.Localize("publish"),
+                            Services.TextService.Localize("publish/contentPublishedFailedExpired",
+                                    new[]
+                                    {
+                                                                string.Format("{0} ({1})", status.ContentItem.Name, status.ContentItem.Id),
+                                    }).Trim());
+                    break;
+                case PublishStatusType.FailedIsTrashed:
+                    //TODO: We should add proper error messaging for this!
+                    break;
+                case PublishStatusType.FailedContentInvalid:
+                    display.AddWarningNotification(
+                            Services.TextService.Localize("publish"),
+                            Services.TextService.Localize("publish/contentPublishedFailedInvalid",
+                                    new[]
+                                    {
+                                                                string.Format("{0} ({1})", status.ContentItem.Name, status.ContentItem.Id),
+                                                                string.Join(",", status.InvalidProperties.Select(x => x.Alias))
+                                    }).Trim());
+                    break;
+                default:
+                    throw new IndexOutOfRangeException();
+            }
+        }
+
+
+        /// <summary>
+        /// Performs a permissions check for the user to check if it has access to the node based on
+        /// start node and/or permissions for the node
+        /// </summary>
+        /// <param name="storage">The storage to add the content item to so it can be reused</param>
+        /// <param name="user"></param>
+        /// <param name="userService"></param>
+        /// <param name="contentService"></param>
+        /// <param name="entityService"></param>
+        /// <param name="nodeId">The content to lookup, if the contentItem is not specified</param>
+        /// <param name="permissionsToCheck"></param>
+        /// <param name="contentItem">Specifies the already resolved content item to check against</param>
+        /// <returns></returns>
+        internal static bool CheckPermissions(
+                IDictionary<string, object> storage,
+                IUser user,
+                IUserService userService,
+                IContentService contentService,
+                IEntityService entityService,
+                int nodeId,
+                char[] permissionsToCheck = null,
+                IContent contentItem = null)
+        {
+            if (storage == null) throw new ArgumentNullException("storage");
+            if (user == null) throw new ArgumentNullException("user");
+            if (userService == null) throw new ArgumentNullException("userService");
+            if (contentService == null) throw new ArgumentNullException("contentService");
+            if (entityService == null) throw new ArgumentNullException("entityService");
+
+            if (contentItem == null && nodeId != Constants.System.Root && nodeId != Constants.System.RecycleBinContent)
+            {
+                contentItem = contentService.GetById(nodeId);
+                //put the content item into storage so it can be retreived
+                // in the controller (saves a lookup)
+                storage[typeof(IContent).ToString()] = contentItem;
+            }
+
+            if (contentItem == null && nodeId != Constants.System.Root && nodeId != Constants.System.RecycleBinContent)
+            {
+                throw new HttpResponseException(HttpStatusCode.NotFound);
+            }
+
+            var hasPathAccess = (nodeId == Constants.System.Root)
+                ? user.HasContentRootAccess(entityService)
+                : (nodeId == Constants.System.RecycleBinContent)
+                    ? user.HasContentBinAccess(entityService)
+                    : user.HasPathAccess(contentItem, entityService);
+
+            if (hasPathAccess == false)
+            {
+                return false;
+            }
+
+            if (permissionsToCheck == null || permissionsToCheck.Length == 0)
+            {
+                return true;
+            }
+
+            //get the implicit/inherited permissions for the user for this path,
+            //if there is no content item for this id, than just use the id as the path (i.e. -1 or -20)
+            var path = contentItem != null ? contentItem.Path : nodeId.ToString();
+            var permission = userService.GetPermissionsForPath(user, path);
+
+            var allowed = true;
+            foreach (var p in permissionsToCheck)
+            {
+                if (permission == null
+                    || permission.GetAllPermissions().Contains(p.ToString(CultureInfo.InvariantCulture)) == false)
+                {
+                    allowed = false;
+                }
+            }
+            return allowed;
+        }
+
+        [EnsureUserPermissionForContent("contentId", 'F')]
+        public IEnumerable<NotifySetting> GetNotificationOptions(int contentId)
+        {
+            var notifications = new List<NotifySetting>();
+            if (contentId <= 0) throw new HttpResponseException(Request.CreateResponse(HttpStatusCode.NotFound));
+
+            var content = Services.ContentService.GetById(contentId);
+            if (content == null) throw new HttpResponseException(Request.CreateResponse(HttpStatusCode.NotFound));
+
+            var actionList = ActionsResolver.Current.Actions;
+            foreach (var a in actionList)
+            {
+                if (a.ShowInNotifier)
+                {
+                    NotifySetting n = new NotifySetting
+                    {
+                        Name = ui.Text("actions", a.Alias),
+                        Checked = (UmbracoUser.GetNotifications(content.Path).IndexOf(a.Letter) > -1),
+                        NotifyCode = a.Letter.ToString()
+                    };
+                    notifications.Add(n);
+                }
+            }
+            return notifications;
+        }
+
+        public void PostNotificationOptions(int contentId, string notifyOptions = "")
+        {
+            if (contentId <= 0) throw new HttpResponseException(Request.CreateResponse(HttpStatusCode.NotFound));
+            var content = Services.ContentService.GetById(contentId);
+
+            if (content == null) throw new HttpResponseException(Request.CreateResponse(HttpStatusCode.NotFound));
+            var node = new CMSNode(contentId);
+
+            global::umbraco.cms.businesslogic.workflow.Notification.UpdateNotifications(UmbracoUser, node, notifyOptions ?? "");
+        }
+    }
+}

From 8c46984a2fbe34c9beb903919be1be421ffa539d Mon Sep 17 00:00:00 2001
From: Shannon Deminick <sdeminick@gmail.com>
Date: Thu, 19 Sep 2019 18:46:02 +1000
Subject: [PATCH 10/14] U4-9912 Previewing without changing creates new version
 (#1943)

(cherry picked from commit 7d0d5b9c939a9d9578c9e112a2f1d90bac6df777)
---
 src/Umbraco.Core/Services/ContentService.cs  | 5894 +++++++++---------
 src/Umbraco.Web/Editors/ContentController.cs | 2442 ++++----
 2 files changed, 4172 insertions(+), 4164 deletions(-)

diff --git a/src/Umbraco.Core/Services/ContentService.cs b/src/Umbraco.Core/Services/ContentService.cs
index 2994bcc4f6..0b50eb1f65 100644
--- a/src/Umbraco.Core/Services/ContentService.cs
+++ b/src/Umbraco.Core/Services/ContentService.cs
@@ -1,2945 +1,2949 @@
-using System;
-using System.Collections.Generic;
-using System.ComponentModel;
-using System.Globalization;
-using System.IO;
-using System.Linq;
-using System.Text.RegularExpressions;
-using System.Threading;
-using System.Xml;
-using System.Xml.Linq;
-using Umbraco.Core.Events;
-using Umbraco.Core.Logging;
-using Umbraco.Core.Models;
-using Umbraco.Core.Models.Membership;
-using Umbraco.Core.Models.Rdbms;
-using Umbraco.Core.Persistence;
-using Umbraco.Core.Persistence.DatabaseModelDefinitions;
-using Umbraco.Core.Persistence.Querying;
-using Umbraco.Core.Persistence.Repositories;
-using Umbraco.Core.Persistence.UnitOfWork;
-using Umbraco.Core.Publishing;
-
-namespace Umbraco.Core.Services
-{
-    /// <summary>
-    /// Represents the Content Service, which is an easy access to operations involving <see cref="IContent"/>
-    /// </summary>
-    public class ContentService : ScopeRepositoryService, IContentService, IContentServiceOperations
-    {
-        private readonly IPublishingStrategy2 _publishingStrategy;
-        private readonly EntityXmlSerializer _entitySerializer = new EntityXmlSerializer();
-        private readonly IDataTypeService _dataTypeService;
-        private readonly IUserService _userService;
-
-        //Support recursive locks because some of the methods that require locking call other methods that require locking.
-        //for example, the Move method needs to be locked but this calls the Save method which also needs to be locked.
-        private static readonly ReaderWriterLockSlim Locker = new ReaderWriterLockSlim(LockRecursionPolicy.SupportsRecursion);
-        private static readonly Regex AnchorRegex = new Regex("<a id=\"(.*?)\">", RegexOptions.Compiled);
-
-        public ContentService(
-            IDatabaseUnitOfWorkProvider provider,
-            RepositoryFactory repositoryFactory,
-            ILogger logger,
-            IEventMessagesFactory eventMessagesFactory,
-            IDataTypeService dataTypeService,
-            IUserService userService)
-            : base(provider, repositoryFactory, logger, eventMessagesFactory)
-        {
-            if (dataTypeService == null) throw new ArgumentNullException("dataTypeService");
-            if (userService == null) throw new ArgumentNullException("userService");
-            _publishingStrategy = new PublishingStrategy(UowProvider.ScopeProvider, eventMessagesFactory, logger);
-            _dataTypeService = dataTypeService;
-            _userService = userService;
-        }
-
-        #region Static Queries
-
-        private IQuery<IContent> _notTrashedQuery;
-
-        #endregion
-
-        public int CountPublished(string contentTypeAlias = null)
-        {
-            using (var uow = UowProvider.GetUnitOfWork(readOnly: true))
-            {
-                var repository = RepositoryFactory.CreateContentRepository(uow);
-                return repository.CountPublished(contentTypeAlias);
-            }
-        }
-
-        public int Count(string contentTypeAlias = null)
-        {
-            using (var uow = UowProvider.GetUnitOfWork(readOnly: true))
-            {
-                var repository = RepositoryFactory.CreateContentRepository(uow);
-                return repository.Count(contentTypeAlias);
-            }
-        }
-
-        public int CountChildren(int parentId, string contentTypeAlias = null)
-        {
-            using (var uow = UowProvider.GetUnitOfWork(readOnly: true))
-            {
-                var repository = RepositoryFactory.CreateContentRepository(uow);
-                return repository.CountChildren(parentId, contentTypeAlias);
-            }
-        }
-
-        public int CountDescendants(int parentId, string contentTypeAlias = null)
-        {
-            using (var uow = UowProvider.GetUnitOfWork(readOnly: true))
-            {
-                var repository = RepositoryFactory.CreateContentRepository(uow);
-                return repository.CountDescendants(parentId, contentTypeAlias);
-            }
-        }
-
-        /// <summary>
-        /// Used to bulk update the permissions set for a content item. This will replace all permissions
-        /// assigned to an entity with a list of user id & permission pairs.
-        /// </summary>
-        /// <param name="permissionSet"></param>
-        public void ReplaceContentPermissions(EntityPermissionSet permissionSet)
-        {
-            using (var uow = UowProvider.GetUnitOfWork())
-            {
-                var repository = RepositoryFactory.CreateContentRepository(uow);
-                repository.ReplaceContentPermissions(permissionSet);
-                uow.Commit();
-            }
-        }
-
-        /// <summary>
-        /// Assigns a single permission to the current content item for the specified group ids
-        /// </summary>
-        /// <param name="entity"></param>
-        /// <param name="permission"></param>
-        /// <param name="groupIds"></param>
-        public void AssignContentPermission(IContent entity, char permission, IEnumerable<int> groupIds)
-        {
-            using (var uow = UowProvider.GetUnitOfWork())
-            {
-                var repository = RepositoryFactory.CreateContentRepository(uow);
-                repository.AssignEntityPermission(entity, permission, groupIds);
-                uow.Commit();
-            }
-        }
-
-        /// <summary>
-        /// Returns implicit/inherited permissions assigned to the content item for all user groups
-        /// </summary>
-        /// <param name="content"></param>
-        /// <returns></returns>
-        public EntityPermissionCollection GetPermissionsForEntity(IContent content)
-        {
-            using (var uow = UowProvider.GetUnitOfWork(readOnly: true))
-            {
-                var repository = RepositoryFactory.CreateContentRepository(uow);
-                return repository.GetPermissionsForEntity(content.Id);
-            }
-        }
-
-        /// <summary>
-        /// Creates an <see cref="IContent"/> object using the alias of the <see cref="IContentType"/>
-        /// that this Content should based on.
-        /// </summary>
-        /// <remarks>
-        /// Note that using this method will simply return a new IContent without any identity
-        /// as it has not yet been persisted. It is intended as a shortcut to creating new content objects
-        /// that does not invoke a save operation against the database.
-        /// </remarks>
-        /// <param name="name">Name of the Content object</param>
-        /// <param name="parentId">Id of Parent for the new Content</param>
-        /// <param name="contentTypeAlias">Alias of the <see cref="IContentType"/></param>
-        /// <param name="userId">Optional id of the user creating the content</param>
-        /// <returns><see cref="IContent"/></returns>
-        public IContent CreateContent(string name, Guid parentId, string contentTypeAlias, int userId = 0)
-        {
-            var parent = GetById(parentId);
-            return CreateContent(name, parent, contentTypeAlias, userId);
-        }
-
-        /// <summary>
-        /// Creates an <see cref="IContent"/> object using the alias of the <see cref="IContentType"/>
-        /// that this Content should based on.
-        /// </summary>
-        /// <remarks>
-        /// Note that using this method will simply return a new IContent without any identity
-        /// as it has not yet been persisted. It is intended as a shortcut to creating new content objects
-        /// that does not invoke a save operation against the database.
-        /// </remarks>
-        /// <param name="name">Name of the Content object</param>
-        /// <param name="parentId">Id of Parent for the new Content</param>
-        /// <param name="contentTypeAlias">Alias of the <see cref="IContentType"/></param>
-        /// <param name="userId">Optional id of the user creating the content</param>
-        /// <returns><see cref="IContent"/></returns>
-        public IContent CreateContent(string name, int parentId, string contentTypeAlias, int userId = 0)
-        {
-            var contentType = FindContentTypeByAlias(contentTypeAlias);
-            var content = new Content(name, parentId, contentType);
-            var parent = GetById(content.ParentId);
-            content.Path = string.Concat(parent.IfNotNull(x => x.Path, content.ParentId.ToString()), ",", content.Id);
-
-            using (var uow = UowProvider.GetUnitOfWork())
-            {
-                var newEventArgs = new NewEventArgs<IContent>(content, contentTypeAlias, parentId);
-                if (uow.Events.DispatchCancelable(Creating, this, newEventArgs))
-                {
-                    uow.Commit();
-                    content.WasCancelled = true;
-                    return content;
-                }
-
-                content.CreatorId = userId;
-                content.WriterId = userId;
-                newEventArgs.CanCancel = false;
-                uow.Events.Dispatch(Created, this, newEventArgs);
-
-                uow.Commit();
-            }
-
-            return content;
-        }
-
-        /// <summary>
-        /// Creates an <see cref="IContent"/> object using the alias of the <see cref="IContentType"/>
-        /// that this Content should based on.
-        /// </summary>
-        /// <remarks>
-        /// Note that using this method will simply return a new IContent without any identity
-        /// as it has not yet been persisted. It is intended as a shortcut to creating new content objects
-        /// that does not invoke a save operation against the database.
-        /// </remarks>
-        /// <param name="name">Name of the Content object</param>
-        /// <param name="parent">Parent <see cref="IContent"/> object for the new Content</param>
-        /// <param name="contentTypeAlias">Alias of the <see cref="IContentType"/></param>
-        /// <param name="userId">Optional id of the user creating the content</param>
-        /// <returns><see cref="IContent"/></returns>
-        public IContent CreateContent(string name, IContent parent, string contentTypeAlias, int userId = 0)
-        {
-            if (parent == null) throw new ArgumentNullException("parent");
-
-            var contentType = FindContentTypeByAlias(contentTypeAlias);
-            var content = new Content(name, parent, contentType);
-            content.Path = string.Concat(parent.Path, ",", content.Id);
-
-            using (var uow = UowProvider.GetUnitOfWork())
-            {
-                var newEventArgs = new NewEventArgs<IContent>(content, contentTypeAlias, parent);
-                if (uow.Events.DispatchCancelable(Creating, this, newEventArgs))
-                {
-                    uow.Commit();
-                    content.WasCancelled = true;
-                    return content;
-                }
-
-                content.CreatorId = userId;
-                content.WriterId = userId;
-                newEventArgs.CanCancel = false;
-                uow.Events.Dispatch(Created, this, newEventArgs);
-
-                uow.Commit();
-            }
-
-            return content;
-        }
-
-        /// <summary>
-        /// Creates and saves an <see cref="IContent"/> object using the alias of the <see cref="IContentType"/>
-        /// that this Content should based on.
-        /// </summary>
-        /// <remarks>
-        /// This method returns an <see cref="IContent"/> object that has been persisted to the database
-        /// and therefor has an identity.
-        /// </remarks>
-        /// <param name="name">Name of the Content object</param>
-        /// <param name="parentId">Id of Parent for the new Content</param>
-        /// <param name="contentTypeAlias">Alias of the <see cref="IContentType"/></param>
-        /// <param name="userId">Optional id of the user creating the content</param>
-        /// <returns><see cref="IContent"/></returns>
-        public IContent CreateContentWithIdentity(string name, int parentId, string contentTypeAlias, int userId = 0)
-        {
-            var contentType = FindContentTypeByAlias(contentTypeAlias);
-            var content = new Content(name, parentId, contentType);
-
-            using (var uow = UowProvider.GetUnitOfWork())
-            {
-                //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.
-                var newEventArgs = new NewEventArgs<IContent>(content, contentTypeAlias, parentId);
-                if (uow.Events.DispatchCancelable(Creating, this, newEventArgs))
-                {
-                    uow.Commit();
-                    content.WasCancelled = true;
-                    return content;
-                }
-
-                var saveEventArgs = new SaveEventArgs<IContent>(content);
-                if (uow.Events.DispatchCancelable(Saving, this, saveEventArgs, "Saving"))
-                {
-                    uow.Commit();
-                    content.WasCancelled = true;
-                    return content;
-                }
-
-                var repository = RepositoryFactory.CreateContentRepository(uow);
-                content.CreatorId = userId;
-                content.WriterId = userId;
-
-                repository.AddOrUpdate(content);
-                repository.AddOrUpdatePreviewXml(content, c => _entitySerializer.Serialize(this, _dataTypeService, _userService, c));
-                saveEventArgs.CanCancel = false;
-                uow.Events.Dispatch(Saved, this, saveEventArgs, "Saved");
-                newEventArgs.CanCancel = false;
-                uow.Events.Dispatch(Created, this, newEventArgs);
-
-                Audit(uow, AuditType.New, string.Format("Content '{0}' was created with Id {1}", name, content.Id), content.CreatorId, content.Id);
-                uow.Commit();
-            }
-
-            return content;
-        }
-
-        public IEnumerable<string> GetAnchorValuesFromRTEs(int id)
-        {
-            var result = new List<string>();
-
-            var content = GetById(id);
-
-            foreach (var contentProperty in content.Properties)
-            {
-                if (contentProperty.PropertyType.PropertyEditorAlias.InvariantEquals(Constants.PropertyEditors.TinyMCEAlias))
-                {
-                    var value = contentProperty.Value?.ToString();
-
-                    if (!string.IsNullOrEmpty(value))
-                    {
-                        result.AddRange(GetAnchorValuesFromRTEContent(value));
-                    }
-
-                }
-            }
-
-
-            return result;
-        }
-
-
-        public IEnumerable<string> GetAnchorValuesFromRTEContent(string rteContent)
-        {
-            var result = new List<string>();
-
-            var matches = AnchorRegex.Matches(rteContent);
-
-            foreach (Match match in matches)
-            {
-                result.Add(match.Value.Split('\"')[1]);
-            }
-
-            return result;
-        }
-
-        /// <summary>
-        /// Creates and saves an <see cref="IContent"/> object using the alias of the <see cref="IContentType"/>
-        /// that this Content should based on.
-        /// </summary>
-        /// <remarks>
-        /// This method returns an <see cref="IContent"/> object that has been persisted to the database
-        /// and therefor has an identity.
-        /// </remarks>
-        /// <param name="name">Name of the Content object</param>
-        /// <param name="parent">Parent <see cref="IContent"/> object for the new Content</param>
-        /// <param name="contentTypeAlias">Alias of the <see cref="IContentType"/></param>
-        /// <param name="userId">Optional id of the user creating the content</param>
-        /// <returns><see cref="IContent"/></returns>
-        public IContent CreateContentWithIdentity(string name, IContent parent, string contentTypeAlias, int userId = 0)
-        {
-            if (parent == null) throw new ArgumentNullException("parent");
-
-            var contentType = FindContentTypeByAlias(contentTypeAlias);
-            var content = new Content(name, parent, contentType);
-
-            using (var uow = UowProvider.GetUnitOfWork())
-            {
-                //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.
-                var newEventArgs = new NewEventArgs<IContent>(content, contentTypeAlias, parent);
-                if (uow.Events.DispatchCancelable(Creating, this, newEventArgs))
-                {
-                    uow.Commit();
-                    content.WasCancelled = true;
-                    return content;
-                }
-
-                var saveEventArgs = new SaveEventArgs<IContent>(content);
-                if (uow.Events.DispatchCancelable(Saving, this, saveEventArgs, "Saving"))
-                {
-                    uow.Commit();
-                    content.WasCancelled = true;
-                    return content;
-                }
-
-                var repository = RepositoryFactory.CreateContentRepository(uow);
-                content.CreatorId = userId;
-                content.WriterId = userId;
-
-                repository.AddOrUpdate(content);
-                repository.AddOrUpdatePreviewXml(content, c => _entitySerializer.Serialize(this, _dataTypeService, _userService, c));
-                saveEventArgs.CanCancel = false;
-                uow.Events.Dispatch(Saved, this, saveEventArgs, "Saved");
-                newEventArgs.CanCancel = false;
-                uow.Events.Dispatch(Created, this, newEventArgs);
-
-                Audit(uow, AuditType.New, string.Format("Content '{0}' was created with Id {1}", name, content.Id), content.CreatorId, content.Id);
-                uow.Commit();
-            }
-
-            return content;
-        }
-
-        /// <summary>
-        /// Gets an <see cref="IContent"/> object by Id
-        /// </summary>
-        /// <param name="id">Id of the Content to retrieve</param>
-        /// <returns><see cref="IContent"/></returns>
-        public IContent GetById(int id)
-        {
-            using (var uow = UowProvider.GetUnitOfWork(readOnly: true))
-            {
-                var repository = RepositoryFactory.CreateContentRepository(uow);
-                return repository.Get(id);
-            }
-        }
-
-        /// <summary>
-        /// Gets <see cref="IContent"/> objects by Ids
-        /// </summary>
-        /// <param name="ids">Ids of the Content to retrieve</param>
-        /// <returns><see cref="IContent"/></returns>
-        public IEnumerable<IContent> GetByIds(IEnumerable<int> ids)
-        {
-            var idsArray = ids.ToArray();
-            if (idsArray.Length == 0) return Enumerable.Empty<IContent>();
-
-            using (var uow = UowProvider.GetUnitOfWork(readOnly: true))
-            {
-                var repository = RepositoryFactory.CreateContentRepository(uow);
-
-                // ensure that the result has the order based on the ids passed in
-                var result = repository.GetAll(idsArray);
-                var content = result.ToDictionary(x => x.Id, x => x);
-
-                var sortedResult = idsArray.Select(x =>
-                {
-                    IContent c;
-                    return content.TryGetValue(x, out c) ? c : null;
-                }).WhereNotNull();
-
-                return sortedResult;
-            }
-        }
-
-        /// <summary>
-        /// Gets <see cref="IContent"/> objects by Ids
-        /// </summary>
-        /// <param name="ids">Ids of the Content to retrieve</param>
-        /// <returns><see cref="IContent"/></returns>
-        public IEnumerable<IContent> GetByIds(IEnumerable<Guid> ids)
-        {
-            var idsArray = ids.ToArray();
-            if (idsArray.Length == 0) return Enumerable.Empty<IContent>();
-
-            using (var uow = UowProvider.GetUnitOfWork(readOnly: true))
-            {
-                var repository = RepositoryFactory.CreateContentRepository(uow);
-
-                // ensure that the result has the order based on the ids passed in
-                var result = repository.GetAll(idsArray);
-                var content = result.ToDictionary(x => x.Key, x => x);
-
-                var sortedResult = idsArray.Select(x =>
-                {
-                    IContent c;
-                    return content.TryGetValue(x, out c) ? c : null;
-                }).WhereNotNull();
-
-                return sortedResult;
-            }
-        }
-
-        /// <summary>
-        /// Gets an <see cref="IContent"/> object by its 'UniqueId'
-        /// </summary>
-        /// <param name="key">Guid key of the Content to retrieve</param>
-        /// <returns><see cref="IContent"/></returns>
-        public IContent GetById(Guid key)
-        {
-            using (var uow = UowProvider.GetUnitOfWork(readOnly: true))
-            {
-                var repository = RepositoryFactory.CreateContentRepository(uow);
-                return repository.Get(key);
-            }
-        }
-
-        /// <summary>
-        /// Gets a collection of <see cref="IContent"/> objects by the Id of the <see cref="IContentType"/>
-        /// </summary>
-        /// <param name="id">Id of the <see cref="IContentType"/></param>
-        /// <returns>An Enumerable list of <see cref="IContent"/> objects</returns>
-        public IEnumerable<IContent> GetContentOfContentType(int id)
-        {
-            using (var uow = UowProvider.GetUnitOfWork(readOnly: true))
-            {
-                var repository = RepositoryFactory.CreateContentRepository(uow);
-                var query = Query<IContent>.Builder.Where(x => x.ContentTypeId == id);
-                return repository.GetByQuery(query);
-            }
-        }
-
-        internal IEnumerable<IContent> GetPublishedContentOfContentType(int id)
-        {
-            using (var uow = UowProvider.GetUnitOfWork(readOnly: true))
-            {
-                var repository = RepositoryFactory.CreateContentRepository(uow);
-                var query = Query<IContent>.Builder.Where(x => x.ContentTypeId == id);
-                return repository.GetByPublishedVersion(query);
-            }
-        }
-
-        /// <summary>
-        /// Gets a collection of <see cref="IContent"/> objects by Level
-        /// </summary>
-        /// <param name="level">The level to retrieve Content from</param>
-        /// <returns>An Enumerable list of <see cref="IContent"/> objects</returns>
-        public IEnumerable<IContent> GetByLevel(int level)
-        {
-            using (var uow = UowProvider.GetUnitOfWork(readOnly: true))
-            {
-                var repository = RepositoryFactory.CreateContentRepository(uow);
-                var query = Query<IContent>.Builder.Where(x => x.Level == level && x.Path.StartsWith(Constants.System.RecycleBinContent.ToInvariantString()) == false);
-                return repository.GetByQuery(query);
-            }
-        }
-
-        /// <summary>
-        /// Gets a specific version of an <see cref="IContent"/> item.
-        /// </summary>
-        /// <param name="versionId">Id of the version to retrieve</param>
-        /// <returns>An <see cref="IContent"/> item</returns>
-        public IContent GetByVersion(Guid versionId)
-        {
-            using (var uow = UowProvider.GetUnitOfWork(readOnly: true))
-            {
-                var repository = RepositoryFactory.CreateContentRepository(uow);
-                return repository.GetByVersion(versionId);
-            }
-        }
-
-
-        /// <summary>
-        /// Gets a collection of an <see cref="IContent"/> objects versions by Id
-        /// </summary>
-        /// <param name="id"></param>
-        /// <returns>An Enumerable list of <see cref="IContent"/> objects</returns>
-        public IEnumerable<IContent> GetVersions(int id)
-        {
-            using (var uow = UowProvider.GetUnitOfWork(readOnly: true))
-            {
-                var repository = RepositoryFactory.CreateContentRepository(uow);
-                return repository.GetAllVersions(id);
-            }
-        }
-
-        /// <summary>
-        /// Gets a list of all version Ids for the given content item ordered so latest is first
-        /// </summary>
-        /// <param name="id"></param>
-        /// <param name="maxRows">The maximum number of rows to return</param>
-        /// <returns></returns>
-        public IEnumerable<Guid> GetVersionIds(int id, int maxRows)
-        {
-            using (var uow = UowProvider.GetUnitOfWork(readOnly: true))
-            {
-                var repository = RepositoryFactory.CreateContentRepository(uow);
-                return repository.GetVersionIds(id, maxRows);
-            }
-        }
-
-        /// <summary>
-        /// Gets a collection of <see cref="IContent"/> objects, which are ancestors of the current content.
-        /// </summary>
-        /// <param name="id">Id of the <see cref="IContent"/> to retrieve ancestors for</param>
-        /// <returns>An Enumerable list of <see cref="IContent"/> objects</returns>
-        public IEnumerable<IContent> GetAncestors(int id)
-        {
-            var content = GetById(id);
-            return GetAncestors(content);
-        }
-
-        /// <summary>
-        /// Gets a collection of <see cref="IContent"/> objects, which are ancestors of the current content.
-        /// </summary>
-        /// <param name="content"><see cref="IContent"/> to retrieve ancestors for</param>
-        /// <returns>An Enumerable list of <see cref="IContent"/> objects</returns>
-        public IEnumerable<IContent> GetAncestors(IContent content)
-        {
-            //null check otherwise we get exceptions
-            if (content.Path.IsNullOrWhiteSpace()) return Enumerable.Empty<IContent>();
-
-            var ids = content.Path.Split(',').Where(x => x != Constants.System.Root.ToInvariantString() && x != content.Id.ToString(CultureInfo.InvariantCulture)).Select(int.Parse).ToArray();
-            if (ids.Any() == false)
-                return new List<IContent>();
-
-            using (var uow = UowProvider.GetUnitOfWork(readOnly: true))
-            {
-                var repository = RepositoryFactory.CreateContentRepository(uow);
-                return repository.GetAll(ids);
-            }
-        }
-
-        /// <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>
-        /// <returns>An Enumerable list of <see cref="IContent"/> objects</returns>
-        public IEnumerable<IContent> GetChildren(int id)
-        {
-            using (var uow = UowProvider.GetUnitOfWork(readOnly: true))
-            {
-                var repository = RepositoryFactory.CreateContentRepository(uow);
-                var query = Query<IContent>.Builder.Where(x => x.ParentId == id);
-                return repository.GetByQuery(query).OrderBy(x => x.SortOrder);
-            }
-        }
-
-        [Obsolete("Use the overload with 'long' parameter types instead")]
-        [EditorBrowsable(EditorBrowsableState.Never)]
-        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;
-        }
-
-        /// <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="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, 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");
-
-            using (var uow = UowProvider.GetUnitOfWork(readOnly: true))
-            {
-                var repository = RepositoryFactory.CreateContentRepository(uow);
-
-                var query = Query<IContent>.Builder;
-                // always check for a parent - else it will also get decendants (and then you should use the GetPagedDescendants method)
-                query.Where(x => x.ParentId == id);
-
-                IQuery<IContent> filterQuery = null;
-                if (filter.IsNullOrWhiteSpace() == false)
-                {
-                    filterQuery = Query<IContent>.Builder.Where(x => x.Name.Contains(filter));
-                }
-                return repository.GetPagedResultsByQuery(query, pageIndex, pageSize, out totalChildren, orderBy, orderDirection, orderBySystemField, filterQuery);
-            }
-        }
-
-        [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");
-            using (var uow = UowProvider.GetUnitOfWork(readOnly: true))
-            {
-                var repository = RepositoryFactory.CreateContentRepository(uow);
-
-                // get query - if the id is System Root, then just get all
-                var query = Query<IContent>.Builder;
-                if (id != Constants.System.Root)
-                {
-                    var entityRepository = RepositoryFactory.CreateEntityRepository(uow);
-                    var contentPath = entityRepository.GetAllPaths(Constants.ObjectTypes.DocumentGuid, id).ToArray();
-                    if (contentPath.Length == 0)
-                    {
-                        totalChildren = 0;
-                        return Enumerable.Empty<IContent>();
-                    }
-                    query.Where(x => x.Path.SqlStartsWith(string.Format("{0},", contentPath[0].Path), TextColumnType.NVarchar));
-                }
-
-
-                // get filter
-                IQuery<IContent> filterQuery = null;
-                if (filter.IsNullOrWhiteSpace() == false)
-                    filterQuery = Query<IContent>.Builder.Where(x => x.Name.Contains(filter));
-
-                return repository.GetPagedResultsByQuery(query, pageIndex, pageSize, out totalChildren, orderBy, orderDirection, orderBySystemField, filterQuery);
-            }
-        }
-
-        /// <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 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, IQuery<IContent> filter)
-        {
-            Mandate.ParameterCondition(pageIndex >= 0, "pageIndex");
-            Mandate.ParameterCondition(pageSize > 0, "pageSize");
-
-            using (var uow = UowProvider.GetUnitOfWork(readOnly: true))
-            {
-                var repository = RepositoryFactory.CreateContentRepository(uow);
-
-                // get query - if the id is System Root, then just get all
-                var query = Query<IContent>.Builder;
-                if (id != Constants.System.Root)
-                {
-                    var entityRepository = RepositoryFactory.CreateEntityRepository(uow);
-                    var contentPath = entityRepository.GetAllPaths(Constants.ObjectTypes.DocumentGuid, id).ToArray();
-                    if (contentPath.Length == 0)
-                    {
-                        totalChildren = 0;
-                        return Enumerable.Empty<IContent>();
-                    }
-                    query.Where(x => x.Path.SqlStartsWith(string.Format("{0},", contentPath[0].Path), TextColumnType.NVarchar));
-                }
-
-                return repository.GetPagedResultsByQuery(query, pageIndex, pageSize, out totalChildren, orderBy, orderDirection, orderBySystemField, filter);
-            }
-        }
-
-        /// <summary>
-        /// Gets a collection of <see cref="IContent"/> objects by its name or partial name
-        /// </summary>
-        /// <param name="parentId">Id of the Parent to retrieve Children from</param>
-        /// <param name="name">Full or partial name of the children</param>
-        /// <returns>An Enumerable list of <see cref="IContent"/> objects</returns>
-        public IEnumerable<IContent> GetChildrenByName(int parentId, string name)
-        {
-            using (var uow = UowProvider.GetUnitOfWork(readOnly: true))
-            {
-                var repository = RepositoryFactory.CreateContentRepository(uow);
-
-                var query = Query<IContent>.Builder.Where(x => x.ParentId == parentId && x.Name.Contains(name));
-                return repository.GetByQuery(query);
-            }
-        }
-
-        /// <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>
-        /// <returns>An Enumerable list of <see cref="IContent"/> objects</returns>
-        public IEnumerable<IContent> GetDescendants(int id)
-        {
-            var content = GetById(id);
-            return content == null ? Enumerable.Empty<IContent>() : GetDescendants(content);
-        }
-
-        /// <summary>
-        /// Gets a collection of <see cref="IContent"/> objects by Parent Id
-        /// </summary>
-        /// <param name="content"><see cref="IContent"/> item to retrieve Descendants from</param>
-        /// <returns>An Enumerable list of <see cref="IContent"/> objects</returns>
-        public IEnumerable<IContent> GetDescendants(IContent content)
-        {
-            //This is a check to ensure that the path is correct for this entity to avoid problems like: http://issues.umbraco.org/issue/U4-9336 due to data corruption
-            if (content.ValidatePath() == false)
-                throw new InvalidDataException(string.Format("The content item {0} has an invalid path: {1} with parentID: {2}", content.Id, content.Path, content.ParentId));
-
-            using (var uow = UowProvider.GetUnitOfWork(readOnly: true))
-            {
-                var repository = RepositoryFactory.CreateContentRepository(uow);
-
-                var pathMatch = content.Path + ",";
-                var query = Query<IContent>.Builder.Where(x => x.Path.StartsWith(pathMatch) && x.Id != content.Id);
-                return repository.GetByQuery(query);
-            }
-        }
-
-        /// <summary>
-        /// Gets the parent of the current content as an <see cref="IContent"/> item.
-        /// </summary>
-        /// <param name="id">Id of the <see cref="IContent"/> to retrieve the parent from</param>
-        /// <returns>Parent <see cref="IContent"/> object</returns>
-        public IContent GetParent(int id)
-        {
-            var content = GetById(id);
-            return GetParent(content);
-        }
-
-        /// <summary>
-        /// Gets the parent of the current content as an <see cref="IContent"/> item.
-        /// </summary>
-        /// <param name="content"><see cref="IContent"/> to retrieve the parent from</param>
-        /// <returns>Parent <see cref="IContent"/> object</returns>
-        public IContent GetParent(IContent content)
-        {
-            if (content.ParentId == Constants.System.Root || content.ParentId == Constants.System.RecycleBinContent)
-                return null;
-
-            return GetById(content.ParentId);
-        }
-
-        /// <summary>
-        /// Gets the published version of an <see cref="IContent"/> item
-        /// </summary>
-        /// <param name="id">Id of the <see cref="IContent"/> to retrieve version from</param>
-        /// <returns>An <see cref="IContent"/> item</returns>
-        public IContent GetPublishedVersion(int id)
-        {
-            var version = GetVersions(id);
-            return version.FirstOrDefault(x => x.Published);
-        }
-
-        /// <summary>
-        /// Gets the published version of a <see cref="IContent"/> item.
-        /// </summary>
-        /// <param name="content">The content item.</param>
-        /// <returns>The published version, if any; otherwise, null.</returns>
-        public IContent GetPublishedVersion(IContent content)
-        {
-            if (content.Published) return content;
-            return content.HasPublishedVersion
-                ? GetByVersion(content.PublishedVersionGuid)
-                : null;
-        }
-
-        /// <summary>
-        /// Gets a collection of <see cref="IContent"/> objects, which reside at the first level / root
-        /// </summary>
-        /// <returns>An Enumerable list of <see cref="IContent"/> objects</returns>
-        public IEnumerable<IContent> GetRootContent()
-        {
-            using (var uow = UowProvider.GetUnitOfWork(readOnly: true))
-            {
-                var repository = RepositoryFactory.CreateContentRepository(uow);
-
-                var query = Query<IContent>.Builder.Where(x => x.ParentId == Constants.System.Root);
-                return repository.GetByQuery(query);
-            }
-        }
-
-        /// <summary>
-        /// Gets all published content items
-        /// </summary>
-        /// <returns></returns>
-        internal IEnumerable<IContent> GetAllPublished()
-        {
-            //create it once if it is needed (no need for locking here)
-            if (_notTrashedQuery == null)
-            {
-                _notTrashedQuery = Query<IContent>.Builder.Where(x => x.Trashed == false);
-            }
-
-            using (var uow = UowProvider.GetUnitOfWork(readOnly: true))
-            {
-                var repository = RepositoryFactory.CreateContentRepository(uow);
-                return repository.GetByPublishedVersion(_notTrashedQuery);
-            }
-        }
-
-        /// <summary>
-        /// Gets a collection of <see cref="IContent"/> objects, which has an expiration date less than or equal to today.
-        /// </summary>
-        /// <returns>An Enumerable list of <see cref="IContent"/> objects</returns>
-        public IEnumerable<IContent> GetContentForExpiration()
-        {
-            using (var uow = UowProvider.GetUnitOfWork(readOnly: true))
-            {
-                var repository = RepositoryFactory.CreateContentRepository(uow);
-                var query = Query<IContent>.Builder.Where(x => x.ExpireDate <= DateTime.Now);
-                return repository.GetByQuery(query).Where(x => x.HasPublishedVersion);
-            }
-        }
-
-        /// <summary>
-        /// Gets a collection of <see cref="IContent"/> objects, which has a release date less than or equal to today.
-        /// </summary>
-        /// <returns>An Enumerable list of <see cref="IContent"/> objects</returns>
-        public IEnumerable<IContent> GetContentForRelease()
-        {
-            using (var uow = UowProvider.GetUnitOfWork(readOnly: true))
-            {
-                var repository = RepositoryFactory.CreateContentRepository(uow);
-                var query = Query<IContent>.Builder.Where(x => x.Published == false && x.ReleaseDate <= DateTime.Now);
-                return repository.GetByQuery(query);
-            }
-        }
-
-        /// <summary>
-        /// Gets a collection of an <see cref="IContent"/> objects, which resides in the Recycle Bin
-        /// </summary>
-        /// <returns>An Enumerable list of <see cref="IContent"/> objects</returns>
-        public IEnumerable<IContent> GetContentInRecycleBin()
-        {
-            using (var uow = UowProvider.GetUnitOfWork(readOnly: true))
-            {
-                var repository = RepositoryFactory.CreateContentRepository(uow);
-                var query = Query<IContent>.Builder.Where(x => x.Path.StartsWith(Constants.System.RecycleBinContentPathPrefix));
-                return repository.GetByQuery(query);
-            }
-        }
-
-        /// <summary>
-        /// Checks whether an <see cref="IContent"/> item has any children
-        /// </summary>
-        /// <param name="id">Id of the <see cref="IContent"/></param>
-        /// <returns>True if the content has any children otherwise False</returns>
-        public bool HasChildren(int id)
-        {
-            return CountChildren(id) > 0;
-        }
-
-        internal int CountChildren(int id)
-        {
-            using (var uow = UowProvider.GetUnitOfWork(readOnly: true))
-            {
-                var repository = RepositoryFactory.CreateContentRepository(uow);
-                var query = Query<IContent>.Builder.Where(x => x.ParentId == id);
-                return repository.Count(query);
-            }
-        }
-
-        /// <summary>
-        /// Checks whether an <see cref="IContent"/> item has any published versions
-        /// </summary>
-        /// <param name="id">Id of the <see cref="IContent"/></param>
-        /// <returns>True if the content has any published version otherwise False</returns>
-        public bool HasPublishedVersion(int id)
-        {
-            using (var uow = UowProvider.GetUnitOfWork(readOnly: true))
-            {
-                var repository = RepositoryFactory.CreateContentRepository(uow);
-                var query = Query<IContent>.Builder.Where(x => x.Published == true && x.Id == id && x.Trashed == false);
-                return repository.Count(query) > 0;
-            }
-        }
-
-        /// <summary>
-        /// Checks if the passed in <see cref="IContent"/> can be published based on the anscestors publish state.
-        /// </summary>
-        /// <param name="content"><see cref="IContent"/> to check if anscestors are published</param>
-        /// <returns>True if the Content can be published, otherwise False</returns>
-        public bool IsPublishable(IContent content)
-        {
-            int[] ids;
-            if (content.HasIdentity)
-            {
-                // get ids from path (we have identity)
-                // skip the first one that has to be -1 - and we don't care
-                // skip the last one that has to be "this" - and it's ok to stop at the parent
-                ids = content.Path.Split(',').Skip(1).SkipLast().Select(int.Parse).ToArray();
-            }
-            else
-            {
-                // no path yet (no identity), have to move up to parent
-                // skip the first one that has to be -1 - and we don't care
-                // don't skip the last one that is "parent"
-                var parent = GetById(content.ParentId);
-                if (parent == null) return false;
-                ids = parent.Path.Split(',').Skip(1).Select(int.Parse).ToArray();
-            }
-            if (ids.Length == 0)
-                return false;
-
-            // if the first one is recycle bin, fail fast
-            if (ids[0] == Constants.System.RecycleBinContent)
-                return false;
-
-            // fixme - move to repository?
-            using (var uow = UowProvider.GetUnitOfWork(readOnly: true))
-            {
-                var sql = new Sql(@"
-                    SELECT id
-                    FROM umbracoNode
-                    JOIN cmsDocument ON umbracoNode.id=cmsDocument.nodeId AND cmsDocument.published=@0
-                    WHERE umbracoNode.trashed=@1 AND umbracoNode.id IN (@2)",
-                    true, false, ids);
-                var x = uow.Database.Fetch<int>(sql);
-                return ids.Length == x.Count;
-            }
-        }
-
-        /// <summary>
-        /// This will rebuild the xml structures for content in the database.
-        /// </summary>
-        /// <param name="userId">This is not used for anything</param>
-        /// <returns>True if publishing succeeded, otherwise False</returns>
-        /// <remarks>
-        /// This is used for when a document type alias or a document type property is changed, the xml will need to
-        /// be regenerated.
-        /// </remarks>
-        public bool RePublishAll(int userId = 0)
-        {
-            try
-            {
-                RebuildXmlStructures();
-                return true;
-            }
-            catch (Exception ex)
-            {
-                Logger.Error<ContentService>("An error occurred executing RePublishAll", ex);
-                return false;
-            }
-        }
-
-        /// <summary>
-        /// This will rebuild the xml structures for content in the database.
-        /// </summary>
-        /// <param name="contentTypeIds">
-        /// If specified will only rebuild the xml for the content type's specified, otherwise will update the structure
-        /// for all published content.
-        /// </param>
-        internal void RePublishAll(params int[] contentTypeIds)
-        {
-            try
-            {
-                RebuildXmlStructures(contentTypeIds);
-            }
-            catch (Exception ex)
-            {
-                Logger.Error<ContentService>("An error occurred executing RePublishAll", ex);
-            }
-        }
-
-        /// <summary>
-        /// Publishes a single <see cref="IContent"/> object
-        /// </summary>
-        /// <param name="content">The <see cref="IContent"/> to publish</param>
-        /// <param name="userId">Optional Id of the User issueing the publishing</param>
-        /// <returns>True if publishing succeeded, otherwise False</returns>
-        public bool Publish(IContent content, int userId = 0)
-        {
-            var result = SaveAndPublishDo(content, userId);
-            Logger.Info<ContentService>("Call was made to ContentService.Publish, use PublishWithStatus instead since that method will provide more detailed information on the outcome");
-            return result.Success;
-        }
-
-        /// <summary>
-        /// Publishes a <see cref="IContent"/> object and all its children
-        /// </summary>
-        /// <param name="content">The <see cref="IContent"/> to publish along with its children</param>
-        /// <param name="userId">Optional Id of the User issueing the publishing</param>
-        /// <param name="includeUnpublished"></param>
-        /// <returns>The list of statuses for all published items</returns>
-        IEnumerable<Attempt<PublishStatus>> IContentServiceOperations.PublishWithChildren(IContent content, int userId, bool includeUnpublished)
-        {
-            return PublishWithChildrenDo(content, userId, includeUnpublished);
-        }
-
-        /// <summary>
-        /// Saves and Publishes a single <see cref="IContent"/> object
-        /// </summary>
-        /// <param name="content">The <see cref="IContent"/> to save and publish</param>
-        /// <param name="userId">Optional Id of the User issueing the publishing</param>
-        /// <param name="raiseEvents">Optional boolean indicating whether or not to raise save events.</param>
-        /// <returns>True if publishing succeeded, otherwise False</returns>
-        Attempt<PublishStatus> IContentServiceOperations.SaveAndPublish(IContent content, int userId, bool raiseEvents)
-        {
-            return SaveAndPublishDo(content, userId, raiseEvents);
-        }
-
-        /// <summary>
-        /// Deletes an <see cref="IContent"/> object by moving it to the Recycle Bin
-        /// </summary>
-        /// <remarks>Move an item to the Recycle Bin will result in the item being unpublished</remarks>
-        /// <param name="content">The <see cref="IContent"/> to delete</param>
-        /// <param name="userId">Optional Id of the User deleting the Content</param>
-        Attempt<OperationStatus> IContentServiceOperations.MoveToRecycleBin(IContent content, int userId)
-        {
-            return MoveToRecycleBinDo(content, userId, false);
-        }
-
-        /// <summary>
-        /// Deletes an <see cref="IContent"/> object by moving it to the Recycle Bin
-        /// </summary>
-        /// <remarks>Move an item to the Recycle Bin will result in the item being unpublished</remarks>
-        /// <param name="content">The <see cref="IContent"/> to delete</param>
-        /// <param name="userId">Optional Id of the User deleting the Content</param>
-        /// <param name="ignoreDescendants">
-        /// A boolean indicating to ignore this item's descendant list from also being moved to the recycle bin. This is required for the DeleteContentOfTypes method
-        /// because it has already looked up all descendant nodes that will need to be recycled
-        /// TODO: Fix all of this, it will require a reasonable refactor and most of this stuff should be done at the repo level instead of service sub operations
-        /// </param>
-        private Attempt<OperationStatus> MoveToRecycleBinDo(IContent content, int userId, bool ignoreDescendants)
-        {
-            var evtMsgs = EventMessagesFactory.Get();
-            using (new WriteLock(Locker))
-            {
-                using (var uow = UowProvider.GetUnitOfWork())
-                {
-                    //Hack: this ensures that the entity's path is valid and if not it fixes/persists it
-                    //see: http://issues.umbraco.org/issue/U4-9336
-                    content.EnsureValidPath(Logger, entity => GetById(entity.ParentId), QuickUpdate);
-                    var originalPath = content.Path;
-                    var moveEventInfo = new MoveEventInfo<IContent>(content, originalPath, Constants.System.RecycleBinContent);
-                    var moveEventArgs = new MoveEventArgs<IContent>(evtMsgs, moveEventInfo);
-                    if (uow.Events.DispatchCancelable(Trashing, this, moveEventArgs, "Trashing"))
-                    {
-                        uow.Commit();
-                        return OperationStatus.Cancelled(evtMsgs);
-                    }
-                    var moveInfo = new List<MoveEventInfo<IContent>>
-                    {
-                        moveEventInfo
-                    };
-
-                    //get descendents to process of the content item that is being moved to trash - must be done before changing the state below
-                    //must be processed with shallowest levels first
-                    var descendants = ignoreDescendants ? Enumerable.Empty<IContent>() : GetDescendants(content).OrderBy(x => x.Level);
-
-                    //Do the updates for this item
-                    var repository = RepositoryFactory.CreateContentRepository(uow);
-                    //Make sure that published content is unpublished before being moved to the Recycle Bin
-                    if (HasPublishedVersion(content.Id))
-                    {
-                        //TODO: this shouldn't be a 'sub operation', and if it needs to be it cannot raise events and cannot be cancelled!
-                        UnPublish(content, userId);
-                    }
-                    content.WriterId = userId;
-                    content.ChangeTrashedState(true);
-                    repository.AddOrUpdate(content);
-
-                    //Loop through descendants to update their trash state, but ensuring structure by keeping the ParentId
-                    foreach (var descendant in descendants)
-                    {
-                        //TODO: this shouldn't be a 'sub operation', and if it needs to be it cannot raise events and cannot be cancelled!
-                        UnPublish(descendant, userId);
-                        descendant.WriterId = userId;
-                        descendant.ChangeTrashedState(true, descendant.ParentId);
-                        repository.AddOrUpdate(descendant);
-
-                        moveInfo.Add(new MoveEventInfo<IContent>(descendant, descendant.Path, descendant.ParentId));
-                    }
-
-                    moveEventArgs.CanCancel = false;
-                    moveEventArgs.MoveInfoCollection = moveInfo;
-                    uow.Events.Dispatch(Trashed, this, moveEventArgs, "Trashed");
-
-                    Audit(uow, AuditType.Move, "Move Content to Recycle Bin performed by user", userId, content.Id);
-                    uow.Commit();
-                }
-
-                return OperationStatus.Success(evtMsgs);
-            }
-        }
-
-        /// <summary>
-        /// UnPublishes a single <see cref="IContent"/> object
-        /// </summary>
-        /// <param name="content">The <see cref="IContent"/> to publish</param>
-        /// <param name="userId">Optional Id of the User issueing the publishing</param>
-        /// <returns>True if unpublishing succeeded, otherwise False</returns>
-        Attempt<UnPublishStatus> IContentServiceOperations.UnPublish(IContent content, int userId)
-        {
-            return UnPublishDo(content, false, userId);
-        }
-
-        /// <summary>
-        /// Publishes a single <see cref="IContent"/> object
-        /// </summary>
-        /// <param name="content">The <see cref="IContent"/> to publish</param>
-        /// <param name="userId">Optional Id of the User issueing the publishing</param>
-        /// <returns>True if publishing succeeded, otherwise False</returns>
-        public Attempt<PublishStatus> PublishWithStatus(IContent content, int userId = 0)
-        {
-            return ((IContentServiceOperations)this).Publish(content, userId);
-        }
-
-        /// <summary>
-        /// Publishes a <see cref="IContent"/> object and all its children
-        /// </summary>
-        /// <param name="content">The <see cref="IContent"/> to publish along with its children</param>
-        /// <param name="userId">Optional Id of the User issueing the publishing</param>
-        /// <returns>True if publishing succeeded, otherwise False</returns>
-        [Obsolete("Use PublishWithChildrenWithStatus instead, that method will provide more detailed information on the outcome and also allows the includeUnpublished flag")]
-        public bool PublishWithChildren(IContent content, int userId = 0)
-        {
-            var result = PublishWithChildrenDo(content, userId, true);
-
-            //This used to just return false only when the parent content failed, otherwise would always return true so we'll
-            // do the same thing for the moment
-            if (result.All(x => x.Result.ContentItem.Id != content.Id))
-                return false;
-
-            return result.Single(x => x.Result.ContentItem.Id == content.Id).Success;
-        }
-
-        /// <summary>
-        /// Publishes a <see cref="IContent"/> object and all its children
-        /// </summary>
-        /// <param name="content">The <see cref="IContent"/> to publish along with its children</param>
-        /// <param name="userId">Optional Id of the User issueing the publishing</param>
-        /// <param name="includeUnpublished">set to true if you want to also publish children that are currently unpublished</param>
-        /// <returns>True if publishing succeeded, otherwise False</returns>
-        public IEnumerable<Attempt<PublishStatus>> PublishWithChildrenWithStatus(IContent content, int userId = 0, bool includeUnpublished = false)
-        {
-            return ((IContentServiceOperations)this).PublishWithChildren(content, userId, includeUnpublished);
-        }
-
-        /// <summary>
-        /// UnPublishes a single <see cref="IContent"/> object
-        /// </summary>
-        /// <param name="content">The <see cref="IContent"/> to publish</param>
-        /// <param name="userId">Optional Id of the User issueing the publishing</param>
-        /// <returns>True if unpublishing succeeded, otherwise False</returns>
-        public bool UnPublish(IContent content, int userId = 0)
-        {
-            var attempt = ((IContentServiceOperations)this).UnPublish(content, userId);
-            LogHelper.Debug<ContentService>(string.Format("Result of unpublish attempt: {0}", attempt.Result.StatusType));
-            return attempt.Success;
-        }
-
-        /// <summary>
-        /// Saves and Publishes a single <see cref="IContent"/> object
-        /// </summary>
-        /// <param name="content">The <see cref="IContent"/> to save and publish</param>
-        /// <param name="userId">Optional Id of the User issueing the publishing</param>
-        /// <param name="raiseEvents">Optional boolean indicating whether or not to raise save events.</param>
-        /// <returns>True if publishing succeeded, otherwise False</returns>
-        [Obsolete("Use SaveAndPublishWithStatus instead, that method will provide more detailed information on the outcome")]
-        public bool SaveAndPublish(IContent content, int userId = 0, bool raiseEvents = true)
-        {
-            var result = SaveAndPublishDo(content, userId, raiseEvents);
-            return result.Success;
-        }
-
-        /// <summary>
-        /// Saves and Publishes a single <see cref="IContent"/> object
-        /// </summary>
-        /// <param name="content">The <see cref="IContent"/> to save and publish</param>
-        /// <param name="userId">Optional Id of the User issueing the publishing</param>
-        /// <param name="raiseEvents">Optional boolean indicating whether or not to raise save events.</param>
-        /// <returns>True if publishing succeeded, otherwise False</returns>
-        public Attempt<PublishStatus> SaveAndPublishWithStatus(IContent content, int userId = 0, bool raiseEvents = true)
-        {
-            return ((IContentServiceOperations)this).SaveAndPublish(content, userId, raiseEvents);
-        }
-
-        public IContent GetBlueprintById(int id)
-        {
-            using (var uow = UowProvider.GetUnitOfWork(readOnly: true))
-            {
-                var repository = RepositoryFactory.CreateContentBlueprintRepository(uow);
-                var blueprint = repository.Get(id);
-                if (blueprint != null)
-                    ((Content) blueprint).IsBlueprint = true;
-                return blueprint;
-            }
-        }
-
-        public IContent GetBlueprintById(Guid id)
-        {
-            using (var uow = UowProvider.GetUnitOfWork(readOnly: true))
-            {
-                var repository = RepositoryFactory.CreateContentBlueprintRepository(uow);
-                var blueprint = repository.Get(id);
-                if (blueprint != null)
-                    ((Content)blueprint).IsBlueprint = true;
-                return blueprint;
-            }
-        }
-
-        public void SaveBlueprint(IContent content, int userId = 0)
-        {
-            //always ensure the blueprint is at the root
-            if (content.ParentId != -1)
-                content.ParentId = -1;
-
-            ((Content) content).IsBlueprint = true;
-
-            using (new WriteLock(Locker))
-            {
-                using (var uow = UowProvider.GetUnitOfWork())
-                {
-                    if (string.IsNullOrWhiteSpace(content.Name))
-                    {
-                        throw new ArgumentException("Cannot save content blueprint with empty name.");
-                    }
-
-                    var repository = RepositoryFactory.CreateContentBlueprintRepository(uow);
-
-                    if (content.HasIdentity == false)
-                    {
-                        content.CreatorId = userId;
-                    }
-                    content.WriterId = userId;
-
-                    repository.AddOrUpdate(content);
-
-                    uow.Events.Dispatch(SavedBlueprint, this, new SaveEventArgs<IContent>(content), "SavedBlueprint");
-
-                    uow.Commit();
-                }
-            }
-        }
-
-        public void DeleteBlueprint(IContent content, int userId = 0)
-        {
-            using (new WriteLock(Locker))
-            {
-                using (var uow = UowProvider.GetUnitOfWork())
-                {
-                    var repository = RepositoryFactory.CreateContentBlueprintRepository(uow);
-                    repository.Delete(content);
-                    uow.Events.Dispatch(DeletedBlueprint, this, new DeleteEventArgs<IContent>(content), "DeletedBlueprint");
-                    uow.Commit();
-                }
-            }
-        }
-
-        public IContent CreateContentFromBlueprint(IContent blueprint, string name, int userId = 0)
-        {
-            if (blueprint == null) throw new ArgumentNullException("blueprint");
-
-            var contentType = blueprint.ContentType;
-            var content = new Content(name, -1, contentType);
-            content.Path = string.Concat(content.ParentId.ToString(), ",", content.Id);
-
-            content.CreatorId = userId;
-            content.WriterId = userId;
-
-            foreach (var property in blueprint.Properties)
-                content.SetValue(property.Alias, property.Value);
-
-            return content;
-        }
-
-        public void DeleteBlueprintsOfTypes(IEnumerable<int> contentTypeIds, int userId = 0)
-        {
-            using (new WriteLock(Locker))
-            using (var uow = UowProvider.GetUnitOfWork())
-            {
-                var repository = RepositoryFactory.CreateContentBlueprintRepository(uow);
-
-                var contentTypeIdsA = contentTypeIds.ToArray();
-                var query = new Query<IContent>();
-                if (contentTypeIdsA.Length > 0)
-                {
-                    query.Where(x => contentTypeIdsA.Contains(x.ContentTypeId));
-                }
-                var blueprints = repository.GetByQuery(query).Select(x =>
-                {
-                    ((Content) x).IsBlueprint = true;
-                    return x;
-                }).ToArray();
-
-                foreach (var blueprint in blueprints)
-                {
-                    repository.Delete(blueprint);
-                }
-
-                uow.Events.Dispatch(DeletedBlueprint, this, new DeleteEventArgs<IContent>(blueprints), "DeletedBlueprint");
-                uow.Commit();
-            }
-        }
-
-        public void DeleteBlueprintsOfType(int contentTypeId, int userId = 0)
-        {
-            DeleteBlueprintsOfTypes(new[] {contentTypeId}, userId);
-        }
-
-        /// <summary>
-        /// Saves a single <see cref="IContent"/> object
-        /// </summary>
-        /// <param name="content">The <see cref="IContent"/> to save</param>
-        /// <param name="userId">Optional Id of the User saving the Content</param>
-        /// <param name="raiseEvents">Optional boolean indicating whether or not to raise events.</param>
-        public void Save(IContent content, int userId = 0, bool raiseEvents = true)
-        {
-            ((IContentServiceOperations)this).Save(content, userId, raiseEvents);
-        }
-
-        /// <summary>
-        /// Saves a collection of <see cref="IContent"/> objects.
-        /// </summary>
-        /// <param name="contents">Collection of <see cref="IContent"/> to save</param>
-        /// <param name="userId">Optional Id of the User saving the Content</param>
-        /// <param name="raiseEvents">Optional boolean indicating whether or not to raise events.</param>
-        Attempt<OperationStatus> IContentServiceOperations.Save(IEnumerable<IContent> contents, int userId, bool raiseEvents)
-        {
-            var asArray = contents.ToArray();
-
-            var evtMsgs = EventMessagesFactory.Get();
-
-            using (var uow = UowProvider.GetUnitOfWork())
-            {
-                var saveEventArgs = new SaveEventArgs<IContent>(asArray, evtMsgs);
-                if (raiseEvents && uow.Events.DispatchCancelable(Saving, this, saveEventArgs, "Saving"))
-                {
-                    uow.Commit();
-                    return OperationStatus.Cancelled(evtMsgs);
-                }
-
-                // todo - understand what's a lock in a scope?
-                // (though, these locks are refactored in v8)
-                using (new WriteLock(Locker))
-                {
-                    var containsNew = asArray.Any(x => x.HasIdentity == false);
-                    var repository = RepositoryFactory.CreateContentRepository(uow);
-
-                    if (containsNew)
-                    {
-                        foreach (var content in asArray)
-                        {
-                            content.WriterId = userId;
-
-                            //Only change the publish state if the "previous" version was actually published
-                            if (content.Published)
-                                content.ChangePublishedState(PublishedState.Saved);
-
-                            repository.AddOrUpdate(content);
-                            //add or update preview
-                            repository.AddOrUpdatePreviewXml(content, c => _entitySerializer.Serialize(this, _dataTypeService, _userService, c));
-                        }
-                    }
-                    else
-                    {
-                        foreach (var content in asArray)
-                        {
-                            content.WriterId = userId;
-                            repository.AddOrUpdate(content);
-                            //add or update preview
-                            repository.AddOrUpdatePreviewXml(content, c => _entitySerializer.Serialize(this, _dataTypeService, _userService, c));
-                        }
-                    }
-                }
-
-                if (raiseEvents)
-                {
-                    saveEventArgs.CanCancel = false;
-                    uow.Events.Dispatch(Saved, this, saveEventArgs, "Saved");
-                }
-
-                Audit(uow, AuditType.Save, "Bulk Save content performed by user", userId == -1 ? 0 : userId, Constants.System.Root);
-                uow.Commit();
-
-                return OperationStatus.Success(evtMsgs);
-            }
-        }
-
-        /// <summary>
-        /// Permanently deletes an <see cref="IContent"/> object.
-        /// </summary>
-        /// <remarks>
-        /// This method will also delete associated media files, child content and possibly associated domains.
-        /// </remarks>
-        /// <remarks>Please note that this method will completely remove the Content from the database</remarks>
-        /// <param name="content">The <see cref="IContent"/> to delete</param>
-        /// <param name="userId">Optional Id of the User deleting the Content</param>
-        Attempt<OperationStatus> IContentServiceOperations.Delete(IContent content, int userId)
-        {
-            var evtMsgs = EventMessagesFactory.Get();
-
-            using (new WriteLock(Locker))
-            {
-                using (var uow = UowProvider.GetUnitOfWork())
-                {
-                    var deleteEventArgs = new DeleteEventArgs<IContent>(content, evtMsgs);
-                    if (uow.Events.DispatchCancelable(Deleting, this, deleteEventArgs, "Deleting"))
-                    {
-                        uow.Commit();
-                        return OperationStatus.Cancelled(evtMsgs);
-                    }
-
-                    //Make sure that published content is unpublished before being deleted
-                    if (HasPublishedVersion(content.Id))
-                    {
-                        UnPublish(content, userId);
-                    }
-
-                    //Delete children before deleting the 'possible parent'
-                    var children = GetChildren(content.Id);
-                    foreach (var child in children)
-                    {
-                        Delete(child, userId);
-                    }
-
-                    var repository = RepositoryFactory.CreateContentRepository(uow);
-
-                    repository.Delete(content);
-
-                    deleteEventArgs.CanCancel = false;
-                    uow.Events.Dispatch(Deleted, this, deleteEventArgs, "Deleted");
-
-                    Audit(uow, AuditType.Delete, "Delete Content performed by user", userId, content.Id);
-                    uow.Commit();
-                }
-
-                return OperationStatus.Success(evtMsgs);
-            }
-        }
-
-        /// <summary>
-        /// Publishes a single <see cref="IContent"/> object
-        /// </summary>
-        /// <param name="content">The <see cref="IContent"/> to publish</param>
-        /// <param name="userId">Optional Id of the User issueing the publishing</param>
-        /// <returns>The published status attempt</returns>
-        Attempt<PublishStatus> IContentServiceOperations.Publish(IContent content, int userId)
-        {
-            return SaveAndPublishDo(content, userId);
-        }
-
-        /// <summary>
-        /// Saves a single <see cref="IContent"/> object
-        /// </summary>
-        /// <param name="content">The <see cref="IContent"/> to save</param>
-        /// <param name="userId">Optional Id of the User saving the Content</param>
-        /// <param name="raiseEvents">Optional boolean indicating whether or not to raise events.</param>
-        Attempt<OperationStatus> IContentServiceOperations.Save(IContent content, int userId, bool raiseEvents)
-        {
-            return Save(content, true, userId, raiseEvents);
-        }
-
-        /// <summary>
-        /// Saves a collection of <see cref="IContent"/> objects.
-        /// </summary>
-        /// <remarks>
-        /// If the collection of content contains new objects that references eachother by Id or ParentId,
-        /// then use the overload Save method with a collection of Lazy <see cref="IContent"/>.
-        /// </remarks>
-        /// <param name="contents">Collection of <see cref="IContent"/> to save</param>
-        /// <param name="userId">Optional Id of the User saving the Content</param>
-        /// <param name="raiseEvents">Optional boolean indicating whether or not to raise events.</param>
-        public void Save(IEnumerable<IContent> contents, int userId = 0, bool raiseEvents = true)
-        {
-            ((IContentServiceOperations)this).Save(contents, userId, raiseEvents);
-        }
-
-        /// <summary>
-        /// Deletes all content of the specified types. All Descendants of deleted content that is not of these types is moved to Recycle Bin.
-        /// </summary>
-        /// <param name="contentTypeIds">Id of the <see cref="IContentType"/></param>
-        /// <param name="userId">Optional Id of the user issueing the delete operation</param>
-        public void DeleteContentOfTypes(IEnumerable<int> contentTypeIds, int userId = 0)
-        {
-            using (new WriteLock(Locker))
-            using (var uow = UowProvider.GetUnitOfWork())
-            {
-                var repository = RepositoryFactory.CreateContentRepository(uow);
-
-                //track the 'root' items of the collection of nodes discovered to delete, we need to use
-                //these items to lookup descendants that are not of this doc type so they can be transfered
-                //to the recycle bin
-                IDictionary<string, IContent> rootItems;
-                var contentToDelete = this.TrackDeletionsForDeleteContentOfTypes(contentTypeIds, repository, out rootItems).ToArray();
-
-                if (uow.Events.DispatchCancelable(Deleting, this, new DeleteEventArgs<IContent>(contentToDelete), "Deleting"))
-                {
-                    uow.Commit();
-                    return;
-                }
-
-                //Determine the items that will need to be recycled (that are children of these content items but not of these content types)
-                var contentToRecycle = this.TrackTrashedForDeleteContentOfTypes(contentTypeIds, rootItems, repository);
-
-                //move each item to the bin starting with the deepest items
-                foreach (var child in contentToRecycle.OrderByDescending(x => x.Level))
-                {
-                    MoveToRecycleBinDo(child, userId, true);
-                }
-
-                foreach (var content in contentToDelete)
-                {
-                    Delete(content, userId);
-                }
-
-                Audit(uow, AuditType.Delete,
-                    string.Format("Delete Content of Types {0} performed by user", string.Join(",", contentTypeIds)),
-                    userId, Constants.System.Root);
-                uow.Commit();
-            }
-        }
-
-        /// <summary>
-        /// Deletes all content of specified type. All children of deleted content is moved to Recycle Bin.
-        /// </summary>
-        /// <remarks>This needs extra care and attention as its potentially a dangerous and extensive operation</remarks>
-        /// <param name="contentTypeId">Id of the <see cref="IContentType"/></param>
-        /// <param name="userId">Optional Id of the user issueing the delete operation</param>
-        public void DeleteContentOfType(int contentTypeId, int userId = 0)
-        {
-            DeleteContentOfTypes(new[] {contentTypeId}, userId);
-        }
-
-        /// <summary>
-        /// Permanently deletes an <see cref="IContent"/> object as well as all of its Children.
-        /// </summary>
-        /// <remarks>
-        /// This method will also delete associated media files, child content and possibly associated domains.
-        /// </remarks>
-        /// <remarks>Please note that this method will completely remove the Content from the database</remarks>
-        /// <param name="content">The <see cref="IContent"/> to delete</param>
-        /// <param name="userId">Optional Id of the User deleting the Content</param>
-        public void Delete(IContent content, int userId = 0)
-        {
-            ((IContentServiceOperations)this).Delete(content, userId);
-        }
-
-        /// <summary>
-        /// Permanently deletes versions from an <see cref="IContent"/> object prior to a specific date.
-        /// This method will never delete the latest version of a content item.
-        /// </summary>
-        /// <param name="id">Id of the <see cref="IContent"/> object to delete versions from</param>
-        /// <param name="versionDate">Latest version date</param>
-        /// <param name="userId">Optional Id of the User deleting versions of a Content object</param>
-        public void DeleteVersions(int id, DateTime versionDate, int userId = 0)
-        {
-            using (var uow = UowProvider.GetUnitOfWork())
-            {
-                var deleteRevisionsEventArgs = new DeleteRevisionsEventArgs(id, dateToRetain: versionDate);
-                if (uow.Events.DispatchCancelable(DeletingVersions, this, deleteRevisionsEventArgs, "DeletingVersions"))
-                {
-                    uow.Commit();
-                    return;
-                }
-
-                var repository = RepositoryFactory.CreateContentRepository(uow);
-                repository.DeleteVersions(id, versionDate);
-                deleteRevisionsEventArgs.CanCancel = false;
-                uow.Events.Dispatch(DeletedVersions, this, deleteRevisionsEventArgs, "DeletedVersions");
-
-                Audit(uow, AuditType.Delete, "Delete Content by version date performed by user", userId, Constants.System.Root);
-                uow.Commit();
-            }
-        }
-
-        /// <summary>
-        /// Permanently deletes specific version(s) from an <see cref="IContent"/> object.
-        /// This method will never delete the latest version of a content item.
-        /// </summary>
-        /// <param name="id">Id of the <see cref="IContent"/> object to delete a version from</param>
-        /// <param name="versionId">Id of the version to delete</param>
-        /// <param name="deletePriorVersions">Boolean indicating whether to delete versions prior to the versionId</param>
-        /// <param name="userId">Optional Id of the User deleting versions of a Content object</param>
-        public void DeleteVersion(int id, Guid versionId, bool deletePriorVersions, int userId = 0)
-        {
-            using (new WriteLock(Locker))
-            {
-                using (var uow = UowProvider.GetUnitOfWork())
-                {
-                    if (uow.Events.DispatchCancelable(DeletingVersions, this, new DeleteRevisionsEventArgs(id, specificVersion: versionId), "DeletingVersions"))
-                    {
-                        uow.Commit();
-                        return;
-                    }
-
-                    if (deletePriorVersions)
-                    {
-                        var content = GetByVersion(versionId);
-                        DeleteVersions(id, content.UpdateDate, userId);
-                    }
-
-                    var repository = RepositoryFactory.CreateContentRepository(uow);
-                    repository.DeleteVersion(versionId);
-
-                    uow.Events.Dispatch(DeletedVersions, this, new DeleteRevisionsEventArgs(id, false, specificVersion: versionId), "DeletedVersions");
-
-                    Audit(uow, AuditType.Delete, "Delete Content by version performed by user", userId, Constants.System.Root);
-                    uow.Commit();
-                }
-            }
-        }
-
-        /// <summary>
-        /// Deletes an <see cref="IContent"/> object by moving it to the Recycle Bin
-        /// </summary>
-        /// <remarks>Move an item to the Recycle Bin will result in the item being unpublished</remarks>
-        /// <param name="content">The <see cref="IContent"/> to delete</param>
-        /// <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);
-        }
-
-        /// <summary>
-        /// Moves an <see cref="IContent"/> object to a new location by changing its parent id.
-        /// </summary>
-        /// <remarks>
-        /// If the <see cref="IContent"/> object is already published it will be
-        /// published after being moved to its new location. Otherwise it'll just
-        /// be saved with a new parent id.
-        /// </remarks>
-        /// <param name="content">The <see cref="IContent"/> to move</param>
-        /// <param name="parentId">Id of the Content's new Parent</param>
-        /// <param name="userId">Optional Id of the User moving the Content</param>
-        public void Move(IContent content, int parentId, int userId = 0)
-        {
-            using (new WriteLock(Locker))
-            {
-                //This ensures that the correct method is called if this method is used to Move to recycle bin.
-                if (parentId == Constants.System.RecycleBinContent)
-                {
-                    MoveToRecycleBin(content, userId);
-                    return;
-                }
-
-                using (var uow = UowProvider.GetUnitOfWork())
-                {
-                    var moveEventInfo = new MoveEventInfo<IContent>(content, content.Path, parentId);
-                    var moveEventArgs = new MoveEventArgs<IContent>(moveEventInfo);
-                    if (uow.Events.DispatchCancelable(Moving, this, moveEventArgs, "Moving"))
-                    {
-                        uow.Commit();
-                        return;
-                    }
-
-                    //used to track all the moved entities to be given to the event
-                    var moveInfo = new List<MoveEventInfo<IContent>>();
-
-                    //call private method that does the recursive moving
-                    PerformMove(content, parentId, userId, moveInfo);
-
-                    moveEventArgs.MoveInfoCollection = moveInfo;
-                    moveEventArgs.CanCancel = false;
-                    uow.Events.Dispatch(Moved, this, moveEventArgs, "Moved");
-
-                    Audit(uow, AuditType.Move, "Move Content performed by user", userId, content.Id);
-                    uow.Commit();
-                }
-            }
-        }
-
-        /// <summary>
-        /// Empties the Recycle Bin by deleting all <see cref="IContent"/> that resides in the bin
-        /// </summary>
-        [EditorBrowsable(EditorBrowsableState.Never)]
-        [Obsolete("Use EmptyRecycleBin with explicit indication of user ID instead")]
-        public void EmptyRecycleBin() => EmptyRecycleBin(0);
-
-        /// <summary>
-        /// Empties the Recycle Bin by deleting all <see cref="IContent"/> that resides in the bin
-        /// </summary>
-        /// <param name="userId">Optional Id of the User emptying the Recycle Bin</param>
-        public void EmptyRecycleBin(int userId = 0)
-        {
-            using (new WriteLock(Locker))
-            {
-                var nodeObjectType = Constants.ObjectTypes.DocumentGuid;
-
-                using (var uow = UowProvider.GetUnitOfWork())
-                {
-                    var repository = RepositoryFactory.CreateContentRepository(uow);
-
-                    //Create a dictionary of ids -> dictionary of property aliases + values
-                    var entities = repository.GetEntitiesInRecycleBin()
-                        .ToDictionary(
-                            key => key.Id,
-                            val => (IEnumerable<Property>)val.Properties);
-
-                    var files = ((ContentRepository)repository).GetFilesInRecycleBinForUploadField();
-
-                    var recycleBinEventArgs = new RecycleBinEventArgs(nodeObjectType, entities, files);
-                    if (uow.Events.DispatchCancelable(EmptyingRecycleBin, this, recycleBinEventArgs))
-                    {
-                        uow.Commit();
-                        return;
-                    }
-
-                    var success = repository.EmptyRecycleBin();
-                    recycleBinEventArgs.CanCancel = false;
-                    recycleBinEventArgs.RecycleBinEmptiedSuccessfully = success;
-                    uow.Events.Dispatch(EmptiedRecycleBin, this, recycleBinEventArgs);
-
-                    Audit(uow, AuditType.Delete, "Empty Content Recycle Bin performed by user", userId, Constants.System.RecycleBinContent);
-                    uow.Commit();
-                }
-            }
-        }
-
-        /// <summary>
-        /// Copies an <see cref="IContent"/> object by creating a new Content object of the same type and copies all data from the current
-        /// to the new copy which is returned. Recursively copies all children.
-        /// </summary>
-        /// <param name="content">The <see cref="IContent"/> to copy</param>
-        /// <param name="parentId">Id of the Content's new Parent</param>
-        /// <param name="relateToOriginal">Boolean indicating whether the copy should be related to the original</param>
-        /// <param name="userId">Optional Id of the User copying the Content</param>
-        /// <returns>The newly created <see cref="IContent"/> object</returns>
-        public IContent Copy(IContent content, int parentId, bool relateToOriginal, int userId = 0)
-        {
-            return Copy(content, parentId, relateToOriginal, true, userId);
-        }
-
-        /// <summary>
-        /// Copies an <see cref="IContent"/> object by creating a new Content object of the same type and copies all data from the current
-        /// to the new copy which is returned.
-        /// </summary>
-        /// <param name="content">The <see cref="IContent"/> to copy</param>
-        /// <param name="parentId">Id of the Content's new Parent</param>
-        /// <param name="relateToOriginal">Boolean indicating whether the copy should be related to the original</param>
-        /// <param name="recursive">A value indicating whether to recursively copy children.</param>
-        /// <param name="userId">Optional Id of the User copying the Content</param>
-        /// <returns>The newly created <see cref="IContent"/> object</returns>
-        public IContent Copy(IContent content, int parentId, bool relateToOriginal, bool recursive, int userId = 0)
-        {
-            //TODO: This all needs to be managed correctly so that the logic is submitted in one
-            // transaction, the CRUD needs to be moved to the repo
-
-            using (new WriteLock(Locker))
-            {
-                var copy = content.DeepCloneWithResetIdentities();
-                copy.ParentId = parentId;
-
-                // A copy should never be set to published automatically even if the original was.
-                copy.ChangePublishedState(PublishedState.Unpublished);
-
-                using (var uow = UowProvider.GetUnitOfWork())
-                {
-                    var copyEventArgs = new CopyEventArgs<IContent>(content, copy, true, parentId, relateToOriginal);
-                    if (uow.Events.DispatchCancelable(Copying, this, copyEventArgs))
-                    {
-                        uow.Commit();
-                        return null;
-                    }
-
-                    var repository = RepositoryFactory.CreateContentRepository(uow);
-
-                    // Update the create author and last edit author
-                    copy.CreatorId = userId;
-                    copy.WriterId = userId;
-
-                    //get the current permissions, if there are any explicit ones they need to be copied
-                    var currentPermissions = GetPermissionsForEntity(content);
-                    currentPermissions.RemoveWhere(p => p.IsDefaultPermissions);
-
-                    repository.AddOrUpdate(copy);
-                    repository.AddOrUpdatePreviewXml(copy, c => _entitySerializer.Serialize(this, _dataTypeService, _userService, c));
-
-                    //add permissions
-                    if (currentPermissions.Count > 0)
-                    {
-                        var permissionSet = new ContentPermissionSet(copy, currentPermissions);
-                        repository.AddOrUpdatePermissions(permissionSet);
-                    }
-
-                    uow.Commit(); // todo - this should flush, not commit
-
-                    //Special case for the associated tags
-                    //TODO: Move this to the repository layer in a single transaction!
-                    //don't copy tags data in tags table if the item is in the recycle bin
-                    if (parentId != Constants.System.RecycleBinContent)
-                    {
-                        var tags = uow.Database.Fetch<TagRelationshipDto>("WHERE nodeId = @Id", new { Id = content.Id });
-                        foreach (var tag in tags)
-                            uow.Database.Insert(new TagRelationshipDto
-                            {
-                                NodeId = copy.Id, TagId = tag.TagId, PropertyTypeId = tag.PropertyTypeId
-                            });
-                    }
-                    uow.Commit(); // todo - this should flush, not commit
-
-                    if (recursive)
-                    {
-                        //Look for children and copy those as well
-                        var children = GetChildren(content.Id);
-                        foreach (var child in children)
-                        {
-                            //TODO: This shouldn't recurse back to this method, it should be done in a private method
-                            // that doesn't have a nested lock and so we can perform the entire operation in one commit.
-                            Copy(child, copy.Id, relateToOriginal, true, userId);
-                        }
-                    }
-                    copyEventArgs.CanCancel = false;
-                    uow.Events.Dispatch(Copied, this, copyEventArgs);
-                    Audit(uow, AuditType.Copy, "Copy Content performed by user", userId, content.Id);
-                    uow.Commit();
-                }
-
-                return copy;
-            }
-        }
-
-
-        /// <summary>
-        /// Sends an <see cref="IContent"/> to Publication, which executes handlers and events for the 'Send to Publication' action.
-        /// </summary>
-        /// <param name="content">The <see cref="IContent"/> to send to publication</param>
-        /// <param name="userId">Optional Id of the User issueing the send to publication</param>
-        /// <returns>True if sending publication was succesfull otherwise false</returns>
-        public bool SendToPublication(IContent content, int userId = 0)
-        {
-            using (var uow = UowProvider.GetUnitOfWork())
-            {
-                var sendToPublishEventArgs = new SendToPublishEventArgs<IContent>(content);
-                if (uow.Events.DispatchCancelable(SendingToPublish, this, sendToPublishEventArgs))
-                {
-                    uow.Commit();
-                    return false;
-                }
-
-                //Save before raising event
-                Save(content, userId);
-                sendToPublishEventArgs.CanCancel = false;
-                uow.Events.Dispatch(SentToPublish, this, sendToPublishEventArgs);
-
-                Audit(uow, AuditType.SendToPublish, "Send to Publish performed by user", content.WriterId, content.Id);
-                uow.Commit();
-
-                return true;
-            }
-        }
-
-        /// <summary>
-        /// Rollback an <see cref="IContent"/> object to a previous version.
-        /// This will create a new version, which is a copy of all the old data.
-        /// </summary>
-        /// <remarks>
-        /// The way data is stored actually only allows us to rollback on properties
-        /// and not data like Name and Alias of the Content.
-        /// </remarks>
-        /// <param name="id">Id of the <see cref="IContent"/>being rolled back</param>
-        /// <param name="versionId">Id of the version to rollback to</param>
-        /// <param name="userId">Optional Id of the User issueing the rollback of the Content</param>
-        /// <returns>The newly created <see cref="IContent"/> object</returns>
-        public IContent Rollback(int id, Guid versionId, int userId = 0)
-        {
-            var content = GetByVersion(versionId);
-
-            using (var uow = UowProvider.GetUnitOfWork())
-            {
-                var rollbackEventArgs = new RollbackEventArgs<IContent>(content);
-                if (uow.Events.DispatchCancelable(RollingBack, this, rollbackEventArgs))
-                {
-                    uow.Commit();
-                    return content;
-                }
-
-                var repository = RepositoryFactory.CreateContentRepository(uow);
-
-                content.WriterId = userId;
-                content.CreatorId = userId;
-                content.ChangePublishedState(PublishedState.Unpublished);
-
-                repository.AddOrUpdate(content);
-                repository.AddOrUpdatePreviewXml(content, c => _entitySerializer.Serialize(this, _dataTypeService, _userService, c));
-                rollbackEventArgs.CanCancel = false;
-                uow.Events.Dispatch(RolledBack, this, rollbackEventArgs);
-
-                Audit(uow, AuditType.RollBack, "Content rollback performed by user", content.WriterId, content.Id);
-                uow.Commit();
-            }
-
-            return content;
-        }
-
-        /// <summary>
-        /// Sorts a collection of <see cref="IContent"/> objects by updating the SortOrder according
-        /// to the ordering of items in the passed in <see cref="IEnumerable{T}"/>.
-        /// </summary>
-        /// <remarks>
-        /// Using this method will ensure that the Published-state is maintained upon sorting
-        /// so the cache is updated accordingly - as needed.
-        /// </remarks>
-        /// <param name="items"></param>
-        /// <param name="userId"></param>
-        /// <param name="raiseEvents"></param>
-        /// <returns>True if sorting succeeded, otherwise False</returns>
-        public bool Sort(IEnumerable<IContent> items, int userId = 0, bool raiseEvents = true)
-        {
-            var shouldBePublished = new List<IContent>();
-            var shouldBeSaved = new List<IContent>();
-
-            using (new WriteLock(Locker))
-            {
-                using (var uow = UowProvider.GetUnitOfWork())
-                {
-                    var asArray = items.ToArray();
-                    var saveEventArgs = new SaveEventArgs<IContent>(asArray);
-                    if (raiseEvents && uow.Events.DispatchCancelable(Saving, this, saveEventArgs, "Saving"))
-                    {
-                        uow.Commit();
-                        return false;
-                    }
-
-                    var repository = RepositoryFactory.CreateContentRepository(uow);
-
-                    var i = 0;
-                    foreach (var content in asArray)
-                    {
-                        //If the current sort order equals that of the content
-                        //we don't need to update it, so just increment the sort order
-                        //and continue.
-                        if (content.SortOrder == i)
-                        {
-                            i++;
-                            continue;
-                        }
-
-                        content.SortOrder = i;
-                        content.WriterId = userId;
-                        i++;
-
-                        if (content.Published)
-                        {
-                            //TODO: This should not be an inner operation, but if we do this, it cannot raise events and cannot be cancellable!
-                            var published = _publishingStrategy.Publish(uow, content, userId).Success;
-                            shouldBePublished.Add(content);
-                        }
-                        else
-                            shouldBeSaved.Add(content);
-
-                        repository.AddOrUpdate(content);
-                        //add or update a preview
-                        repository.AddOrUpdatePreviewXml(content, c => _entitySerializer.Serialize(this, _dataTypeService, _userService, c));
-                    }
-
-                    foreach (var content in shouldBePublished)
-                    {
-                        //Create and Save ContentXml DTO
-                        repository.AddOrUpdateContentXml(content, c => _entitySerializer.Serialize(this, _dataTypeService, _userService, c));
-                    }
-
-                    if (raiseEvents)
-                    {
-                        saveEventArgs.CanCancel = false;
-                        uow.Events.Dispatch(Saved, this, saveEventArgs, "Saved");
-                    }
-
-                    if (shouldBePublished.Any())
-                    {
-                        //TODO: This should not be an inner operation, but if we do this, it cannot raise events and cannot be cancellable!
-                        _publishingStrategy.PublishingFinalized(uow, shouldBePublished, false);
-                    }
-
-                    Audit(uow, AuditType.Sort, "Sorting content performed by user", userId, 0);
-                    uow.Commit();
-                }
-            }
-
-            return true;
-        }
-
-        /// <summary>
-        /// Sorts a collection of <see cref="IContent"/> objects by updating the SortOrder according
-        /// to the ordering of node Ids passed in.
-        /// </summary>
-        /// <remarks>
-        /// Using this method will ensure that the Published-state is maintained upon sorting
-        /// so the cache is updated accordingly - as needed.
-        /// </remarks>
-        /// <param name="ids"></param>
-        /// <param name="userId"></param>
-        /// <param name="raiseEvents"></param>
-        /// <returns>True if sorting succeeded, otherwise False</returns>
-        public bool Sort(int[] ids, int userId = 0, bool raiseEvents = true)
-        {
-            var shouldBePublished = new List<IContent>();
-            var shouldBeSaved = new List<IContent>();
-
-            using (new WriteLock(Locker))
-            {
-                var allContent = GetByIds(ids).ToDictionary(x => x.Id, x => x);
-                if (allContent.Any() == false)
-                {
-                    return false;
-                }
-                var items = ids.Select(x => allContent[x]).ToArray();
-
-                using (var uow = UowProvider.GetUnitOfWork())
-                {
-                    var saveEventArgs = new SaveEventArgs<IContent>(items);
-                    if (raiseEvents && uow.Events.DispatchCancelable(Saving, this, saveEventArgs, "Saving"))
-                    {
-                        uow.Commit();
-                        return false;
-                    }
-
-                    var repository = RepositoryFactory.CreateContentRepository(uow);
-
-                    var i = 0;
-                    foreach (var content in items)
-                    {
-                        //If the current sort order equals that of the content
-                        //we don't need to update it, so just increment the sort order
-                        //and continue.
-                        if (content.SortOrder == i)
-                        {
-                            i++;
-                            continue;
-                        }
-
-                        content.SortOrder = i;
-                        content.WriterId = userId;
-                        i++;
-
-                        if (content.Published)
-                        {
-                            //TODO: This should not be an inner operation, but if we do this, it cannot raise events and cannot be cancellable!
-                            var published = _publishingStrategy.Publish(uow, content, userId).Success;
-                            shouldBePublished.Add(content);
-                        }
-                        else
-                            shouldBeSaved.Add(content);
-
-                        repository.AddOrUpdate(content);
-                        //add or update a preview
-                        repository.AddOrUpdatePreviewXml(content, c => _entitySerializer.Serialize(this, _dataTypeService, _userService, c));
-                    }
-
-                    foreach (var content in shouldBePublished)
-                    {
-                        //Create and Save ContentXml DTO
-                        repository.AddOrUpdateContentXml(content, c => _entitySerializer.Serialize(this, _dataTypeService, _userService, c));
-                    }
-
-                    if (raiseEvents)
-                    {
-                        saveEventArgs.CanCancel = false;
-                        uow.Events.Dispatch(Saved, this, saveEventArgs, "Saved");
-                    }
-
-                    if (shouldBePublished.Any())
-                    {
-                        //TODO: This should not be an inner operation, but if we do this, it cannot raise events and cannot be cancellable!
-                        _publishingStrategy.PublishingFinalized(uow, shouldBePublished, false);
-                    }
-
-                    Audit(uow, AuditType.Sort, "Sort child items performed by user", userId, items.First().ParentId);
-                    uow.Commit();
-                }
-            }
-
-            return true;
-        }
-
-        public IEnumerable<IContent> GetBlueprintsForContentTypes(params int[] documentTypeIds)
-        {
-            using (var uow = UowProvider.GetUnitOfWork(readOnly: true))
-            {
-                var repository = RepositoryFactory.CreateContentBlueprintRepository(uow);
-
-                var query = new Query<IContent>();
-                if (documentTypeIds.Length > 0)
-                {
-                    query.Where(x => documentTypeIds.Contains(x.ContentTypeId));
-                }
-                return repository.GetByQuery(query).Select(x =>
-                {
-                    ((Content) x).IsBlueprint = true;
-                    return x;
-                });
-            }
-        }
-
-        /// <summary>
-        /// Gets paged content descendants as XML by path
-        /// </summary>
-        /// <param name="path">Path starts with</param>
-        /// <param name="pageIndex">Page number</param>
-        /// <param name="pageSize">Page size</param>
-        /// <param name="totalRecords">Total records the query would return without paging</param>
-        /// <returns>A paged enumerable of XML entries of content items</returns>
-        public IEnumerable<XElement> GetPagedXmlEntries(string path, long pageIndex, int pageSize, out long totalRecords)
-        {
-            Mandate.ParameterCondition(pageIndex >= 0, "pageIndex");
-            Mandate.ParameterCondition(pageSize > 0, "pageSize");
-
-            using (var uow = UowProvider.GetUnitOfWork(readOnly: true))
-            {
-                var repository = RepositoryFactory.CreateContentRepository(uow);
-                var contents = repository.GetPagedXmlEntriesByPath(path, pageIndex, pageSize,
-                    //This order by is VERY important! This allows us to figure out what is implicitly not published, see ContentRepository.BuildXmlCache and
-                    // UmbracoContentIndexer.PerformIndexAll which uses the logic based on this sort order
-                    new[] { "level", "parentID", "sortOrder" },
-                    out totalRecords);
-                return contents;
-            }
-        }
-
-        /// <summary>
-        /// This builds the Xml document used for the XML cache
-        /// </summary>
-        /// <returns></returns>
-        public XmlDocument BuildXmlCache()
-        {
-            using (var uow = UowProvider.GetUnitOfWork())
-            {
-                var repository = RepositoryFactory.CreateContentRepository(uow);
-                var result = repository.BuildXmlCache();
-                uow.Commit();
-                return result;
-            }
-        }
-
-        public XmlDocument BuildPreviewXmlCache()
-        {
-            using (var uow = UowProvider.GetUnitOfWork())
-            {
-                var repository = RepositoryFactory.CreateContentRepository(uow);
-                var result = repository.BuildPreviewXmlCache();
-                uow.Commit();
-                return result;
-            }
-        }
-
-        /// <summary>
-        /// Rebuilds all xml content in the cmsContentXml table for all documents
-        /// </summary>
-        /// <param name="contentTypeIds">
-        /// Only rebuild the xml structures for the content type ids passed in, if none then rebuilds the structures
-        /// for all content
-        /// </param>
-        public void RebuildXmlStructures(params int[] contentTypeIds)
-        {
-            using (var uow = UowProvider.GetUnitOfWork())
-            {
-                var repository = RepositoryFactory.CreateContentRepository(uow);
-
-                repository.RebuildXmlStructures(
-                    content => _entitySerializer.Serialize(this, _dataTypeService, _userService, content),
-                    contentTypeIds: contentTypeIds.Length == 0 ? null : contentTypeIds);
-
-                Audit(uow, AuditType.Publish, "ContentService.RebuildXmlStructures completed, the xml has been regenerated in the database", 0, Constants.System.Root);
-                uow.Commit();
-            }
-        }
-
-        #region Internal Methods
-
-        /// <summary>
-        /// Gets a collection of <see cref="IContent"/> descendants by the first Parent.
-        /// </summary>
-        /// <param name="content"><see cref="IContent"/> item to retrieve Descendants from</param>
-        /// <returns>An Enumerable list of <see cref="IContent"/> objects</returns>
-        internal IEnumerable<IContent> GetPublishedDescendants(IContent content)
-        {
-            using (var uow = UowProvider.GetUnitOfWork(readOnly: true))
-            {
-                var repository = RepositoryFactory.CreateContentRepository(uow);
-
-                var query = Query<IContent>.Builder.Where(x => x.Id != content.Id && x.Path.StartsWith(content.Path) && x.Trashed == false);
-                return repository.GetByPublishedVersion(query);
-            }
-        }
-
-        #endregion
-
-        #region Private Methods
-
-        /// <summary>
-        /// Hack: This is used to fix some data if an entity's properties are invalid/corrupt
-        /// </summary>
-        /// <param name="content"></param>
-        private void QuickUpdate(IContent content)
-        {
-            if (content == null) throw new ArgumentNullException("content");
-            if (content.HasIdentity == false) throw new InvalidOperationException("Cannot update an entity without an Identity");
-
-            using (var uow = UowProvider.GetUnitOfWork())
-            {
-                var repository = RepositoryFactory.CreateContentRepository(uow);
-                repository.AddOrUpdate(content);
-                uow.Commit();
-            }
-        }
-
-        private void Audit(IScopeUnitOfWork uow, AuditType type, string message, int userId, int objectId)
-        {
-            var auditRepo = RepositoryFactory.CreateAuditRepository(uow);
-            auditRepo.AddOrUpdate(new AuditItem(objectId, message, type, userId));
-        }
-
-        //TODO: All of this needs to be moved to the repository
-        private void PerformMove(IContent content, int parentId, int userId, ICollection<MoveEventInfo<IContent>> moveInfo)
-        {
-            //add a tracking item to use in the Moved event
-            moveInfo.Add(new MoveEventInfo<IContent>(content, content.Path, parentId));
-
-            content.WriterId = userId;
-            if (parentId == Constants.System.Root)
-            {
-                content.Path = string.Concat(Constants.System.Root, ",", content.Id);
-                content.Level = 1;
-            }
-            else
-            {
-                var parent = GetById(parentId);
-                content.Path = string.Concat(parent.Path, ",", content.Id);
-                content.Level = parent.Level + 1;
-            }
-
-            //If Content is being moved away from Recycle Bin, its state should be un-trashed
-            if (content.Trashed && parentId != Constants.System.RecycleBinContent)
-            {
-                content.ChangeTrashedState(false, parentId);
-            }
-            else
-            {
-                content.ParentId = parentId;
-            }
-
-            //If Content is published, it should be (re)published from its new location
-            if (content.Published)
-            {
-                //If Content is Publishable its saved and published
-                //otherwise we save the content without changing the publish state, and generate new xml because the Path, Level and Parent has changed.
-                if (IsPublishable(content))
-                {
-                    //TODO: This is raising events, probably not desirable as this costs performance for event listeners like Examine
-                    SaveAndPublish(content, userId);
-                }
-                else
-                {
-                    //TODO: This is raising events, probably not desirable as this costs performance for event listeners like Examine
-                    Save(content, false, userId);
-
-                    //TODO: This shouldn't be here! This needs to be part of the repository logic but in order to fix this we need to
-                    // change how this method calls "Save" as it needs to save using an internal method
-                    using (var uow = UowProvider.GetUnitOfWork())
-                    {
-                        var xml = _entitySerializer.Serialize(this, _dataTypeService, _userService, content);
-
-                        var poco = new ContentXmlDto { NodeId = content.Id, Xml = xml.ToDataString() };
-                        var exists =
-                            uow.Database.FirstOrDefault<ContentXmlDto>("WHERE nodeId = @Id", new { Id = content.Id }) !=
-                            null;
-                        int result = exists
-                                         ? uow.Database.Update(poco)
-                                         : Convert.ToInt32(uow.Database.Insert(poco));
-                        uow.Commit();
-                    }
-                }
-            }
-            else
-            {
-                //TODO: This is raising events, probably not desirable as this costs performance for event listeners like Examine
-                Save(content, userId);
-            }
-
-            //Ensure that Path and Level is updated on children
-            var children = GetChildren(content.Id).ToArray();
-            if (children.Any())
-            {
-                foreach (var child in children)
-                {
-                    PerformMove(child, content.Id, userId, moveInfo);
-                }
-            }
-        }
-
-        /// <summary>
-        /// Publishes a <see cref="IContent"/> object and all its children
-        /// </summary>
-        /// <param name="content">The <see cref="IContent"/> to publish along with its children</param>
-        /// <param name="userId">Optional Id of the User issueing the publishing</param>
-        /// <param name="includeUnpublished">If set to true, this will also publish descendants that are completely unpublished, normally this will only publish children that have previously been published</param>
-        /// <returns>
-        /// A list of publish statues. If the parent document is not valid or cannot be published because it's parent(s) is not published
-        /// then the list will only contain one status item, otherwise it will contain status items for it and all of it's descendants that
-        /// are to be published.
-        /// </returns>
-        private IEnumerable<Attempt<PublishStatus>> PublishWithChildrenDo(
-            IContent content, int userId = 0, bool includeUnpublished = false)
-        {
-            if (content == null) throw new ArgumentNullException("content");
-
-            var evtMsgs = EventMessagesFactory.Get();
-
-            using (new WriteLock(Locker))
-            {
-                //Hack: this ensures that the entity's path is valid and if not it fixes/persists it
-                //see: http://issues.umbraco.org/issue/U4-9336
-                content.EnsureValidPath(Logger, entity => GetById(entity.ParentId), QuickUpdate);
-
-                var result = new List<Attempt<PublishStatus>>();
-
-                //Check if parent is published (although not if its a root node) - if parent isn't published this Content cannot be published
-                if (content.ParentId != Constants.System.Root && content.ParentId != Constants.System.RecycleBinContent && IsPublishable(content) == false)
-                {
-                    Logger.Info<ContentService>(
-                        string.Format(
-                            "Content '{0}' with Id '{1}' could not be published because its parent or one of its ancestors is not published.",
-                            content.Name, content.Id));
-                    result.Add(Attempt.Fail(new PublishStatus(content, PublishStatusType.FailedPathNotPublished, evtMsgs)));
-                    return result;
-                }
-
-                //Content contains invalid property values and can therefore not be published - fire event?
-                if (!content.IsValid())
-                {
-                    Logger.Info<ContentService>(
-                        string.Format("Content '{0}' with Id '{1}' could not be published because of invalid properties.",
-                                      content.Name, content.Id));
-                    result.Add(
-                        Attempt.Fail(
-                            new PublishStatus(content, PublishStatusType.FailedContentInvalid, evtMsgs)
-                            {
-                                InvalidProperties = ((ContentBase)content).LastInvalidProperties
-                            }));
-                    return result;
-                }
-
-                //Consider creating a Path query instead of recursive method:
-                //var query = Query<IContent>.Builder.Where(x => x.Path.StartsWith(content.Path));
-
-                var updated = new List<IContent>();
-                var list = new List<IContent>();
-                list.Add(content); //include parent item
-                list.AddRange(GetDescendants(content));
-
-                var internalStrategy = _publishingStrategy;
-
-                using (var uow = UowProvider.GetUnitOfWork())
-                {
-                    //Publish and then update the database with new status
-                    var publishedOutcome = internalStrategy.PublishWithChildren(uow, list, userId, includeUnpublished).ToArray();
-                    var published = publishedOutcome
-                        .Where(x => x.Success || x.Result.StatusType == PublishStatusType.SuccessAlreadyPublished)
-                        // ensure proper order (for events) - cannot publish a child before its parent!
-                        .OrderBy(x => x.Result.ContentItem.Level)
-                        .ThenBy(x => x.Result.ContentItem.SortOrder);
-
-                    var repository = RepositoryFactory.CreateContentRepository(uow);
-
-                    //NOTE The Publish with subpages-dialog was used more as a republish-type-thing, so we'll have to include PublishStatusType.SuccessAlreadyPublished
-                    //in the updated-list, so the Published event is triggered with the expected set of pages and the xml is updated.
-                    foreach (var item in published)
-                    {
-                        item.Result.ContentItem.WriterId = userId;
-                        repository.AddOrUpdate(item.Result.ContentItem);
-                        //add or update a preview
-                        repository.AddOrUpdatePreviewXml(item.Result.ContentItem, c => _entitySerializer.Serialize(this, _dataTypeService, _userService, c));
-                        //add or update the published xml
-                        repository.AddOrUpdateContentXml(item.Result.ContentItem, c => _entitySerializer.Serialize(this, _dataTypeService, _userService, c));
-                        updated.Add(item.Result.ContentItem);
-                    }
-
-                    //Save xml to db and call following method to fire event:
-                    _publishingStrategy.PublishingFinalized(uow, updated, false);
-
-                    Audit(uow, AuditType.Publish, "Publish with Children performed by user", userId, content.Id);
-                    uow.Commit();
-
-                    return publishedOutcome;
-                }
-            }
-        }
-
-        /// <summary>
-        /// UnPublishes a single <see cref="IContent"/> object
-        /// </summary>
-        /// <param name="content">The <see cref="IContent"/> to publish</param>
-        /// <param name="omitCacheRefresh">Optional boolean to avoid having the cache refreshed when calling this Unpublish method. By default this method will update the cache.</param>
-        /// <param name="userId">Optional Id of the User issueing the publishing</param>
-        /// <returns>True if unpublishing succeeded, otherwise False</returns>
-        private Attempt<UnPublishStatus> UnPublishDo(IContent content, bool omitCacheRefresh = false, int userId = 0)
-        {
-            var newest = GetById(content.Id); // ensure we have the newest version
-            if (content.Version != newest.Version) // but use the original object if it's already the newest version
-                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
-            }
-
-            using (var uow = UowProvider.GetUnitOfWork())
-            {
-                var unpublished = _publishingStrategy.UnPublish(uow, content, userId);
-                if (unpublished == false)
-                {
-                    uow.Commit();
-                    return Attempt.Fail(new UnPublishStatus(content, UnPublishedStatusType.FailedCancelledByEvent, evtMsgs));
-                }
-
-                var repository = RepositoryFactory.CreateContentRepository(uow);
-
-                content.WriterId = userId;
-                repository.AddOrUpdate(content);
-                // is published is not newest, reset the published flag on published version
-                if (published.Version != content.Version)
-                    repository.ClearPublished(published);
-                repository.DeleteContentXml(content);
-
-                //Delete xml from db? and call following method to fire event through PublishingStrategy to update cache
-                if (omitCacheRefresh == false)
-                    _publishingStrategy.UnPublishingFinalized(uow, content);
-
-                Audit(uow, AuditType.UnPublish, "UnPublish performed by user", userId, content.Id);
-                uow.Commit();
-            }
-
-            return Attempt.Succeed(new UnPublishStatus(content, UnPublishedStatusType.Success, evtMsgs));
-        }
-
-        /// <summary>
-        /// Saves and Publishes a single <see cref="IContent"/> object
-        /// </summary>
-        /// <param name="content">The <see cref="IContent"/> to save and publish</param>
-        /// <param name="userId">Optional Id of the User issueing the publishing</param>
-        /// <param name="raiseEvents">Optional boolean indicating whether or not to raise save events.</param>
-        /// <returns>True if publishing succeeded, otherwise False</returns>
-        private Attempt<PublishStatus> SaveAndPublishDo(IContent content, int userId = 0, bool raiseEvents = true)
-        {
-            var evtMsgs = EventMessagesFactory.Get();
-
-            using (new WriteLock(Locker))
-            {
-                using (var uow = UowProvider.GetUnitOfWork())
-                {
-                    var saveEventArgs = new SaveEventArgs<IContent>(content, evtMsgs);
-                    if (raiseEvents && uow.Events.DispatchCancelable(Saving, this, saveEventArgs, "Saving"))
-                    {
-                        uow.Commit();
-                        return Attempt.Fail(new PublishStatus(content, PublishStatusType.FailedCancelledByEvent, evtMsgs));
-                    }
-
-                    //Has this content item previously been published? If so, we don't need to refresh the children
-                    var previouslyPublished = content.HasIdentity && HasPublishedVersion(content.Id); //content might not have an id
-                    var publishStatus = new PublishStatus(content, PublishStatusType.Success, evtMsgs); //initially set to success
-
-                    //Check if parent is published (although not if its a root node) - if parent isn't published this Content cannot be published
-                    publishStatus.StatusType = CheckAndLogIsPublishable(content);
-                    //if it is not successful, then check if the props are valid
-                    if ((int)publishStatus.StatusType < 10)
-                    {
-                        //Content contains invalid property values and can therefore not be published - fire event?
-                        publishStatus.StatusType = CheckAndLogIsValid(content);
-                        //set the invalid properties (if there are any)
-                        publishStatus.InvalidProperties = ((ContentBase)content).LastInvalidProperties;
-                    }
-                    //if we're still successful, then publish using the strategy
-                    if (publishStatus.StatusType == PublishStatusType.Success)
-                    {
-                        //Publish and then update the database with new status
-                        var publishResult = _publishingStrategy.Publish(uow, content, userId);
-                        //set the status type to the publish result
-                        publishStatus.StatusType = publishResult.Result.StatusType;
-                    }
-
-                    //we are successfully published if our publishStatus is still Successful
-                    bool published = publishStatus.StatusType == PublishStatusType.Success;
-
-                    var repository = RepositoryFactory.CreateContentRepository(uow);
-
-                    if (published == false)
-                    {
-                        content.ChangePublishedState(PublishedState.Saved);
-                    }
-                    //Since this is the Save and Publish method, the content should be saved even though the publish fails or isn't allowed
-                    if (content.HasIdentity == false)
-                    {
-                        content.CreatorId = userId;
-                    }
-                    content.WriterId = userId;
-
-                    repository.AddOrUpdate(content);
-                    repository.AddOrUpdatePreviewXml(content, c => _entitySerializer.Serialize(this, _dataTypeService, _userService, c));
-
-                    if (published)
-                    {
-                        //Content Xml
-                        repository.AddOrUpdateContentXml(content, c => _entitySerializer.Serialize(this, _dataTypeService, _userService, c));
-                    }
-
-                    if (raiseEvents)
-                    {
-                        saveEventArgs.CanCancel = false;
-                        uow.Events.Dispatch(Saved, this, saveEventArgs, "Saved");
-                    }
-
-                    //Save xml to db and call following method to fire event through PublishingStrategy to update cache
-                    if (published)
-                    {
-                        _publishingStrategy.PublishingFinalized(uow, content);
-                    }
-
-                    //We need to check if children and their publish state to ensure that we 'republish' content that was previously published
-                    if (published && previouslyPublished == false && HasChildren(content.Id))
-                    {
-                    //TODO: Horrible for performance if there are lots of descendents! We should page if anything but this is crazy
-                        var descendants = GetPublishedDescendants(content);
-                        _publishingStrategy.PublishingFinalized(uow, descendants, false);
-                    }
-
-                    uow.Commit();
-
-                    if (publishStatus.StatusType == PublishStatusType.Success)
-                    {
-                        Audit(uow, AuditType.Publish, "Save and Publish performed by user", userId, content.Id);
-                    }
-                    else
-                    {
-                        Audit(uow, AuditType.Save, "Save performed by user", userId, content.Id);
-                    }
-                    uow.Commit();
-
-                    return Attempt.If(publishStatus.StatusType == PublishStatusType.Success, publishStatus);
-                }
-            }
-        }
-
-        /// <summary>
-        /// Saves a single <see cref="IContent"/> object
-        /// </summary>
-        /// <param name="content">The <see cref="IContent"/> to save</param>
-        /// <param name="changeState">Boolean indicating whether or not to change the Published state upon saving</param>
-        /// <param name="userId">Optional Id of the User saving the Content</param>
-        /// <param name="raiseEvents">Optional boolean indicating whether or not to raise events.</param>
-        private Attempt<OperationStatus> Save(IContent content, bool changeState, int userId = 0, bool raiseEvents = true)
-        {
-            var evtMsgs = EventMessagesFactory.Get();
-
-            using (new WriteLock(Locker))
-            {
-                using (var uow = UowProvider.GetUnitOfWork())
-                {
-                    var saveEventArgs = new SaveEventArgs<IContent>(content, evtMsgs);
-                    if (raiseEvents && uow.Events.DispatchCancelable(Saving, this, saveEventArgs, "Saving"))
-                    {
-                        uow.Commit();
-                        return OperationStatus.Cancelled(evtMsgs);
-                    }
-
-                    if (string.IsNullOrWhiteSpace(content.Name))
-                    {
-                        throw new ArgumentException("Cannot save content with empty name.");
-                    }
-
-                    var repository = RepositoryFactory.CreateContentRepository(uow);
-
-                    if (content.HasIdentity == false)
-                    {
-                        content.CreatorId = userId;
-                    }
-                    content.WriterId = userId;
-
-                    //Only change the publish state if the "previous" version was actually published or marked as unpublished
-                    if (changeState && (content.Published || ((Content)content).PublishedState == PublishedState.Unpublished))
-                        content.ChangePublishedState(PublishedState.Saved);
-
-                    repository.AddOrUpdate(content);
-
-                    //Generate a new preview
-                    repository.AddOrUpdatePreviewXml(content, c => _entitySerializer.Serialize(this, _dataTypeService, _userService, c));
-
-                    if (raiseEvents)
-                    {
-                        saveEventArgs.CanCancel = false;
-                        uow.Events.Dispatch(Saved, this, saveEventArgs, "Saved");
-                    }
-
-                    Audit(uow, AuditType.Save, "Save Content performed by user", userId, content.Id);
-                    uow.Commit();
-                }
-
-                return OperationStatus.Success(evtMsgs);
-            }
-        }
-
-        private PublishStatusType CheckAndLogIsPublishable(IContent content)
-        {
-            //Check if parent is published (although not if its a root node) - if parent isn't published this Content cannot be published
-            if (content.ParentId != Constants.System.Root && content.ParentId != Constants.System.RecycleBinContent && IsPublishable(content) == false)
-            {
-                Logger.Info<ContentService>(
-                    string.Format(
-                        "Content '{0}' with Id '{1}' could not be published because its parent is not published.",
-                        content.Name, content.Id));
-                return PublishStatusType.FailedPathNotPublished;
-            }
-
-            if (content.ExpireDate.HasValue && content.ExpireDate.Value > DateTime.MinValue && DateTime.Now > content.ExpireDate.Value)
-            {
-                Logger.Info<ContentService>(
-                    string.Format(
-                        "Content '{0}' with Id '{1}' has expired and could not be published.",
-                        content.Name, content.Id));
-                return PublishStatusType.FailedHasExpired;
-            }
-
-            if (content.ReleaseDate.HasValue && content.ReleaseDate.Value > DateTime.MinValue && content.ReleaseDate.Value > DateTime.Now)
-            {
-                Logger.Info<ContentService>(
-                    string.Format(
-                        "Content '{0}' with Id '{1}' is awaiting release and could not be published.",
-                        content.Name, content.Id));
-                return PublishStatusType.FailedAwaitingRelease;
-            }
-
-            return PublishStatusType.Success;
-        }
-
-        private PublishStatusType CheckAndLogIsValid(IContent content)
-        {
-            //Content contains invalid property values and can therefore not be published - fire event?
-            if (content.IsValid() == false)
-            {
-                Logger.Info<ContentService>(
-                    string.Format(
-                        "Content '{0}' with Id '{1}' could not be published because of invalid properties.",
-                        content.Name, content.Id));
-                return PublishStatusType.FailedContentInvalid;
-            }
-
-            return PublishStatusType.Success;
-        }
-
-        private IContentType FindContentTypeByAlias(string contentTypeAlias)
-        {
-            using (var uow = UowProvider.GetUnitOfWork(readOnly: true))
-            {
-                var repository = RepositoryFactory.CreateContentTypeRepository(uow);
-
-                var query = Query<IContentType>.Builder.Where(x => x.Alias == contentTypeAlias);
-                var types = repository.GetByQuery(query);
-
-                if (types.Any() == false)
-                    throw new Exception(
-                        string.Format("No ContentType matching the passed in Alias: '{0}' was found",
-                                      contentTypeAlias));
-
-                var contentType = types.First();
-
-                if (contentType == null)
-                    throw new Exception(string.Format("ContentType matching the passed in Alias: '{0}' was null",
-                                                      contentTypeAlias));
-                return contentType;
-            }
-        }
-
-        #endregion
-
-        #region Proxy Event Handlers
-        /// <summary>
-        /// Occurs before publish.
-        /// </summary>
-        /// <remarks>Proxy to the real event on the <see cref="PublishingStrategy"/></remarks>
-        public static event TypedEventHandler<IPublishingStrategy, PublishEventArgs<IContent>> Publishing
-        {
-            add { PublishingStrategy.Publishing += value; }
-            remove { PublishingStrategy.Publishing -= value; }
-        }
-
-        /// <summary>
-        /// Occurs after publish.
-        /// </summary>
-        /// <remarks>Proxy to the real event on the <see cref="PublishingStrategy"/></remarks>
-        public static event TypedEventHandler<IPublishingStrategy, PublishEventArgs<IContent>> Published
-        {
-            add { PublishingStrategy.Published += value; }
-            remove { PublishingStrategy.Published -= value; }
-        }
-        /// <summary>
-        /// Occurs before unpublish.
-        /// </summary>
-        /// <remarks>Proxy to the real event on the <see cref="PublishingStrategy"/></remarks>
-        public static event TypedEventHandler<IPublishingStrategy, PublishEventArgs<IContent>> UnPublishing
-        {
-            add { PublishingStrategy.UnPublishing += value; }
-            remove { PublishingStrategy.UnPublishing -= value; }
-        }
-
-        /// <summary>
-        /// Occurs after unpublish.
-        /// </summary>
-        /// <remarks>Proxy to the real event on the <see cref="PublishingStrategy"/></remarks>
-        public static event TypedEventHandler<IPublishingStrategy, PublishEventArgs<IContent>> UnPublished
-        {
-            add { PublishingStrategy.UnPublished += value; }
-            remove { PublishingStrategy.UnPublished -= value; }
-        }
-        #endregion
-
-        #region Event Handlers
-        /// <summary>
-        /// Occurs before Delete
-        /// </summary>
-        public static event TypedEventHandler<IContentService, DeleteEventArgs<IContent>> Deleting;
-
-        /// <summary>
-        /// Occurs after Delete
-        /// </summary>
-        public static event TypedEventHandler<IContentService, DeleteEventArgs<IContent>> Deleted;
-
-        /// <summary>
-        /// Occurs before Delete Versions
-        /// </summary>
-        public static event TypedEventHandler<IContentService, DeleteRevisionsEventArgs> DeletingVersions;
-
-        /// <summary>
-        /// Occurs after Delete Versions
-        /// </summary>
-        public static event TypedEventHandler<IContentService, DeleteRevisionsEventArgs> DeletedVersions;
-
-        /// <summary>
-        /// Occurs before Save
-        /// </summary>
-        public static event TypedEventHandler<IContentService, SaveEventArgs<IContent>> Saving;
-
-        /// <summary>
-        /// Occurs after Save
-        /// </summary>
-        public static event TypedEventHandler<IContentService, SaveEventArgs<IContent>> Saved;
-
-        /// <summary>
-        /// Occurs before Create
-        /// </summary>
-        [Obsolete("Use the Created event instead, the Creating and Created events both offer the same functionality, Creating event has been deprecated.")]
-        public static event TypedEventHandler<IContentService, NewEventArgs<IContent>> Creating;
-
-        /// <summary>
-        /// Occurs after Create
-        /// </summary>
-        /// <remarks>
-        /// Please note that the Content object has been created, but might not have been saved
-        /// so it does not have an identity yet (meaning no Id has been set).
-        /// </remarks>
-        public static event TypedEventHandler<IContentService, NewEventArgs<IContent>> Created;
-
-        /// <summary>
-        /// Occurs before Copy
-        /// </summary>
-        public static event TypedEventHandler<IContentService, CopyEventArgs<IContent>> Copying;
-
-        /// <summary>
-        /// Occurs after Copy
-        /// </summary>
-        public static event TypedEventHandler<IContentService, CopyEventArgs<IContent>> Copied;
-
-        /// <summary>
-        /// Occurs before Content is moved to Recycle Bin
-        /// </summary>
-        public static event TypedEventHandler<IContentService, MoveEventArgs<IContent>> Trashing;
-
-        /// <summary>
-        /// Occurs after Content is moved to Recycle Bin
-        /// </summary>
-        public static event TypedEventHandler<IContentService, MoveEventArgs<IContent>> Trashed;
-
-        /// <summary>
-        /// Occurs before Move
-        /// </summary>
-        public static event TypedEventHandler<IContentService, MoveEventArgs<IContent>> Moving;
-
-        /// <summary>
-        /// Occurs after Move
-        /// </summary>
-        public static event TypedEventHandler<IContentService, MoveEventArgs<IContent>> Moved;
-
-        /// <summary>
-        /// Occurs before Rollback
-        /// </summary>
-        public static event TypedEventHandler<IContentService, RollbackEventArgs<IContent>> RollingBack;
-
-        /// <summary>
-        /// Occurs after Rollback
-        /// </summary>
-        public static event TypedEventHandler<IContentService, RollbackEventArgs<IContent>> RolledBack;
-
-        /// <summary>
-        /// Occurs before Send to Publish
-        /// </summary>
-        public static event TypedEventHandler<IContentService, SendToPublishEventArgs<IContent>> SendingToPublish;
-
-        /// <summary>
-        /// Occurs after Send to Publish
-        /// </summary>
-        public static event TypedEventHandler<IContentService, SendToPublishEventArgs<IContent>> SentToPublish;
-
-        /// <summary>
-        /// Occurs before the Recycle Bin is emptied
-        /// </summary>
-        public static event TypedEventHandler<IContentService, RecycleBinEventArgs> EmptyingRecycleBin;
-
-        /// <summary>
-        /// Occurs after the Recycle Bin has been Emptied
-        /// </summary>
-        public static event TypedEventHandler<IContentService, RecycleBinEventArgs> EmptiedRecycleBin;
-
-        /// <summary>
-        /// Occurs after a blueprint has been saved.
-        /// </summary>
-        public static event TypedEventHandler<IContentService, SaveEventArgs<IContent>> SavedBlueprint;
-
-        /// <summary>
-        /// Occurs after a blueprint has been deleted.
-        /// </summary>
-        public static event TypedEventHandler<IContentService, DeleteEventArgs<IContent>> DeletedBlueprint;
-
-        #endregion
-    }
-}
+using System;
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.Globalization;
+using System.IO;
+using System.Linq;
+using System.Text.RegularExpressions;
+using System.Threading;
+using System.Xml;
+using System.Xml.Linq;
+using Umbraco.Core.Events;
+using Umbraco.Core.Logging;
+using Umbraco.Core.Models;
+using Umbraco.Core.Models.Membership;
+using Umbraco.Core.Models.Rdbms;
+using Umbraco.Core.Persistence;
+using Umbraco.Core.Persistence.DatabaseModelDefinitions;
+using Umbraco.Core.Persistence.Querying;
+using Umbraco.Core.Persistence.Repositories;
+using Umbraco.Core.Persistence.UnitOfWork;
+using Umbraco.Core.Publishing;
+
+namespace Umbraco.Core.Services
+{
+    /// <summary>
+    /// Represents the Content Service, which is an easy access to operations involving <see cref="IContent"/>
+    /// </summary>
+    public class ContentService : ScopeRepositoryService, IContentService, IContentServiceOperations
+    {
+        private readonly IPublishingStrategy2 _publishingStrategy;
+        private readonly EntityXmlSerializer _entitySerializer = new EntityXmlSerializer();
+        private readonly IDataTypeService _dataTypeService;
+        private readonly IUserService _userService;
+
+        //Support recursive locks because some of the methods that require locking call other methods that require locking.
+        //for example, the Move method needs to be locked but this calls the Save method which also needs to be locked.
+        private static readonly ReaderWriterLockSlim Locker = new ReaderWriterLockSlim(LockRecursionPolicy.SupportsRecursion);
+        private static readonly Regex AnchorRegex = new Regex("<a id=\"(.*?)\">", RegexOptions.Compiled);
+
+        public ContentService(
+            IDatabaseUnitOfWorkProvider provider,
+            RepositoryFactory repositoryFactory,
+            ILogger logger,
+            IEventMessagesFactory eventMessagesFactory,
+            IDataTypeService dataTypeService,
+            IUserService userService)
+            : base(provider, repositoryFactory, logger, eventMessagesFactory)
+        {
+            if (dataTypeService == null) throw new ArgumentNullException("dataTypeService");
+            if (userService == null) throw new ArgumentNullException("userService");
+            _publishingStrategy = new PublishingStrategy(UowProvider.ScopeProvider, eventMessagesFactory, logger);
+            _dataTypeService = dataTypeService;
+            _userService = userService;
+        }
+
+        #region Static Queries
+
+        private IQuery<IContent> _notTrashedQuery;
+
+        #endregion
+
+        public int CountPublished(string contentTypeAlias = null)
+        {
+            using (var uow = UowProvider.GetUnitOfWork(readOnly: true))
+            {
+                var repository = RepositoryFactory.CreateContentRepository(uow);
+                return repository.CountPublished(contentTypeAlias);
+            }
+        }
+
+        public int Count(string contentTypeAlias = null)
+        {
+            using (var uow = UowProvider.GetUnitOfWork(readOnly: true))
+            {
+                var repository = RepositoryFactory.CreateContentRepository(uow);
+                return repository.Count(contentTypeAlias);
+            }
+        }
+
+        public int CountChildren(int parentId, string contentTypeAlias = null)
+        {
+            using (var uow = UowProvider.GetUnitOfWork(readOnly: true))
+            {
+                var repository = RepositoryFactory.CreateContentRepository(uow);
+                return repository.CountChildren(parentId, contentTypeAlias);
+            }
+        }
+
+        public int CountDescendants(int parentId, string contentTypeAlias = null)
+        {
+            using (var uow = UowProvider.GetUnitOfWork(readOnly: true))
+            {
+                var repository = RepositoryFactory.CreateContentRepository(uow);
+                return repository.CountDescendants(parentId, contentTypeAlias);
+            }
+        }
+
+        /// <summary>
+        /// Used to bulk update the permissions set for a content item. This will replace all permissions
+        /// assigned to an entity with a list of user id & permission pairs.
+        /// </summary>
+        /// <param name="permissionSet"></param>
+        public void ReplaceContentPermissions(EntityPermissionSet permissionSet)
+        {
+            using (var uow = UowProvider.GetUnitOfWork())
+            {
+                var repository = RepositoryFactory.CreateContentRepository(uow);
+                repository.ReplaceContentPermissions(permissionSet);
+                uow.Commit();
+            }
+        }
+
+        /// <summary>
+        /// Assigns a single permission to the current content item for the specified group ids
+        /// </summary>
+        /// <param name="entity"></param>
+        /// <param name="permission"></param>
+        /// <param name="groupIds"></param>
+        public void AssignContentPermission(IContent entity, char permission, IEnumerable<int> groupIds)
+        {
+            using (var uow = UowProvider.GetUnitOfWork())
+            {
+                var repository = RepositoryFactory.CreateContentRepository(uow);
+                repository.AssignEntityPermission(entity, permission, groupIds);
+                uow.Commit();
+            }
+        }
+
+        /// <summary>
+        /// Returns implicit/inherited permissions assigned to the content item for all user groups
+        /// </summary>
+        /// <param name="content"></param>
+        /// <returns></returns>
+        public EntityPermissionCollection GetPermissionsForEntity(IContent content)
+        {
+            using (var uow = UowProvider.GetUnitOfWork(readOnly: true))
+            {
+                var repository = RepositoryFactory.CreateContentRepository(uow);
+                return repository.GetPermissionsForEntity(content.Id);
+            }
+        }
+
+        /// <summary>
+        /// Creates an <see cref="IContent"/> object using the alias of the <see cref="IContentType"/>
+        /// that this Content should based on.
+        /// </summary>
+        /// <remarks>
+        /// Note that using this method will simply return a new IContent without any identity
+        /// as it has not yet been persisted. It is intended as a shortcut to creating new content objects
+        /// that does not invoke a save operation against the database.
+        /// </remarks>
+        /// <param name="name">Name of the Content object</param>
+        /// <param name="parentId">Id of Parent for the new Content</param>
+        /// <param name="contentTypeAlias">Alias of the <see cref="IContentType"/></param>
+        /// <param name="userId">Optional id of the user creating the content</param>
+        /// <returns><see cref="IContent"/></returns>
+        public IContent CreateContent(string name, Guid parentId, string contentTypeAlias, int userId = 0)
+        {
+            var parent = GetById(parentId);
+            return CreateContent(name, parent, contentTypeAlias, userId);
+        }
+
+        /// <summary>
+        /// Creates an <see cref="IContent"/> object using the alias of the <see cref="IContentType"/>
+        /// that this Content should based on.
+        /// </summary>
+        /// <remarks>
+        /// Note that using this method will simply return a new IContent without any identity
+        /// as it has not yet been persisted. It is intended as a shortcut to creating new content objects
+        /// that does not invoke a save operation against the database.
+        /// </remarks>
+        /// <param name="name">Name of the Content object</param>
+        /// <param name="parentId">Id of Parent for the new Content</param>
+        /// <param name="contentTypeAlias">Alias of the <see cref="IContentType"/></param>
+        /// <param name="userId">Optional id of the user creating the content</param>
+        /// <returns><see cref="IContent"/></returns>
+        public IContent CreateContent(string name, int parentId, string contentTypeAlias, int userId = 0)
+        {
+            var contentType = FindContentTypeByAlias(contentTypeAlias);
+            var content = new Content(name, parentId, contentType);
+            var parent = GetById(content.ParentId);
+            content.Path = string.Concat(parent.IfNotNull(x => x.Path, content.ParentId.ToString()), ",", content.Id);
+
+            using (var uow = UowProvider.GetUnitOfWork())
+            {
+                var newEventArgs = new NewEventArgs<IContent>(content, contentTypeAlias, parentId);
+                if (uow.Events.DispatchCancelable(Creating, this, newEventArgs))
+                {
+                    uow.Commit();
+                    content.WasCancelled = true;
+                    return content;
+                }
+
+                content.CreatorId = userId;
+                content.WriterId = userId;
+                newEventArgs.CanCancel = false;
+                uow.Events.Dispatch(Created, this, newEventArgs);
+
+                uow.Commit();
+            }
+
+            return content;
+        }
+
+        /// <summary>
+        /// Creates an <see cref="IContent"/> object using the alias of the <see cref="IContentType"/>
+        /// that this Content should based on.
+        /// </summary>
+        /// <remarks>
+        /// Note that using this method will simply return a new IContent without any identity
+        /// as it has not yet been persisted. It is intended as a shortcut to creating new content objects
+        /// that does not invoke a save operation against the database.
+        /// </remarks>
+        /// <param name="name">Name of the Content object</param>
+        /// <param name="parent">Parent <see cref="IContent"/> object for the new Content</param>
+        /// <param name="contentTypeAlias">Alias of the <see cref="IContentType"/></param>
+        /// <param name="userId">Optional id of the user creating the content</param>
+        /// <returns><see cref="IContent"/></returns>
+        public IContent CreateContent(string name, IContent parent, string contentTypeAlias, int userId = 0)
+        {
+            if (parent == null) throw new ArgumentNullException("parent");
+
+            var contentType = FindContentTypeByAlias(contentTypeAlias);
+            var content = new Content(name, parent, contentType);
+            content.Path = string.Concat(parent.Path, ",", content.Id);
+
+            using (var uow = UowProvider.GetUnitOfWork())
+            {
+                var newEventArgs = new NewEventArgs<IContent>(content, contentTypeAlias, parent);
+                if (uow.Events.DispatchCancelable(Creating, this, newEventArgs))
+                {
+                    uow.Commit();
+                    content.WasCancelled = true;
+                    return content;
+                }
+
+                content.CreatorId = userId;
+                content.WriterId = userId;
+                newEventArgs.CanCancel = false;
+                uow.Events.Dispatch(Created, this, newEventArgs);
+
+                uow.Commit();
+            }
+
+            return content;
+        }
+
+        /// <summary>
+        /// Creates and saves an <see cref="IContent"/> object using the alias of the <see cref="IContentType"/>
+        /// that this Content should based on.
+        /// </summary>
+        /// <remarks>
+        /// This method returns an <see cref="IContent"/> object that has been persisted to the database
+        /// and therefor has an identity.
+        /// </remarks>
+        /// <param name="name">Name of the Content object</param>
+        /// <param name="parentId">Id of Parent for the new Content</param>
+        /// <param name="contentTypeAlias">Alias of the <see cref="IContentType"/></param>
+        /// <param name="userId">Optional id of the user creating the content</param>
+        /// <returns><see cref="IContent"/></returns>
+        public IContent CreateContentWithIdentity(string name, int parentId, string contentTypeAlias, int userId = 0)
+        {
+            var contentType = FindContentTypeByAlias(contentTypeAlias);
+            var content = new Content(name, parentId, contentType);
+
+            using (var uow = UowProvider.GetUnitOfWork())
+            {
+                //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.
+                var newEventArgs = new NewEventArgs<IContent>(content, contentTypeAlias, parentId);
+                if (uow.Events.DispatchCancelable(Creating, this, newEventArgs))
+                {
+                    uow.Commit();
+                    content.WasCancelled = true;
+                    return content;
+                }
+
+                var saveEventArgs = new SaveEventArgs<IContent>(content);
+                if (uow.Events.DispatchCancelable(Saving, this, saveEventArgs, "Saving"))
+                {
+                    uow.Commit();
+                    content.WasCancelled = true;
+                    return content;
+                }
+
+                var repository = RepositoryFactory.CreateContentRepository(uow);
+                content.CreatorId = userId;
+                content.WriterId = userId;
+
+                repository.AddOrUpdate(content);
+                repository.AddOrUpdatePreviewXml(content, c => _entitySerializer.Serialize(this, _dataTypeService, _userService, c));
+                saveEventArgs.CanCancel = false;
+                uow.Events.Dispatch(Saved, this, saveEventArgs, "Saved");
+                newEventArgs.CanCancel = false;
+                uow.Events.Dispatch(Created, this, newEventArgs);
+
+                Audit(uow, AuditType.New, string.Format("Content '{0}' was created with Id {1}", name, content.Id), content.CreatorId, content.Id);
+                uow.Commit();
+            }
+
+            return content;
+        }
+
+        public IEnumerable<string> GetAnchorValuesFromRTEs(int id)
+        {
+            var result = new List<string>();
+
+            var content = GetById(id);
+
+            foreach (var contentProperty in content.Properties)
+            {
+                if (contentProperty.PropertyType.PropertyEditorAlias.InvariantEquals(Constants.PropertyEditors.TinyMCEAlias))
+                {
+                    var value = contentProperty.Value?.ToString();
+
+                    if (!string.IsNullOrEmpty(value))
+                    {
+                        result.AddRange(GetAnchorValuesFromRTEContent(value));
+                    }
+
+                }
+            }
+
+
+            return result;
+        }
+
+
+        public IEnumerable<string> GetAnchorValuesFromRTEContent(string rteContent)
+        {
+            var result = new List<string>();
+
+            var matches = AnchorRegex.Matches(rteContent);
+
+            foreach (Match match in matches)
+            {
+                result.Add(match.Value.Split('\"')[1]);
+            }
+
+            return result;
+        }
+
+        /// <summary>
+        /// Creates and saves an <see cref="IContent"/> object using the alias of the <see cref="IContentType"/>
+        /// that this Content should based on.
+        /// </summary>
+        /// <remarks>
+        /// This method returns an <see cref="IContent"/> object that has been persisted to the database
+        /// and therefor has an identity.
+        /// </remarks>
+        /// <param name="name">Name of the Content object</param>
+        /// <param name="parent">Parent <see cref="IContent"/> object for the new Content</param>
+        /// <param name="contentTypeAlias">Alias of the <see cref="IContentType"/></param>
+        /// <param name="userId">Optional id of the user creating the content</param>
+        /// <returns><see cref="IContent"/></returns>
+        public IContent CreateContentWithIdentity(string name, IContent parent, string contentTypeAlias, int userId = 0)
+        {
+            if (parent == null) throw new ArgumentNullException("parent");
+
+            var contentType = FindContentTypeByAlias(contentTypeAlias);
+            var content = new Content(name, parent, contentType);
+
+            using (var uow = UowProvider.GetUnitOfWork())
+            {
+                //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.
+                var newEventArgs = new NewEventArgs<IContent>(content, contentTypeAlias, parent);
+                if (uow.Events.DispatchCancelable(Creating, this, newEventArgs))
+                {
+                    uow.Commit();
+                    content.WasCancelled = true;
+                    return content;
+                }
+
+                var saveEventArgs = new SaveEventArgs<IContent>(content);
+                if (uow.Events.DispatchCancelable(Saving, this, saveEventArgs, "Saving"))
+                {
+                    uow.Commit();
+                    content.WasCancelled = true;
+                    return content;
+                }
+
+                var repository = RepositoryFactory.CreateContentRepository(uow);
+                content.CreatorId = userId;
+                content.WriterId = userId;
+
+                repository.AddOrUpdate(content);
+                repository.AddOrUpdatePreviewXml(content, c => _entitySerializer.Serialize(this, _dataTypeService, _userService, c));
+                saveEventArgs.CanCancel = false;
+                uow.Events.Dispatch(Saved, this, saveEventArgs, "Saved");
+                newEventArgs.CanCancel = false;
+                uow.Events.Dispatch(Created, this, newEventArgs);
+
+                Audit(uow, AuditType.New, string.Format("Content '{0}' was created with Id {1}", name, content.Id), content.CreatorId, content.Id);
+                uow.Commit();
+            }
+
+            return content;
+        }
+
+        /// <summary>
+        /// Gets an <see cref="IContent"/> object by Id
+        /// </summary>
+        /// <param name="id">Id of the Content to retrieve</param>
+        /// <returns><see cref="IContent"/></returns>
+        public IContent GetById(int id)
+        {
+            using (var uow = UowProvider.GetUnitOfWork(readOnly: true))
+            {
+                var repository = RepositoryFactory.CreateContentRepository(uow);
+                return repository.Get(id);
+            }
+        }
+
+        /// <summary>
+        /// Gets <see cref="IContent"/> objects by Ids
+        /// </summary>
+        /// <param name="ids">Ids of the Content to retrieve</param>
+        /// <returns><see cref="IContent"/></returns>
+        public IEnumerable<IContent> GetByIds(IEnumerable<int> ids)
+        {
+            var idsArray = ids.ToArray();
+            if (idsArray.Length == 0) return Enumerable.Empty<IContent>();
+
+            using (var uow = UowProvider.GetUnitOfWork(readOnly: true))
+            {
+                var repository = RepositoryFactory.CreateContentRepository(uow);
+
+                // ensure that the result has the order based on the ids passed in
+                var result = repository.GetAll(idsArray);
+                var content = result.ToDictionary(x => x.Id, x => x);
+
+                var sortedResult = idsArray.Select(x =>
+                {
+                    IContent c;
+                    return content.TryGetValue(x, out c) ? c : null;
+                }).WhereNotNull();
+
+                return sortedResult;
+            }
+        }
+
+        /// <summary>
+        /// Gets <see cref="IContent"/> objects by Ids
+        /// </summary>
+        /// <param name="ids">Ids of the Content to retrieve</param>
+        /// <returns><see cref="IContent"/></returns>
+        public IEnumerable<IContent> GetByIds(IEnumerable<Guid> ids)
+        {
+            var idsArray = ids.ToArray();
+            if (idsArray.Length == 0) return Enumerable.Empty<IContent>();
+
+            using (var uow = UowProvider.GetUnitOfWork(readOnly: true))
+            {
+                var repository = RepositoryFactory.CreateContentRepository(uow);
+
+                // ensure that the result has the order based on the ids passed in
+                var result = repository.GetAll(idsArray);
+                var content = result.ToDictionary(x => x.Key, x => x);
+
+                var sortedResult = idsArray.Select(x =>
+                {
+                    IContent c;
+                    return content.TryGetValue(x, out c) ? c : null;
+                }).WhereNotNull();
+
+                return sortedResult;
+            }
+        }
+
+        /// <summary>
+        /// Gets an <see cref="IContent"/> object by its 'UniqueId'
+        /// </summary>
+        /// <param name="key">Guid key of the Content to retrieve</param>
+        /// <returns><see cref="IContent"/></returns>
+        public IContent GetById(Guid key)
+        {
+            using (var uow = UowProvider.GetUnitOfWork(readOnly: true))
+            {
+                var repository = RepositoryFactory.CreateContentRepository(uow);
+                return repository.Get(key);
+            }
+        }
+
+        /// <summary>
+        /// Gets a collection of <see cref="IContent"/> objects by the Id of the <see cref="IContentType"/>
+        /// </summary>
+        /// <param name="id">Id of the <see cref="IContentType"/></param>
+        /// <returns>An Enumerable list of <see cref="IContent"/> objects</returns>
+        public IEnumerable<IContent> GetContentOfContentType(int id)
+        {
+            using (var uow = UowProvider.GetUnitOfWork(readOnly: true))
+            {
+                var repository = RepositoryFactory.CreateContentRepository(uow);
+                var query = Query<IContent>.Builder.Where(x => x.ContentTypeId == id);
+                return repository.GetByQuery(query);
+            }
+        }
+
+        internal IEnumerable<IContent> GetPublishedContentOfContentType(int id)
+        {
+            using (var uow = UowProvider.GetUnitOfWork(readOnly: true))
+            {
+                var repository = RepositoryFactory.CreateContentRepository(uow);
+                var query = Query<IContent>.Builder.Where(x => x.ContentTypeId == id);
+                return repository.GetByPublishedVersion(query);
+            }
+        }
+
+        /// <summary>
+        /// Gets a collection of <see cref="IContent"/> objects by Level
+        /// </summary>
+        /// <param name="level">The level to retrieve Content from</param>
+        /// <returns>An Enumerable list of <see cref="IContent"/> objects</returns>
+        public IEnumerable<IContent> GetByLevel(int level)
+        {
+            using (var uow = UowProvider.GetUnitOfWork(readOnly: true))
+            {
+                var repository = RepositoryFactory.CreateContentRepository(uow);
+                var query = Query<IContent>.Builder.Where(x => x.Level == level && x.Path.StartsWith(Constants.System.RecycleBinContent.ToInvariantString()) == false);
+                return repository.GetByQuery(query);
+            }
+        }
+
+        /// <summary>
+        /// Gets a specific version of an <see cref="IContent"/> item.
+        /// </summary>
+        /// <param name="versionId">Id of the version to retrieve</param>
+        /// <returns>An <see cref="IContent"/> item</returns>
+        public IContent GetByVersion(Guid versionId)
+        {
+            using (var uow = UowProvider.GetUnitOfWork(readOnly: true))
+            {
+                var repository = RepositoryFactory.CreateContentRepository(uow);
+                return repository.GetByVersion(versionId);
+            }
+        }
+
+
+        /// <summary>
+        /// Gets a collection of an <see cref="IContent"/> objects versions by Id
+        /// </summary>
+        /// <param name="id"></param>
+        /// <returns>An Enumerable list of <see cref="IContent"/> objects</returns>
+        public IEnumerable<IContent> GetVersions(int id)
+        {
+            using (var uow = UowProvider.GetUnitOfWork(readOnly: true))
+            {
+                var repository = RepositoryFactory.CreateContentRepository(uow);
+                return repository.GetAllVersions(id);
+            }
+        }
+
+        /// <summary>
+        /// Gets a list of all version Ids for the given content item ordered so latest is first
+        /// </summary>
+        /// <param name="id"></param>
+        /// <param name="maxRows">The maximum number of rows to return</param>
+        /// <returns></returns>
+        public IEnumerable<Guid> GetVersionIds(int id, int maxRows)
+        {
+            using (var uow = UowProvider.GetUnitOfWork(readOnly: true))
+            {
+                var repository = RepositoryFactory.CreateContentRepository(uow);
+                return repository.GetVersionIds(id, maxRows);
+            }
+        }
+
+        /// <summary>
+        /// Gets a collection of <see cref="IContent"/> objects, which are ancestors of the current content.
+        /// </summary>
+        /// <param name="id">Id of the <see cref="IContent"/> to retrieve ancestors for</param>
+        /// <returns>An Enumerable list of <see cref="IContent"/> objects</returns>
+        public IEnumerable<IContent> GetAncestors(int id)
+        {
+            var content = GetById(id);
+            return GetAncestors(content);
+        }
+
+        /// <summary>
+        /// Gets a collection of <see cref="IContent"/> objects, which are ancestors of the current content.
+        /// </summary>
+        /// <param name="content"><see cref="IContent"/> to retrieve ancestors for</param>
+        /// <returns>An Enumerable list of <see cref="IContent"/> objects</returns>
+        public IEnumerable<IContent> GetAncestors(IContent content)
+        {
+            //null check otherwise we get exceptions
+            if (content.Path.IsNullOrWhiteSpace()) return Enumerable.Empty<IContent>();
+
+            var ids = content.Path.Split(',').Where(x => x != Constants.System.Root.ToInvariantString() && x != content.Id.ToString(CultureInfo.InvariantCulture)).Select(int.Parse).ToArray();
+            if (ids.Any() == false)
+                return new List<IContent>();
+
+            using (var uow = UowProvider.GetUnitOfWork(readOnly: true))
+            {
+                var repository = RepositoryFactory.CreateContentRepository(uow);
+                return repository.GetAll(ids);
+            }
+        }
+
+        /// <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>
+        /// <returns>An Enumerable list of <see cref="IContent"/> objects</returns>
+        public IEnumerable<IContent> GetChildren(int id)
+        {
+            using (var uow = UowProvider.GetUnitOfWork(readOnly: true))
+            {
+                var repository = RepositoryFactory.CreateContentRepository(uow);
+                var query = Query<IContent>.Builder.Where(x => x.ParentId == id);
+                return repository.GetByQuery(query).OrderBy(x => x.SortOrder);
+            }
+        }
+
+        [Obsolete("Use the overload with 'long' parameter types instead")]
+        [EditorBrowsable(EditorBrowsableState.Never)]
+        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;
+        }
+
+        /// <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="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, 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");
+
+            using (var uow = UowProvider.GetUnitOfWork(readOnly: true))
+            {
+                var repository = RepositoryFactory.CreateContentRepository(uow);
+
+                var query = Query<IContent>.Builder;
+                // always check for a parent - else it will also get decendants (and then you should use the GetPagedDescendants method)
+                query.Where(x => x.ParentId == id);
+
+                IQuery<IContent> filterQuery = null;
+                if (filter.IsNullOrWhiteSpace() == false)
+                {
+                    filterQuery = Query<IContent>.Builder.Where(x => x.Name.Contains(filter));
+                }
+                return repository.GetPagedResultsByQuery(query, pageIndex, pageSize, out totalChildren, orderBy, orderDirection, orderBySystemField, filterQuery);
+            }
+        }
+
+        [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");
+            using (var uow = UowProvider.GetUnitOfWork(readOnly: true))
+            {
+                var repository = RepositoryFactory.CreateContentRepository(uow);
+
+                // get query - if the id is System Root, then just get all
+                var query = Query<IContent>.Builder;
+                if (id != Constants.System.Root)
+                {
+                    var entityRepository = RepositoryFactory.CreateEntityRepository(uow);
+                    var contentPath = entityRepository.GetAllPaths(Constants.ObjectTypes.DocumentGuid, id).ToArray();
+                    if (contentPath.Length == 0)
+                    {
+                        totalChildren = 0;
+                        return Enumerable.Empty<IContent>();
+                    }
+                    query.Where(x => x.Path.SqlStartsWith(string.Format("{0},", contentPath[0].Path), TextColumnType.NVarchar));
+                }
+
+
+                // get filter
+                IQuery<IContent> filterQuery = null;
+                if (filter.IsNullOrWhiteSpace() == false)
+                    filterQuery = Query<IContent>.Builder.Where(x => x.Name.Contains(filter));
+
+                return repository.GetPagedResultsByQuery(query, pageIndex, pageSize, out totalChildren, orderBy, orderDirection, orderBySystemField, filterQuery);
+            }
+        }
+
+        /// <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 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, IQuery<IContent> filter)
+        {
+            Mandate.ParameterCondition(pageIndex >= 0, "pageIndex");
+            Mandate.ParameterCondition(pageSize > 0, "pageSize");
+
+            using (var uow = UowProvider.GetUnitOfWork(readOnly: true))
+            {
+                var repository = RepositoryFactory.CreateContentRepository(uow);
+
+                // get query - if the id is System Root, then just get all
+                var query = Query<IContent>.Builder;
+                if (id != Constants.System.Root)
+                {
+                    var entityRepository = RepositoryFactory.CreateEntityRepository(uow);
+                    var contentPath = entityRepository.GetAllPaths(Constants.ObjectTypes.DocumentGuid, id).ToArray();
+                    if (contentPath.Length == 0)
+                    {
+                        totalChildren = 0;
+                        return Enumerable.Empty<IContent>();
+                    }
+                    query.Where(x => x.Path.SqlStartsWith(string.Format("{0},", contentPath[0].Path), TextColumnType.NVarchar));
+                }
+
+                return repository.GetPagedResultsByQuery(query, pageIndex, pageSize, out totalChildren, orderBy, orderDirection, orderBySystemField, filter);
+            }
+        }
+
+        /// <summary>
+        /// Gets a collection of <see cref="IContent"/> objects by its name or partial name
+        /// </summary>
+        /// <param name="parentId">Id of the Parent to retrieve Children from</param>
+        /// <param name="name">Full or partial name of the children</param>
+        /// <returns>An Enumerable list of <see cref="IContent"/> objects</returns>
+        public IEnumerable<IContent> GetChildrenByName(int parentId, string name)
+        {
+            using (var uow = UowProvider.GetUnitOfWork(readOnly: true))
+            {
+                var repository = RepositoryFactory.CreateContentRepository(uow);
+
+                var query = Query<IContent>.Builder.Where(x => x.ParentId == parentId && x.Name.Contains(name));
+                return repository.GetByQuery(query);
+            }
+        }
+
+        /// <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>
+        /// <returns>An Enumerable list of <see cref="IContent"/> objects</returns>
+        public IEnumerable<IContent> GetDescendants(int id)
+        {
+            var content = GetById(id);
+            return content == null ? Enumerable.Empty<IContent>() : GetDescendants(content);
+        }
+
+        /// <summary>
+        /// Gets a collection of <see cref="IContent"/> objects by Parent Id
+        /// </summary>
+        /// <param name="content"><see cref="IContent"/> item to retrieve Descendants from</param>
+        /// <returns>An Enumerable list of <see cref="IContent"/> objects</returns>
+        public IEnumerable<IContent> GetDescendants(IContent content)
+        {
+            //This is a check to ensure that the path is correct for this entity to avoid problems like: http://issues.umbraco.org/issue/U4-9336 due to data corruption
+            if (content.ValidatePath() == false)
+                throw new InvalidDataException(string.Format("The content item {0} has an invalid path: {1} with parentID: {2}", content.Id, content.Path, content.ParentId));
+
+            using (var uow = UowProvider.GetUnitOfWork(readOnly: true))
+            {
+                var repository = RepositoryFactory.CreateContentRepository(uow);
+
+                var pathMatch = content.Path + ",";
+                var query = Query<IContent>.Builder.Where(x => x.Path.StartsWith(pathMatch) && x.Id != content.Id);
+                return repository.GetByQuery(query);
+            }
+        }
+
+        /// <summary>
+        /// Gets the parent of the current content as an <see cref="IContent"/> item.
+        /// </summary>
+        /// <param name="id">Id of the <see cref="IContent"/> to retrieve the parent from</param>
+        /// <returns>Parent <see cref="IContent"/> object</returns>
+        public IContent GetParent(int id)
+        {
+            var content = GetById(id);
+            return GetParent(content);
+        }
+
+        /// <summary>
+        /// Gets the parent of the current content as an <see cref="IContent"/> item.
+        /// </summary>
+        /// <param name="content"><see cref="IContent"/> to retrieve the parent from</param>
+        /// <returns>Parent <see cref="IContent"/> object</returns>
+        public IContent GetParent(IContent content)
+        {
+            if (content.ParentId == Constants.System.Root || content.ParentId == Constants.System.RecycleBinContent)
+                return null;
+
+            return GetById(content.ParentId);
+        }
+
+        /// <summary>
+        /// Gets the published version of an <see cref="IContent"/> item
+        /// </summary>
+        /// <param name="id">Id of the <see cref="IContent"/> to retrieve version from</param>
+        /// <returns>An <see cref="IContent"/> item</returns>
+        public IContent GetPublishedVersion(int id)
+        {
+            var version = GetVersions(id);
+            return version.FirstOrDefault(x => x.Published);
+        }
+
+        /// <summary>
+        /// Gets the published version of a <see cref="IContent"/> item.
+        /// </summary>
+        /// <param name="content">The content item.</param>
+        /// <returns>The published version, if any; otherwise, null.</returns>
+        public IContent GetPublishedVersion(IContent content)
+        {
+            if (content.Published) return content;
+            return content.HasPublishedVersion
+                ? GetByVersion(content.PublishedVersionGuid)
+                : null;
+        }
+
+        /// <summary>
+        /// Gets a collection of <see cref="IContent"/> objects, which reside at the first level / root
+        /// </summary>
+        /// <returns>An Enumerable list of <see cref="IContent"/> objects</returns>
+        public IEnumerable<IContent> GetRootContent()
+        {
+            using (var uow = UowProvider.GetUnitOfWork(readOnly: true))
+            {
+                var repository = RepositoryFactory.CreateContentRepository(uow);
+
+                var query = Query<IContent>.Builder.Where(x => x.ParentId == Constants.System.Root);
+                return repository.GetByQuery(query);
+            }
+        }
+
+        /// <summary>
+        /// Gets all published content items
+        /// </summary>
+        /// <returns></returns>
+        internal IEnumerable<IContent> GetAllPublished()
+        {
+            //create it once if it is needed (no need for locking here)
+            if (_notTrashedQuery == null)
+            {
+                _notTrashedQuery = Query<IContent>.Builder.Where(x => x.Trashed == false);
+            }
+
+            using (var uow = UowProvider.GetUnitOfWork(readOnly: true))
+            {
+                var repository = RepositoryFactory.CreateContentRepository(uow);
+                return repository.GetByPublishedVersion(_notTrashedQuery);
+            }
+        }
+
+        /// <summary>
+        /// Gets a collection of <see cref="IContent"/> objects, which has an expiration date less than or equal to today.
+        /// </summary>
+        /// <returns>An Enumerable list of <see cref="IContent"/> objects</returns>
+        public IEnumerable<IContent> GetContentForExpiration()
+        {
+            using (var uow = UowProvider.GetUnitOfWork(readOnly: true))
+            {
+                var repository = RepositoryFactory.CreateContentRepository(uow);
+                var query = Query<IContent>.Builder.Where(x => x.ExpireDate <= DateTime.Now);
+                return repository.GetByQuery(query).Where(x => x.HasPublishedVersion);
+            }
+        }
+
+        /// <summary>
+        /// Gets a collection of <see cref="IContent"/> objects, which has a release date less than or equal to today.
+        /// </summary>
+        /// <returns>An Enumerable list of <see cref="IContent"/> objects</returns>
+        public IEnumerable<IContent> GetContentForRelease()
+        {
+            using (var uow = UowProvider.GetUnitOfWork(readOnly: true))
+            {
+                var repository = RepositoryFactory.CreateContentRepository(uow);
+                var query = Query<IContent>.Builder.Where(x => x.Published == false && x.ReleaseDate <= DateTime.Now);
+                return repository.GetByQuery(query);
+            }
+        }
+
+        /// <summary>
+        /// Gets a collection of an <see cref="IContent"/> objects, which resides in the Recycle Bin
+        /// </summary>
+        /// <returns>An Enumerable list of <see cref="IContent"/> objects</returns>
+        public IEnumerable<IContent> GetContentInRecycleBin()
+        {
+            using (var uow = UowProvider.GetUnitOfWork(readOnly: true))
+            {
+                var repository = RepositoryFactory.CreateContentRepository(uow);
+                var query = Query<IContent>.Builder.Where(x => x.Path.StartsWith(Constants.System.RecycleBinContentPathPrefix));
+                return repository.GetByQuery(query);
+            }
+        }
+
+        /// <summary>
+        /// Checks whether an <see cref="IContent"/> item has any children
+        /// </summary>
+        /// <param name="id">Id of the <see cref="IContent"/></param>
+        /// <returns>True if the content has any children otherwise False</returns>
+        public bool HasChildren(int id)
+        {
+            return CountChildren(id) > 0;
+        }
+
+        internal int CountChildren(int id)
+        {
+            using (var uow = UowProvider.GetUnitOfWork(readOnly: true))
+            {
+                var repository = RepositoryFactory.CreateContentRepository(uow);
+                var query = Query<IContent>.Builder.Where(x => x.ParentId == id);
+                return repository.Count(query);
+            }
+        }
+
+        /// <summary>
+        /// Checks whether an <see cref="IContent"/> item has any published versions
+        /// </summary>
+        /// <param name="id">Id of the <see cref="IContent"/></param>
+        /// <returns>True if the content has any published version otherwise False</returns>
+        public bool HasPublishedVersion(int id)
+        {
+            using (var uow = UowProvider.GetUnitOfWork(readOnly: true))
+            {
+                var repository = RepositoryFactory.CreateContentRepository(uow);
+                var query = Query<IContent>.Builder.Where(x => x.Published == true && x.Id == id && x.Trashed == false);
+                return repository.Count(query) > 0;
+            }
+        }
+
+        /// <summary>
+        /// Checks if the passed in <see cref="IContent"/> can be published based on the anscestors publish state.
+        /// </summary>
+        /// <param name="content"><see cref="IContent"/> to check if anscestors are published</param>
+        /// <returns>True if the Content can be published, otherwise False</returns>
+        public bool IsPublishable(IContent content)
+        {
+            int[] ids;
+            if (content.HasIdentity)
+            {
+                // get ids from path (we have identity)
+                // skip the first one that has to be -1 - and we don't care
+                // skip the last one that has to be "this" - and it's ok to stop at the parent
+                ids = content.Path.Split(',').Skip(1).SkipLast().Select(int.Parse).ToArray();
+            }
+            else
+            {
+                // no path yet (no identity), have to move up to parent
+                // skip the first one that has to be -1 - and we don't care
+                // don't skip the last one that is "parent"
+                var parent = GetById(content.ParentId);
+                if (parent == null) return false;
+                ids = parent.Path.Split(',').Skip(1).Select(int.Parse).ToArray();
+            }
+            if (ids.Length == 0)
+                return false;
+
+            // if the first one is recycle bin, fail fast
+            if (ids[0] == Constants.System.RecycleBinContent)
+                return false;
+
+            // fixme - move to repository?
+            using (var uow = UowProvider.GetUnitOfWork(readOnly: true))
+            {
+                var sql = new Sql(@"
+                    SELECT id
+                    FROM umbracoNode
+                    JOIN cmsDocument ON umbracoNode.id=cmsDocument.nodeId AND cmsDocument.published=@0
+                    WHERE umbracoNode.trashed=@1 AND umbracoNode.id IN (@2)",
+                    true, false, ids);
+                var x = uow.Database.Fetch<int>(sql);
+                return ids.Length == x.Count;
+            }
+        }
+
+        /// <summary>
+        /// This will rebuild the xml structures for content in the database.
+        /// </summary>
+        /// <param name="userId">This is not used for anything</param>
+        /// <returns>True if publishing succeeded, otherwise False</returns>
+        /// <remarks>
+        /// This is used for when a document type alias or a document type property is changed, the xml will need to
+        /// be regenerated.
+        /// </remarks>
+        public bool RePublishAll(int userId = 0)
+        {
+            try
+            {
+                RebuildXmlStructures();
+                return true;
+            }
+            catch (Exception ex)
+            {
+                Logger.Error<ContentService>("An error occurred executing RePublishAll", ex);
+                return false;
+            }
+        }
+
+        /// <summary>
+        /// This will rebuild the xml structures for content in the database.
+        /// </summary>
+        /// <param name="contentTypeIds">
+        /// If specified will only rebuild the xml for the content type's specified, otherwise will update the structure
+        /// for all published content.
+        /// </param>
+        internal void RePublishAll(params int[] contentTypeIds)
+        {
+            try
+            {
+                RebuildXmlStructures(contentTypeIds);
+            }
+            catch (Exception ex)
+            {
+                Logger.Error<ContentService>("An error occurred executing RePublishAll", ex);
+            }
+        }
+
+        /// <summary>
+        /// Publishes a single <see cref="IContent"/> object
+        /// </summary>
+        /// <param name="content">The <see cref="IContent"/> to publish</param>
+        /// <param name="userId">Optional Id of the User issueing the publishing</param>
+        /// <returns>True if publishing succeeded, otherwise False</returns>
+        public bool Publish(IContent content, int userId = 0)
+        {
+            var result = SaveAndPublishDo(content, userId);
+            Logger.Info<ContentService>("Call was made to ContentService.Publish, use PublishWithStatus instead since that method will provide more detailed information on the outcome");
+            return result.Success;
+        }
+
+        /// <summary>
+        /// Publishes a <see cref="IContent"/> object and all its children
+        /// </summary>
+        /// <param name="content">The <see cref="IContent"/> to publish along with its children</param>
+        /// <param name="userId">Optional Id of the User issueing the publishing</param>
+        /// <param name="includeUnpublished"></param>
+        /// <returns>The list of statuses for all published items</returns>
+        IEnumerable<Attempt<PublishStatus>> IContentServiceOperations.PublishWithChildren(IContent content, int userId, bool includeUnpublished)
+        {
+            return PublishWithChildrenDo(content, userId, includeUnpublished);
+        }
+
+        /// <summary>
+        /// Saves and Publishes a single <see cref="IContent"/> object
+        /// </summary>
+        /// <param name="content">The <see cref="IContent"/> to save and publish</param>
+        /// <param name="userId">Optional Id of the User issueing the publishing</param>
+        /// <param name="raiseEvents">Optional boolean indicating whether or not to raise save events.</param>
+        /// <returns>True if publishing succeeded, otherwise False</returns>
+        Attempt<PublishStatus> IContentServiceOperations.SaveAndPublish(IContent content, int userId, bool raiseEvents)
+        {
+            return SaveAndPublishDo(content, userId, raiseEvents);
+        }
+
+        /// <summary>
+        /// Deletes an <see cref="IContent"/> object by moving it to the Recycle Bin
+        /// </summary>
+        /// <remarks>Move an item to the Recycle Bin will result in the item being unpublished</remarks>
+        /// <param name="content">The <see cref="IContent"/> to delete</param>
+        /// <param name="userId">Optional Id of the User deleting the Content</param>
+        Attempt<OperationStatus> IContentServiceOperations.MoveToRecycleBin(IContent content, int userId)
+        {
+            return MoveToRecycleBinDo(content, userId, false);
+        }
+
+        /// <summary>
+        /// Deletes an <see cref="IContent"/> object by moving it to the Recycle Bin
+        /// </summary>
+        /// <remarks>Move an item to the Recycle Bin will result in the item being unpublished</remarks>
+        /// <param name="content">The <see cref="IContent"/> to delete</param>
+        /// <param name="userId">Optional Id of the User deleting the Content</param>
+        /// <param name="ignoreDescendants">
+        /// A boolean indicating to ignore this item's descendant list from also being moved to the recycle bin. This is required for the DeleteContentOfTypes method
+        /// because it has already looked up all descendant nodes that will need to be recycled
+        /// TODO: Fix all of this, it will require a reasonable refactor and most of this stuff should be done at the repo level instead of service sub operations
+        /// </param>
+        private Attempt<OperationStatus> MoveToRecycleBinDo(IContent content, int userId, bool ignoreDescendants)
+        {
+            var evtMsgs = EventMessagesFactory.Get();
+            using (new WriteLock(Locker))
+            {
+                using (var uow = UowProvider.GetUnitOfWork())
+                {
+                    //Hack: this ensures that the entity's path is valid and if not it fixes/persists it
+                    //see: http://issues.umbraco.org/issue/U4-9336
+                    content.EnsureValidPath(Logger, entity => GetById(entity.ParentId), QuickUpdate);
+                    var originalPath = content.Path;
+                    var moveEventInfo = new MoveEventInfo<IContent>(content, originalPath, Constants.System.RecycleBinContent);
+                    var moveEventArgs = new MoveEventArgs<IContent>(evtMsgs, moveEventInfo);
+                    if (uow.Events.DispatchCancelable(Trashing, this, moveEventArgs, "Trashing"))
+                    {
+                        uow.Commit();
+                        return OperationStatus.Cancelled(evtMsgs);
+                    }
+                    var moveInfo = new List<MoveEventInfo<IContent>>
+                    {
+                        moveEventInfo
+                    };
+
+                    //get descendents to process of the content item that is being moved to trash - must be done before changing the state below
+                    //must be processed with shallowest levels first
+                    var descendants = ignoreDescendants ? Enumerable.Empty<IContent>() : GetDescendants(content).OrderBy(x => x.Level);
+
+                    //Do the updates for this item
+                    var repository = RepositoryFactory.CreateContentRepository(uow);
+                    //Make sure that published content is unpublished before being moved to the Recycle Bin
+                    if (HasPublishedVersion(content.Id))
+                    {
+                        //TODO: this shouldn't be a 'sub operation', and if it needs to be it cannot raise events and cannot be cancelled!
+                        UnPublish(content, userId);
+                    }
+                    content.WriterId = userId;
+                    content.ChangeTrashedState(true);
+                    repository.AddOrUpdate(content);
+
+                    //Loop through descendants to update their trash state, but ensuring structure by keeping the ParentId
+                    foreach (var descendant in descendants)
+                    {
+                        //TODO: this shouldn't be a 'sub operation', and if it needs to be it cannot raise events and cannot be cancelled!
+                        UnPublish(descendant, userId);
+                        descendant.WriterId = userId;
+                        descendant.ChangeTrashedState(true, descendant.ParentId);
+                        repository.AddOrUpdate(descendant);
+
+                        moveInfo.Add(new MoveEventInfo<IContent>(descendant, descendant.Path, descendant.ParentId));
+                    }
+
+                    moveEventArgs.CanCancel = false;
+                    moveEventArgs.MoveInfoCollection = moveInfo;
+                    uow.Events.Dispatch(Trashed, this, moveEventArgs, "Trashed");
+
+                    Audit(uow, AuditType.Move, "Move Content to Recycle Bin performed by user", userId, content.Id);
+                    uow.Commit();
+                }
+
+                return OperationStatus.Success(evtMsgs);
+            }
+        }
+
+        /// <summary>
+        /// UnPublishes a single <see cref="IContent"/> object
+        /// </summary>
+        /// <param name="content">The <see cref="IContent"/> to publish</param>
+        /// <param name="userId">Optional Id of the User issueing the publishing</param>
+        /// <returns>True if unpublishing succeeded, otherwise False</returns>
+        Attempt<UnPublishStatus> IContentServiceOperations.UnPublish(IContent content, int userId)
+        {
+            return UnPublishDo(content, false, userId);
+        }
+
+        /// <summary>
+        /// Publishes a single <see cref="IContent"/> object
+        /// </summary>
+        /// <param name="content">The <see cref="IContent"/> to publish</param>
+        /// <param name="userId">Optional Id of the User issueing the publishing</param>
+        /// <returns>True if publishing succeeded, otherwise False</returns>
+        public Attempt<PublishStatus> PublishWithStatus(IContent content, int userId = 0)
+        {
+            return ((IContentServiceOperations)this).Publish(content, userId);
+        }
+
+        /// <summary>
+        /// Publishes a <see cref="IContent"/> object and all its children
+        /// </summary>
+        /// <param name="content">The <see cref="IContent"/> to publish along with its children</param>
+        /// <param name="userId">Optional Id of the User issueing the publishing</param>
+        /// <returns>True if publishing succeeded, otherwise False</returns>
+        [Obsolete("Use PublishWithChildrenWithStatus instead, that method will provide more detailed information on the outcome and also allows the includeUnpublished flag")]
+        public bool PublishWithChildren(IContent content, int userId = 0)
+        {
+            var result = PublishWithChildrenDo(content, userId, true);
+
+            //This used to just return false only when the parent content failed, otherwise would always return true so we'll
+            // do the same thing for the moment
+            if (result.All(x => x.Result.ContentItem.Id != content.Id))
+                return false;
+
+            return result.Single(x => x.Result.ContentItem.Id == content.Id).Success;
+        }
+
+        /// <summary>
+        /// Publishes a <see cref="IContent"/> object and all its children
+        /// </summary>
+        /// <param name="content">The <see cref="IContent"/> to publish along with its children</param>
+        /// <param name="userId">Optional Id of the User issueing the publishing</param>
+        /// <param name="includeUnpublished">set to true if you want to also publish children that are currently unpublished</param>
+        /// <returns>True if publishing succeeded, otherwise False</returns>
+        public IEnumerable<Attempt<PublishStatus>> PublishWithChildrenWithStatus(IContent content, int userId = 0, bool includeUnpublished = false)
+        {
+            return ((IContentServiceOperations)this).PublishWithChildren(content, userId, includeUnpublished);
+        }
+
+        /// <summary>
+        /// UnPublishes a single <see cref="IContent"/> object
+        /// </summary>
+        /// <param name="content">The <see cref="IContent"/> to publish</param>
+        /// <param name="userId">Optional Id of the User issueing the publishing</param>
+        /// <returns>True if unpublishing succeeded, otherwise False</returns>
+        public bool UnPublish(IContent content, int userId = 0)
+        {
+            var attempt = ((IContentServiceOperations)this).UnPublish(content, userId);
+            LogHelper.Debug<ContentService>(string.Format("Result of unpublish attempt: {0}", attempt.Result.StatusType));
+            return attempt.Success;
+        }
+
+        /// <summary>
+        /// Saves and Publishes a single <see cref="IContent"/> object
+        /// </summary>
+        /// <param name="content">The <see cref="IContent"/> to save and publish</param>
+        /// <param name="userId">Optional Id of the User issueing the publishing</param>
+        /// <param name="raiseEvents">Optional boolean indicating whether or not to raise save events.</param>
+        /// <returns>True if publishing succeeded, otherwise False</returns>
+        [Obsolete("Use SaveAndPublishWithStatus instead, that method will provide more detailed information on the outcome")]
+        public bool SaveAndPublish(IContent content, int userId = 0, bool raiseEvents = true)
+        {
+            var result = SaveAndPublishDo(content, userId, raiseEvents);
+            return result.Success;
+        }
+
+        /// <summary>
+        /// Saves and Publishes a single <see cref="IContent"/> object
+        /// </summary>
+        /// <param name="content">The <see cref="IContent"/> to save and publish</param>
+        /// <param name="userId">Optional Id of the User issueing the publishing</param>
+        /// <param name="raiseEvents">Optional boolean indicating whether or not to raise save events.</param>
+        /// <returns>True if publishing succeeded, otherwise False</returns>
+        public Attempt<PublishStatus> SaveAndPublishWithStatus(IContent content, int userId = 0, bool raiseEvents = true)
+        {
+            return ((IContentServiceOperations)this).SaveAndPublish(content, userId, raiseEvents);
+        }
+
+        public IContent GetBlueprintById(int id)
+        {
+            using (var uow = UowProvider.GetUnitOfWork(readOnly: true))
+            {
+                var repository = RepositoryFactory.CreateContentBlueprintRepository(uow);
+                var blueprint = repository.Get(id);
+                if (blueprint != null)
+                    ((Content) blueprint).IsBlueprint = true;
+                return blueprint;
+            }
+        }
+
+        public IContent GetBlueprintById(Guid id)
+        {
+            using (var uow = UowProvider.GetUnitOfWork(readOnly: true))
+            {
+                var repository = RepositoryFactory.CreateContentBlueprintRepository(uow);
+                var blueprint = repository.Get(id);
+                if (blueprint != null)
+                    ((Content)blueprint).IsBlueprint = true;
+                return blueprint;
+            }
+        }
+
+        public void SaveBlueprint(IContent content, int userId = 0)
+        {
+            //always ensure the blueprint is at the root
+            if (content.ParentId != -1)
+                content.ParentId = -1;
+
+            ((Content) content).IsBlueprint = true;
+
+            using (new WriteLock(Locker))
+            {
+                using (var uow = UowProvider.GetUnitOfWork())
+                {
+                    if (string.IsNullOrWhiteSpace(content.Name))
+                    {
+                        throw new ArgumentException("Cannot save content blueprint with empty name.");
+                    }
+
+                    var repository = RepositoryFactory.CreateContentBlueprintRepository(uow);
+
+                    if (content.HasIdentity == false)
+                    {
+                        content.CreatorId = userId;
+                    }
+                    content.WriterId = userId;
+
+                    repository.AddOrUpdate(content);
+
+                    uow.Events.Dispatch(SavedBlueprint, this, new SaveEventArgs<IContent>(content), "SavedBlueprint");
+
+                    uow.Commit();
+                }
+            }
+        }
+
+        public void DeleteBlueprint(IContent content, int userId = 0)
+        {
+            using (new WriteLock(Locker))
+            {
+                using (var uow = UowProvider.GetUnitOfWork())
+                {
+                    var repository = RepositoryFactory.CreateContentBlueprintRepository(uow);
+                    repository.Delete(content);
+                    uow.Events.Dispatch(DeletedBlueprint, this, new DeleteEventArgs<IContent>(content), "DeletedBlueprint");
+                    uow.Commit();
+                }
+            }
+        }
+
+        public IContent CreateContentFromBlueprint(IContent blueprint, string name, int userId = 0)
+        {
+            if (blueprint == null) throw new ArgumentNullException("blueprint");
+
+            var contentType = blueprint.ContentType;
+            var content = new Content(name, -1, contentType);
+            content.Path = string.Concat(content.ParentId.ToString(), ",", content.Id);
+
+            content.CreatorId = userId;
+            content.WriterId = userId;
+
+            foreach (var property in blueprint.Properties)
+                content.SetValue(property.Alias, property.Value);
+
+            return content;
+        }
+
+        public void DeleteBlueprintsOfTypes(IEnumerable<int> contentTypeIds, int userId = 0)
+        {
+            using (new WriteLock(Locker))
+            using (var uow = UowProvider.GetUnitOfWork())
+            {
+                var repository = RepositoryFactory.CreateContentBlueprintRepository(uow);
+
+                var contentTypeIdsA = contentTypeIds.ToArray();
+                var query = new Query<IContent>();
+                if (contentTypeIdsA.Length > 0)
+                {
+                    query.Where(x => contentTypeIdsA.Contains(x.ContentTypeId));
+                }
+                var blueprints = repository.GetByQuery(query).Select(x =>
+                {
+                    ((Content) x).IsBlueprint = true;
+                    return x;
+                }).ToArray();
+
+                foreach (var blueprint in blueprints)
+                {
+                    repository.Delete(blueprint);
+                }
+
+                uow.Events.Dispatch(DeletedBlueprint, this, new DeleteEventArgs<IContent>(blueprints), "DeletedBlueprint");
+                uow.Commit();
+            }
+        }
+
+        public void DeleteBlueprintsOfType(int contentTypeId, int userId = 0)
+        {
+            DeleteBlueprintsOfTypes(new[] {contentTypeId}, userId);
+        }
+
+        /// <summary>
+        /// Saves a single <see cref="IContent"/> object
+        /// </summary>
+        /// <param name="content">The <see cref="IContent"/> to save</param>
+        /// <param name="userId">Optional Id of the User saving the Content</param>
+        /// <param name="raiseEvents">Optional boolean indicating whether or not to raise events.</param>
+        public void Save(IContent content, int userId = 0, bool raiseEvents = true)
+        {
+            ((IContentServiceOperations)this).Save(content, userId, raiseEvents);
+        }
+
+        /// <summary>
+        /// Saves a collection of <see cref="IContent"/> objects.
+        /// </summary>
+        /// <param name="contents">Collection of <see cref="IContent"/> to save</param>
+        /// <param name="userId">Optional Id of the User saving the Content</param>
+        /// <param name="raiseEvents">Optional boolean indicating whether or not to raise events.</param>
+        Attempt<OperationStatus> IContentServiceOperations.Save(IEnumerable<IContent> contents, int userId, bool raiseEvents)
+        {
+            var asArray = contents.ToArray();
+
+            var evtMsgs = EventMessagesFactory.Get();
+
+            using (var uow = UowProvider.GetUnitOfWork())
+            {
+                var saveEventArgs = new SaveEventArgs<IContent>(asArray, evtMsgs);
+                if (raiseEvents && uow.Events.DispatchCancelable(Saving, this, saveEventArgs, "Saving"))
+                {
+                    uow.Commit();
+                    return OperationStatus.Cancelled(evtMsgs);
+                }
+
+                // todo - understand what's a lock in a scope?
+                // (though, these locks are refactored in v8)
+                using (new WriteLock(Locker))
+                {
+                    var containsNew = asArray.Any(x => x.HasIdentity == false);
+                    var repository = RepositoryFactory.CreateContentRepository(uow);
+
+                    if (containsNew)
+                    {
+                        foreach (var content in asArray)
+                        {
+                            content.WriterId = userId;
+
+                            //Only change the publish state if the "previous" version was actually published
+                            if (content.Published)
+                                content.ChangePublishedState(PublishedState.Saved);
+
+                            repository.AddOrUpdate(content);
+                            //add or update preview
+                            repository.AddOrUpdatePreviewXml(content, c => _entitySerializer.Serialize(this, _dataTypeService, _userService, c));
+                        }
+                    }
+                    else
+                    {
+                        foreach (var content in asArray)
+                        {
+                            content.WriterId = userId;
+                            repository.AddOrUpdate(content);
+                            //add or update preview
+                            repository.AddOrUpdatePreviewXml(content, c => _entitySerializer.Serialize(this, _dataTypeService, _userService, c));
+                        }
+                    }
+                }
+
+                if (raiseEvents)
+                {
+                    saveEventArgs.CanCancel = false;
+                    uow.Events.Dispatch(Saved, this, saveEventArgs, "Saved");
+                }
+
+                Audit(uow, AuditType.Save, "Bulk Save content performed by user", userId == -1 ? 0 : userId, Constants.System.Root);
+                uow.Commit();
+
+                return OperationStatus.Success(evtMsgs);
+            }
+        }
+
+        /// <summary>
+        /// Permanently deletes an <see cref="IContent"/> object.
+        /// </summary>
+        /// <remarks>
+        /// This method will also delete associated media files, child content and possibly associated domains.
+        /// </remarks>
+        /// <remarks>Please note that this method will completely remove the Content from the database</remarks>
+        /// <param name="content">The <see cref="IContent"/> to delete</param>
+        /// <param name="userId">Optional Id of the User deleting the Content</param>
+        Attempt<OperationStatus> IContentServiceOperations.Delete(IContent content, int userId)
+        {
+            var evtMsgs = EventMessagesFactory.Get();
+
+            using (new WriteLock(Locker))
+            {
+                using (var uow = UowProvider.GetUnitOfWork())
+                {
+                    var deleteEventArgs = new DeleteEventArgs<IContent>(content, evtMsgs);
+                    if (uow.Events.DispatchCancelable(Deleting, this, deleteEventArgs, "Deleting"))
+                    {
+                        uow.Commit();
+                        return OperationStatus.Cancelled(evtMsgs);
+                    }
+
+                    //Make sure that published content is unpublished before being deleted
+                    if (HasPublishedVersion(content.Id))
+                    {
+                        UnPublish(content, userId);
+                    }
+
+                    //Delete children before deleting the 'possible parent'
+                    var children = GetChildren(content.Id);
+                    foreach (var child in children)
+                    {
+                        Delete(child, userId);
+                    }
+
+                    var repository = RepositoryFactory.CreateContentRepository(uow);
+
+                    repository.Delete(content);
+
+                    deleteEventArgs.CanCancel = false;
+                    uow.Events.Dispatch(Deleted, this, deleteEventArgs, "Deleted");
+
+                    Audit(uow, AuditType.Delete, "Delete Content performed by user", userId, content.Id);
+                    uow.Commit();
+                }
+
+                return OperationStatus.Success(evtMsgs);
+            }
+        }
+
+        /// <summary>
+        /// Publishes a single <see cref="IContent"/> object
+        /// </summary>
+        /// <param name="content">The <see cref="IContent"/> to publish</param>
+        /// <param name="userId">Optional Id of the User issueing the publishing</param>
+        /// <returns>The published status attempt</returns>
+        Attempt<PublishStatus> IContentServiceOperations.Publish(IContent content, int userId)
+        {
+            return SaveAndPublishDo(content, userId);
+        }
+
+        /// <summary>
+        /// Saves a single <see cref="IContent"/> object
+        /// </summary>
+        /// <param name="content">The <see cref="IContent"/> to save</param>
+        /// <param name="userId">Optional Id of the User saving the Content</param>
+        /// <param name="raiseEvents">Optional boolean indicating whether or not to raise events.</param>
+        Attempt<OperationStatus> IContentServiceOperations.Save(IContent content, int userId, bool raiseEvents)
+        {
+            return Save(content, true, userId, raiseEvents);
+        }
+
+        /// <summary>
+        /// Saves a collection of <see cref="IContent"/> objects.
+        /// </summary>
+        /// <remarks>
+        /// If the collection of content contains new objects that references eachother by Id or ParentId,
+        /// then use the overload Save method with a collection of Lazy <see cref="IContent"/>.
+        /// </remarks>
+        /// <param name="contents">Collection of <see cref="IContent"/> to save</param>
+        /// <param name="userId">Optional Id of the User saving the Content</param>
+        /// <param name="raiseEvents">Optional boolean indicating whether or not to raise events.</param>
+        public void Save(IEnumerable<IContent> contents, int userId = 0, bool raiseEvents = true)
+        {
+            ((IContentServiceOperations)this).Save(contents, userId, raiseEvents);
+        }
+
+        /// <summary>
+        /// Deletes all content of the specified types. All Descendants of deleted content that is not of these types is moved to Recycle Bin.
+        /// </summary>
+        /// <param name="contentTypeIds">Id of the <see cref="IContentType"/></param>
+        /// <param name="userId">Optional Id of the user issueing the delete operation</param>
+        public void DeleteContentOfTypes(IEnumerable<int> contentTypeIds, int userId = 0)
+        {
+            using (new WriteLock(Locker))
+            using (var uow = UowProvider.GetUnitOfWork())
+            {
+                var repository = RepositoryFactory.CreateContentRepository(uow);
+
+                //track the 'root' items of the collection of nodes discovered to delete, we need to use
+                //these items to lookup descendants that are not of this doc type so they can be transfered
+                //to the recycle bin
+                IDictionary<string, IContent> rootItems;
+                var contentToDelete = this.TrackDeletionsForDeleteContentOfTypes(contentTypeIds, repository, out rootItems).ToArray();
+
+                if (uow.Events.DispatchCancelable(Deleting, this, new DeleteEventArgs<IContent>(contentToDelete), "Deleting"))
+                {
+                    uow.Commit();
+                    return;
+                }
+
+                //Determine the items that will need to be recycled (that are children of these content items but not of these content types)
+                var contentToRecycle = this.TrackTrashedForDeleteContentOfTypes(contentTypeIds, rootItems, repository);
+
+                //move each item to the bin starting with the deepest items
+                foreach (var child in contentToRecycle.OrderByDescending(x => x.Level))
+                {
+                    MoveToRecycleBinDo(child, userId, true);
+                }
+
+                foreach (var content in contentToDelete)
+                {
+                    Delete(content, userId);
+                }
+
+                Audit(uow, AuditType.Delete,
+                    string.Format("Delete Content of Types {0} performed by user", string.Join(",", contentTypeIds)),
+                    userId, Constants.System.Root);
+                uow.Commit();
+            }
+        }
+
+        /// <summary>
+        /// Deletes all content of specified type. All children of deleted content is moved to Recycle Bin.
+        /// </summary>
+        /// <remarks>This needs extra care and attention as its potentially a dangerous and extensive operation</remarks>
+        /// <param name="contentTypeId">Id of the <see cref="IContentType"/></param>
+        /// <param name="userId">Optional Id of the user issueing the delete operation</param>
+        public void DeleteContentOfType(int contentTypeId, int userId = 0)
+        {
+            DeleteContentOfTypes(new[] {contentTypeId}, userId);
+        }
+
+        /// <summary>
+        /// Permanently deletes an <see cref="IContent"/> object as well as all of its Children.
+        /// </summary>
+        /// <remarks>
+        /// This method will also delete associated media files, child content and possibly associated domains.
+        /// </remarks>
+        /// <remarks>Please note that this method will completely remove the Content from the database</remarks>
+        /// <param name="content">The <see cref="IContent"/> to delete</param>
+        /// <param name="userId">Optional Id of the User deleting the Content</param>
+        public void Delete(IContent content, int userId = 0)
+        {
+            ((IContentServiceOperations)this).Delete(content, userId);
+        }
+
+        /// <summary>
+        /// Permanently deletes versions from an <see cref="IContent"/> object prior to a specific date.
+        /// This method will never delete the latest version of a content item.
+        /// </summary>
+        /// <param name="id">Id of the <see cref="IContent"/> object to delete versions from</param>
+        /// <param name="versionDate">Latest version date</param>
+        /// <param name="userId">Optional Id of the User deleting versions of a Content object</param>
+        public void DeleteVersions(int id, DateTime versionDate, int userId = 0)
+        {
+            using (var uow = UowProvider.GetUnitOfWork())
+            {
+                var deleteRevisionsEventArgs = new DeleteRevisionsEventArgs(id, dateToRetain: versionDate);
+                if (uow.Events.DispatchCancelable(DeletingVersions, this, deleteRevisionsEventArgs, "DeletingVersions"))
+                {
+                    uow.Commit();
+                    return;
+                }
+
+                var repository = RepositoryFactory.CreateContentRepository(uow);
+                repository.DeleteVersions(id, versionDate);
+                deleteRevisionsEventArgs.CanCancel = false;
+                uow.Events.Dispatch(DeletedVersions, this, deleteRevisionsEventArgs, "DeletedVersions");
+
+                Audit(uow, AuditType.Delete, "Delete Content by version date performed by user", userId, Constants.System.Root);
+                uow.Commit();
+            }
+        }
+
+        /// <summary>
+        /// Permanently deletes specific version(s) from an <see cref="IContent"/> object.
+        /// This method will never delete the latest version of a content item.
+        /// </summary>
+        /// <param name="id">Id of the <see cref="IContent"/> object to delete a version from</param>
+        /// <param name="versionId">Id of the version to delete</param>
+        /// <param name="deletePriorVersions">Boolean indicating whether to delete versions prior to the versionId</param>
+        /// <param name="userId">Optional Id of the User deleting versions of a Content object</param>
+        public void DeleteVersion(int id, Guid versionId, bool deletePriorVersions, int userId = 0)
+        {
+            using (new WriteLock(Locker))
+            {
+                using (var uow = UowProvider.GetUnitOfWork())
+                {
+                    if (uow.Events.DispatchCancelable(DeletingVersions, this, new DeleteRevisionsEventArgs(id, specificVersion: versionId), "DeletingVersions"))
+                    {
+                        uow.Commit();
+                        return;
+                    }
+
+                    if (deletePriorVersions)
+                    {
+                        var content = GetByVersion(versionId);
+                        DeleteVersions(id, content.UpdateDate, userId);
+                    }
+
+                    var repository = RepositoryFactory.CreateContentRepository(uow);
+                    repository.DeleteVersion(versionId);
+
+                    uow.Events.Dispatch(DeletedVersions, this, new DeleteRevisionsEventArgs(id, false, specificVersion: versionId), "DeletedVersions");
+
+                    Audit(uow, AuditType.Delete, "Delete Content by version performed by user", userId, Constants.System.Root);
+                    uow.Commit();
+                }
+            }
+        }
+
+        /// <summary>
+        /// Deletes an <see cref="IContent"/> object by moving it to the Recycle Bin
+        /// </summary>
+        /// <remarks>Move an item to the Recycle Bin will result in the item being unpublished</remarks>
+        /// <param name="content">The <see cref="IContent"/> to delete</param>
+        /// <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);
+        }
+
+        /// <summary>
+        /// Moves an <see cref="IContent"/> object to a new location by changing its parent id.
+        /// </summary>
+        /// <remarks>
+        /// If the <see cref="IContent"/> object is already published it will be
+        /// published after being moved to its new location. Otherwise it'll just
+        /// be saved with a new parent id.
+        /// </remarks>
+        /// <param name="content">The <see cref="IContent"/> to move</param>
+        /// <param name="parentId">Id of the Content's new Parent</param>
+        /// <param name="userId">Optional Id of the User moving the Content</param>
+        public void Move(IContent content, int parentId, int userId = 0)
+        {
+            using (new WriteLock(Locker))
+            {
+                //This ensures that the correct method is called if this method is used to Move to recycle bin.
+                if (parentId == Constants.System.RecycleBinContent)
+                {
+                    MoveToRecycleBin(content, userId);
+                    return;
+                }
+
+                using (var uow = UowProvider.GetUnitOfWork())
+                {
+                    var moveEventInfo = new MoveEventInfo<IContent>(content, content.Path, parentId);
+                    var moveEventArgs = new MoveEventArgs<IContent>(moveEventInfo);
+                    if (uow.Events.DispatchCancelable(Moving, this, moveEventArgs, "Moving"))
+                    {
+                        uow.Commit();
+                        return;
+                    }
+
+                    //used to track all the moved entities to be given to the event
+                    var moveInfo = new List<MoveEventInfo<IContent>>();
+
+                    //call private method that does the recursive moving
+                    PerformMove(content, parentId, userId, moveInfo);
+
+                    moveEventArgs.MoveInfoCollection = moveInfo;
+                    moveEventArgs.CanCancel = false;
+                    uow.Events.Dispatch(Moved, this, moveEventArgs, "Moved");
+
+                    Audit(uow, AuditType.Move, "Move Content performed by user", userId, content.Id);
+                    uow.Commit();
+                }
+            }
+        }
+
+        /// <summary>
+        /// Empties the Recycle Bin by deleting all <see cref="IContent"/> that resides in the bin
+        /// </summary>
+        [EditorBrowsable(EditorBrowsableState.Never)]
+        [Obsolete("Use EmptyRecycleBin with explicit indication of user ID instead")]
+        public void EmptyRecycleBin() => EmptyRecycleBin(0);
+
+        /// <summary>
+        /// Empties the Recycle Bin by deleting all <see cref="IContent"/> that resides in the bin
+        /// </summary>
+        /// <param name="userId">Optional Id of the User emptying the Recycle Bin</param>
+        public void EmptyRecycleBin(int userId = 0)
+        {
+            using (new WriteLock(Locker))
+            {
+                var nodeObjectType = Constants.ObjectTypes.DocumentGuid;
+
+                using (var uow = UowProvider.GetUnitOfWork())
+                {
+                    var repository = RepositoryFactory.CreateContentRepository(uow);
+
+                    //Create a dictionary of ids -> dictionary of property aliases + values
+                    var entities = repository.GetEntitiesInRecycleBin()
+                        .ToDictionary(
+                            key => key.Id,
+                            val => (IEnumerable<Property>)val.Properties);
+
+                    var files = ((ContentRepository)repository).GetFilesInRecycleBinForUploadField();
+
+                    var recycleBinEventArgs = new RecycleBinEventArgs(nodeObjectType, entities, files);
+                    if (uow.Events.DispatchCancelable(EmptyingRecycleBin, this, recycleBinEventArgs))
+                    {
+                        uow.Commit();
+                        return;
+                    }
+
+                    var success = repository.EmptyRecycleBin();
+                    recycleBinEventArgs.CanCancel = false;
+                    recycleBinEventArgs.RecycleBinEmptiedSuccessfully = success;
+                    uow.Events.Dispatch(EmptiedRecycleBin, this, recycleBinEventArgs);
+
+                    Audit(uow, AuditType.Delete, "Empty Content Recycle Bin performed by user", userId, Constants.System.RecycleBinContent);
+                    uow.Commit();
+                }
+            }
+        }
+
+        /// <summary>
+        /// Copies an <see cref="IContent"/> object by creating a new Content object of the same type and copies all data from the current
+        /// to the new copy which is returned. Recursively copies all children.
+        /// </summary>
+        /// <param name="content">The <see cref="IContent"/> to copy</param>
+        /// <param name="parentId">Id of the Content's new Parent</param>
+        /// <param name="relateToOriginal">Boolean indicating whether the copy should be related to the original</param>
+        /// <param name="userId">Optional Id of the User copying the Content</param>
+        /// <returns>The newly created <see cref="IContent"/> object</returns>
+        public IContent Copy(IContent content, int parentId, bool relateToOriginal, int userId = 0)
+        {
+            return Copy(content, parentId, relateToOriginal, true, userId);
+        }
+
+        /// <summary>
+        /// Copies an <see cref="IContent"/> object by creating a new Content object of the same type and copies all data from the current
+        /// to the new copy which is returned.
+        /// </summary>
+        /// <param name="content">The <see cref="IContent"/> to copy</param>
+        /// <param name="parentId">Id of the Content's new Parent</param>
+        /// <param name="relateToOriginal">Boolean indicating whether the copy should be related to the original</param>
+        /// <param name="recursive">A value indicating whether to recursively copy children.</param>
+        /// <param name="userId">Optional Id of the User copying the Content</param>
+        /// <returns>The newly created <see cref="IContent"/> object</returns>
+        public IContent Copy(IContent content, int parentId, bool relateToOriginal, bool recursive, int userId = 0)
+        {
+            //TODO: This all needs to be managed correctly so that the logic is submitted in one
+            // transaction, the CRUD needs to be moved to the repo
+
+            using (new WriteLock(Locker))
+            {
+                var copy = content.DeepCloneWithResetIdentities();
+                copy.ParentId = parentId;
+
+                // A copy should never be set to published automatically even if the original was.
+                copy.ChangePublishedState(PublishedState.Unpublished);
+
+                using (var uow = UowProvider.GetUnitOfWork())
+                {
+                    var copyEventArgs = new CopyEventArgs<IContent>(content, copy, true, parentId, relateToOriginal);
+                    if (uow.Events.DispatchCancelable(Copying, this, copyEventArgs))
+                    {
+                        uow.Commit();
+                        return null;
+                    }
+
+                    var repository = RepositoryFactory.CreateContentRepository(uow);
+
+                    // Update the create author and last edit author
+                    copy.CreatorId = userId;
+                    copy.WriterId = userId;
+
+                    //get the current permissions, if there are any explicit ones they need to be copied
+                    var currentPermissions = GetPermissionsForEntity(content);
+                    currentPermissions.RemoveWhere(p => p.IsDefaultPermissions);
+
+                    repository.AddOrUpdate(copy);
+                    repository.AddOrUpdatePreviewXml(copy, c => _entitySerializer.Serialize(this, _dataTypeService, _userService, c));
+
+                    //add permissions
+                    if (currentPermissions.Count > 0)
+                    {
+                        var permissionSet = new ContentPermissionSet(copy, currentPermissions);
+                        repository.AddOrUpdatePermissions(permissionSet);
+                    }
+
+                    uow.Commit(); // todo - this should flush, not commit
+
+                    //Special case for the associated tags
+                    //TODO: Move this to the repository layer in a single transaction!
+                    //don't copy tags data in tags table if the item is in the recycle bin
+                    if (parentId != Constants.System.RecycleBinContent)
+                    {
+                        var tags = uow.Database.Fetch<TagRelationshipDto>("WHERE nodeId = @Id", new { Id = content.Id });
+                        foreach (var tag in tags)
+                            uow.Database.Insert(new TagRelationshipDto
+                            {
+                                NodeId = copy.Id, TagId = tag.TagId, PropertyTypeId = tag.PropertyTypeId
+                            });
+                    }
+                    uow.Commit(); // todo - this should flush, not commit
+
+                    if (recursive)
+                    {
+                        //Look for children and copy those as well
+                        var children = GetChildren(content.Id);
+                        foreach (var child in children)
+                        {
+                            //TODO: This shouldn't recurse back to this method, it should be done in a private method
+                            // that doesn't have a nested lock and so we can perform the entire operation in one commit.
+                            Copy(child, copy.Id, relateToOriginal, true, userId);
+                        }
+                    }
+                    copyEventArgs.CanCancel = false;
+                    uow.Events.Dispatch(Copied, this, copyEventArgs);
+                    Audit(uow, AuditType.Copy, "Copy Content performed by user", userId, content.Id);
+                    uow.Commit();
+                }
+
+                return copy;
+            }
+        }
+
+
+        /// <summary>
+        /// Sends an <see cref="IContent"/> to Publication, which executes handlers and events for the 'Send to Publication' action.
+        /// </summary>
+        /// <param name="content">The <see cref="IContent"/> to send to publication</param>
+        /// <param name="userId">Optional Id of the User issueing the send to publication</param>
+        /// <returns>True if sending publication was succesfull otherwise false</returns>
+        public bool SendToPublication(IContent content, int userId = 0)
+        {
+            using (var uow = UowProvider.GetUnitOfWork())
+            {
+                var sendToPublishEventArgs = new SendToPublishEventArgs<IContent>(content);
+                if (uow.Events.DispatchCancelable(SendingToPublish, this, sendToPublishEventArgs))
+                {
+                    uow.Commit();
+                    return false;
+                }
+
+                //Save before raising event
+                Save(content, userId);
+                sendToPublishEventArgs.CanCancel = false;
+                uow.Events.Dispatch(SentToPublish, this, sendToPublishEventArgs);
+
+                Audit(uow, AuditType.SendToPublish, "Send to Publish performed by user", content.WriterId, content.Id);
+                uow.Commit();
+
+                return true;
+            }
+        }
+
+        /// <summary>
+        /// Rollback an <see cref="IContent"/> object to a previous version.
+        /// This will create a new version, which is a copy of all the old data.
+        /// </summary>
+        /// <remarks>
+        /// The way data is stored actually only allows us to rollback on properties
+        /// and not data like Name and Alias of the Content.
+        /// </remarks>
+        /// <param name="id">Id of the <see cref="IContent"/>being rolled back</param>
+        /// <param name="versionId">Id of the version to rollback to</param>
+        /// <param name="userId">Optional Id of the User issueing the rollback of the Content</param>
+        /// <returns>The newly created <see cref="IContent"/> object</returns>
+        public IContent Rollback(int id, Guid versionId, int userId = 0)
+        {
+            var content = GetByVersion(versionId);
+
+            using (var uow = UowProvider.GetUnitOfWork())
+            {
+                var rollbackEventArgs = new RollbackEventArgs<IContent>(content);
+                if (uow.Events.DispatchCancelable(RollingBack, this, rollbackEventArgs))
+                {
+                    uow.Commit();
+                    return content;
+                }
+
+                var repository = RepositoryFactory.CreateContentRepository(uow);
+
+                content.WriterId = userId;
+                content.CreatorId = userId;
+                content.ChangePublishedState(PublishedState.Unpublished);
+
+                repository.AddOrUpdate(content);
+                repository.AddOrUpdatePreviewXml(content, c => _entitySerializer.Serialize(this, _dataTypeService, _userService, c));
+                rollbackEventArgs.CanCancel = false;
+                uow.Events.Dispatch(RolledBack, this, rollbackEventArgs);
+
+                Audit(uow, AuditType.RollBack, "Content rollback performed by user", content.WriterId, content.Id);
+                uow.Commit();
+            }
+
+            return content;
+        }
+
+        /// <summary>
+        /// Sorts a collection of <see cref="IContent"/> objects by updating the SortOrder according
+        /// to the ordering of items in the passed in <see cref="IEnumerable{T}"/>.
+        /// </summary>
+        /// <remarks>
+        /// Using this method will ensure that the Published-state is maintained upon sorting
+        /// so the cache is updated accordingly - as needed.
+        /// </remarks>
+        /// <param name="items"></param>
+        /// <param name="userId"></param>
+        /// <param name="raiseEvents"></param>
+        /// <returns>True if sorting succeeded, otherwise False</returns>
+        public bool Sort(IEnumerable<IContent> items, int userId = 0, bool raiseEvents = true)
+        {
+            var shouldBePublished = new List<IContent>();
+            var shouldBeSaved = new List<IContent>();
+
+            using (new WriteLock(Locker))
+            {
+                using (var uow = UowProvider.GetUnitOfWork())
+                {
+                    var asArray = items.ToArray();
+                    var saveEventArgs = new SaveEventArgs<IContent>(asArray);
+                    if (raiseEvents && uow.Events.DispatchCancelable(Saving, this, saveEventArgs, "Saving"))
+                    {
+                        uow.Commit();
+                        return false;
+                    }
+
+                    var repository = RepositoryFactory.CreateContentRepository(uow);
+
+                    var i = 0;
+                    foreach (var content in asArray)
+                    {
+                        //If the current sort order equals that of the content
+                        //we don't need to update it, so just increment the sort order
+                        //and continue.
+                        if (content.SortOrder == i)
+                        {
+                            i++;
+                            continue;
+                        }
+
+                        content.SortOrder = i;
+                        content.WriterId = userId;
+                        i++;
+
+                        if (content.Published)
+                        {
+                            //TODO: This should not be an inner operation, but if we do this, it cannot raise events and cannot be cancellable!
+                            var published = _publishingStrategy.Publish(uow, content, userId).Success;
+                            shouldBePublished.Add(content);
+                        }
+                        else
+                            shouldBeSaved.Add(content);
+
+                        repository.AddOrUpdate(content);
+                        //add or update a preview
+                        repository.AddOrUpdatePreviewXml(content, c => _entitySerializer.Serialize(this, _dataTypeService, _userService, c));
+                    }
+
+                    foreach (var content in shouldBePublished)
+                    {
+                        //Create and Save ContentXml DTO
+                        repository.AddOrUpdateContentXml(content, c => _entitySerializer.Serialize(this, _dataTypeService, _userService, c));
+                    }
+
+                    if (raiseEvents)
+                    {
+                        saveEventArgs.CanCancel = false;
+                        uow.Events.Dispatch(Saved, this, saveEventArgs, "Saved");
+                    }
+
+                    if (shouldBePublished.Any())
+                    {
+                        //TODO: This should not be an inner operation, but if we do this, it cannot raise events and cannot be cancellable!
+                        _publishingStrategy.PublishingFinalized(uow, shouldBePublished, false);
+                    }
+
+                    Audit(uow, AuditType.Sort, "Sorting content performed by user", userId, 0);
+                    uow.Commit();
+                }
+            }
+
+            return true;
+        }
+
+        /// <summary>
+        /// Sorts a collection of <see cref="IContent"/> objects by updating the SortOrder according
+        /// to the ordering of node Ids passed in.
+        /// </summary>
+        /// <remarks>
+        /// Using this method will ensure that the Published-state is maintained upon sorting
+        /// so the cache is updated accordingly - as needed.
+        /// </remarks>
+        /// <param name="ids"></param>
+        /// <param name="userId"></param>
+        /// <param name="raiseEvents"></param>
+        /// <returns>True if sorting succeeded, otherwise False</returns>
+        public bool Sort(int[] ids, int userId = 0, bool raiseEvents = true)
+        {
+            var shouldBePublished = new List<IContent>();
+            var shouldBeSaved = new List<IContent>();
+
+            using (new WriteLock(Locker))
+            {
+                var allContent = GetByIds(ids).ToDictionary(x => x.Id, x => x);
+                if (allContent.Any() == false)
+                {
+                    return false;
+                }
+                var items = ids.Select(x => allContent[x]).ToArray();
+
+                using (var uow = UowProvider.GetUnitOfWork())
+                {
+                    var saveEventArgs = new SaveEventArgs<IContent>(items);
+                    if (raiseEvents && uow.Events.DispatchCancelable(Saving, this, saveEventArgs, "Saving"))
+                    {
+                        uow.Commit();
+                        return false;
+                    }
+
+                    var repository = RepositoryFactory.CreateContentRepository(uow);
+
+                    var i = 0;
+                    foreach (var content in items)
+                    {
+                        //If the current sort order equals that of the content
+                        //we don't need to update it, so just increment the sort order
+                        //and continue.
+                        if (content.SortOrder == i)
+                        {
+                            i++;
+                            continue;
+                        }
+
+                        content.SortOrder = i;
+                        content.WriterId = userId;
+                        i++;
+
+                        if (content.Published)
+                        {
+                            //TODO: This should not be an inner operation, but if we do this, it cannot raise events and cannot be cancellable!
+                            var published = _publishingStrategy.Publish(uow, content, userId).Success;
+                            shouldBePublished.Add(content);
+                        }
+                        else
+                            shouldBeSaved.Add(content);
+
+                        repository.AddOrUpdate(content);
+                        //add or update a preview
+                        repository.AddOrUpdatePreviewXml(content, c => _entitySerializer.Serialize(this, _dataTypeService, _userService, c));
+                    }
+
+                    foreach (var content in shouldBePublished)
+                    {
+                        //Create and Save ContentXml DTO
+                        repository.AddOrUpdateContentXml(content, c => _entitySerializer.Serialize(this, _dataTypeService, _userService, c));
+                    }
+
+                    if (raiseEvents)
+                    {
+                        saveEventArgs.CanCancel = false;
+                        uow.Events.Dispatch(Saved, this, saveEventArgs, "Saved");
+                    }
+
+                    if (shouldBePublished.Any())
+                    {
+                        //TODO: This should not be an inner operation, but if we do this, it cannot raise events and cannot be cancellable!
+                        _publishingStrategy.PublishingFinalized(uow, shouldBePublished, false);
+                    }
+
+                    Audit(uow, AuditType.Sort, "Sort child items performed by user", userId, items.First().ParentId);
+                    uow.Commit();
+                }
+            }
+
+            return true;
+        }
+
+        public IEnumerable<IContent> GetBlueprintsForContentTypes(params int[] documentTypeIds)
+        {
+            using (var uow = UowProvider.GetUnitOfWork(readOnly: true))
+            {
+                var repository = RepositoryFactory.CreateContentBlueprintRepository(uow);
+
+                var query = new Query<IContent>();
+                if (documentTypeIds.Length > 0)
+                {
+                    query.Where(x => documentTypeIds.Contains(x.ContentTypeId));
+                }
+                return repository.GetByQuery(query).Select(x =>
+                {
+                    ((Content) x).IsBlueprint = true;
+                    return x;
+                });
+            }
+        }
+
+        /// <summary>
+        /// Gets paged content descendants as XML by path
+        /// </summary>
+        /// <param name="path">Path starts with</param>
+        /// <param name="pageIndex">Page number</param>
+        /// <param name="pageSize">Page size</param>
+        /// <param name="totalRecords">Total records the query would return without paging</param>
+        /// <returns>A paged enumerable of XML entries of content items</returns>
+        public IEnumerable<XElement> GetPagedXmlEntries(string path, long pageIndex, int pageSize, out long totalRecords)
+        {
+            Mandate.ParameterCondition(pageIndex >= 0, "pageIndex");
+            Mandate.ParameterCondition(pageSize > 0, "pageSize");
+
+            using (var uow = UowProvider.GetUnitOfWork(readOnly: true))
+            {
+                var repository = RepositoryFactory.CreateContentRepository(uow);
+                var contents = repository.GetPagedXmlEntriesByPath(path, pageIndex, pageSize,
+                    //This order by is VERY important! This allows us to figure out what is implicitly not published, see ContentRepository.BuildXmlCache and
+                    // UmbracoContentIndexer.PerformIndexAll which uses the logic based on this sort order
+                    new[] { "level", "parentID", "sortOrder" },
+                    out totalRecords);
+                return contents;
+            }
+        }
+
+        /// <summary>
+        /// This builds the Xml document used for the XML cache
+        /// </summary>
+        /// <returns></returns>
+        public XmlDocument BuildXmlCache()
+        {
+            using (var uow = UowProvider.GetUnitOfWork())
+            {
+                var repository = RepositoryFactory.CreateContentRepository(uow);
+                var result = repository.BuildXmlCache();
+                uow.Commit();
+                return result;
+            }
+        }
+
+        public XmlDocument BuildPreviewXmlCache()
+        {
+            using (var uow = UowProvider.GetUnitOfWork())
+            {
+                var repository = RepositoryFactory.CreateContentRepository(uow);
+                var result = repository.BuildPreviewXmlCache();
+                uow.Commit();
+                return result;
+            }
+        }
+
+        /// <summary>
+        /// Rebuilds all xml content in the cmsContentXml table for all documents
+        /// </summary>
+        /// <param name="contentTypeIds">
+        /// Only rebuild the xml structures for the content type ids passed in, if none then rebuilds the structures
+        /// for all content
+        /// </param>
+        public void RebuildXmlStructures(params int[] contentTypeIds)
+        {
+            using (var uow = UowProvider.GetUnitOfWork())
+            {
+                var repository = RepositoryFactory.CreateContentRepository(uow);
+
+                repository.RebuildXmlStructures(
+                    content => _entitySerializer.Serialize(this, _dataTypeService, _userService, content),
+                    contentTypeIds: contentTypeIds.Length == 0 ? null : contentTypeIds);
+
+                Audit(uow, AuditType.Publish, "ContentService.RebuildXmlStructures completed, the xml has been regenerated in the database", 0, Constants.System.Root);
+                uow.Commit();
+            }
+        }
+
+        #region Internal Methods
+
+        /// <summary>
+        /// Gets a collection of <see cref="IContent"/> descendants by the first Parent.
+        /// </summary>
+        /// <param name="content"><see cref="IContent"/> item to retrieve Descendants from</param>
+        /// <returns>An Enumerable list of <see cref="IContent"/> objects</returns>
+        internal IEnumerable<IContent> GetPublishedDescendants(IContent content)
+        {
+            using (var uow = UowProvider.GetUnitOfWork(readOnly: true))
+            {
+                var repository = RepositoryFactory.CreateContentRepository(uow);
+
+                var query = Query<IContent>.Builder.Where(x => x.Id != content.Id && x.Path.StartsWith(content.Path) && x.Trashed == false);
+                return repository.GetByPublishedVersion(query);
+            }
+        }
+
+        #endregion
+
+        #region Private Methods
+
+        /// <summary>
+        /// Hack: This is used to fix some data if an entity's properties are invalid/corrupt
+        /// </summary>
+        /// <param name="content"></param>
+        private void QuickUpdate(IContent content)
+        {
+            if (content == null) throw new ArgumentNullException("content");
+            if (content.HasIdentity == false) throw new InvalidOperationException("Cannot update an entity without an Identity");
+
+            using (var uow = UowProvider.GetUnitOfWork())
+            {
+                var repository = RepositoryFactory.CreateContentRepository(uow);
+                repository.AddOrUpdate(content);
+                uow.Commit();
+            }
+        }
+
+        private void Audit(IScopeUnitOfWork uow, AuditType type, string message, int userId, int objectId)
+        {
+            var auditRepo = RepositoryFactory.CreateAuditRepository(uow);
+            auditRepo.AddOrUpdate(new AuditItem(objectId, message, type, userId));
+        }
+
+        //TODO: All of this needs to be moved to the repository
+        private void PerformMove(IContent content, int parentId, int userId, ICollection<MoveEventInfo<IContent>> moveInfo)
+        {
+            //add a tracking item to use in the Moved event
+            moveInfo.Add(new MoveEventInfo<IContent>(content, content.Path, parentId));
+
+            content.WriterId = userId;
+            if (parentId == Constants.System.Root)
+            {
+                content.Path = string.Concat(Constants.System.Root, ",", content.Id);
+                content.Level = 1;
+            }
+            else
+            {
+                var parent = GetById(parentId);
+                content.Path = string.Concat(parent.Path, ",", content.Id);
+                content.Level = parent.Level + 1;
+            }
+
+            //If Content is being moved away from Recycle Bin, its state should be un-trashed
+            if (content.Trashed && parentId != Constants.System.RecycleBinContent)
+            {
+                content.ChangeTrashedState(false, parentId);
+            }
+            else
+            {
+                content.ParentId = parentId;
+            }
+
+            //If Content is published, it should be (re)published from its new location
+            if (content.Published)
+            {
+                //If Content is Publishable its saved and published
+                //otherwise we save the content without changing the publish state, and generate new xml because the Path, Level and Parent has changed.
+                if (IsPublishable(content))
+                {
+                    //TODO: This is raising events, probably not desirable as this costs performance for event listeners like Examine
+                    SaveAndPublish(content, userId);
+                }
+                else
+                {
+                    //TODO: This is raising events, probably not desirable as this costs performance for event listeners like Examine
+                    Save(content, false, userId);
+
+                    //TODO: This shouldn't be here! This needs to be part of the repository logic but in order to fix this we need to
+                    // change how this method calls "Save" as it needs to save using an internal method
+                    using (var uow = UowProvider.GetUnitOfWork())
+                    {
+                        var xml = _entitySerializer.Serialize(this, _dataTypeService, _userService, content);
+
+                        var poco = new ContentXmlDto { NodeId = content.Id, Xml = xml.ToDataString() };
+                        var exists =
+                            uow.Database.FirstOrDefault<ContentXmlDto>("WHERE nodeId = @Id", new { Id = content.Id }) !=
+                            null;
+                        int result = exists
+                                         ? uow.Database.Update(poco)
+                                         : Convert.ToInt32(uow.Database.Insert(poco));
+                        uow.Commit();
+                    }
+                }
+            }
+            else
+            {
+                //TODO: This is raising events, probably not desirable as this costs performance for event listeners like Examine
+                Save(content, userId);
+            }
+
+            //Ensure that Path and Level is updated on children
+            var children = GetChildren(content.Id).ToArray();
+            if (children.Any())
+            {
+                foreach (var child in children)
+                {
+                    PerformMove(child, content.Id, userId, moveInfo);
+                }
+            }
+        }
+
+        /// <summary>
+        /// Publishes a <see cref="IContent"/> object and all its children
+        /// </summary>
+        /// <param name="content">The <see cref="IContent"/> to publish along with its children</param>
+        /// <param name="userId">Optional Id of the User issueing the publishing</param>
+        /// <param name="includeUnpublished">If set to true, this will also publish descendants that are completely unpublished, normally this will only publish children that have previously been published</param>
+        /// <returns>
+        /// A list of publish statues. If the parent document is not valid or cannot be published because it's parent(s) is not published
+        /// then the list will only contain one status item, otherwise it will contain status items for it and all of it's descendants that
+        /// are to be published.
+        /// </returns>
+        private IEnumerable<Attempt<PublishStatus>> PublishWithChildrenDo(
+            IContent content, int userId = 0, bool includeUnpublished = false)
+        {
+            if (content == null) throw new ArgumentNullException("content");
+
+            var evtMsgs = EventMessagesFactory.Get();
+
+            using (new WriteLock(Locker))
+            {
+                //Hack: this ensures that the entity's path is valid and if not it fixes/persists it
+                //see: http://issues.umbraco.org/issue/U4-9336
+                content.EnsureValidPath(Logger, entity => GetById(entity.ParentId), QuickUpdate);
+
+                var result = new List<Attempt<PublishStatus>>();
+
+                //Check if parent is published (although not if its a root node) - if parent isn't published this Content cannot be published
+                if (content.ParentId != Constants.System.Root && content.ParentId != Constants.System.RecycleBinContent && IsPublishable(content) == false)
+                {
+                    Logger.Info<ContentService>(
+                        string.Format(
+                            "Content '{0}' with Id '{1}' could not be published because its parent or one of its ancestors is not published.",
+                            content.Name, content.Id));
+                    result.Add(Attempt.Fail(new PublishStatus(content, PublishStatusType.FailedPathNotPublished, evtMsgs)));
+                    return result;
+                }
+
+                //Content contains invalid property values and can therefore not be published - fire event?
+                if (!content.IsValid())
+                {
+                    Logger.Info<ContentService>(
+                        string.Format("Content '{0}' with Id '{1}' could not be published because of invalid properties.",
+                                      content.Name, content.Id));
+                    result.Add(
+                        Attempt.Fail(
+                            new PublishStatus(content, PublishStatusType.FailedContentInvalid, evtMsgs)
+                            {
+                                InvalidProperties = ((ContentBase)content).LastInvalidProperties
+                            }));
+                    return result;
+                }
+
+                //Consider creating a Path query instead of recursive method:
+                //var query = Query<IContent>.Builder.Where(x => x.Path.StartsWith(content.Path));
+
+                var updated = new List<IContent>();
+                var list = new List<IContent>();
+                list.Add(content); //include parent item
+                list.AddRange(GetDescendants(content));
+
+                var internalStrategy = _publishingStrategy;
+
+                using (var uow = UowProvider.GetUnitOfWork())
+                {
+                    //Publish and then update the database with new status
+                    var publishedOutcome = internalStrategy.PublishWithChildren(uow, list, userId, includeUnpublished).ToArray();
+                    var published = publishedOutcome
+                        .Where(x => x.Success || x.Result.StatusType == PublishStatusType.SuccessAlreadyPublished)
+                        // ensure proper order (for events) - cannot publish a child before its parent!
+                        .OrderBy(x => x.Result.ContentItem.Level)
+                        .ThenBy(x => x.Result.ContentItem.SortOrder);
+
+                    var repository = RepositoryFactory.CreateContentRepository(uow);
+
+                    //NOTE The Publish with subpages-dialog was used more as a republish-type-thing, so we'll have to include PublishStatusType.SuccessAlreadyPublished
+                    //in the updated-list, so the Published event is triggered with the expected set of pages and the xml is updated.
+                    foreach (var item in published)
+                    {
+                        item.Result.ContentItem.WriterId = userId;
+                        repository.AddOrUpdate(item.Result.ContentItem);
+                        //add or update a preview
+                        repository.AddOrUpdatePreviewXml(item.Result.ContentItem, c => _entitySerializer.Serialize(this, _dataTypeService, _userService, c));
+                        //add or update the published xml
+                        repository.AddOrUpdateContentXml(item.Result.ContentItem, c => _entitySerializer.Serialize(this, _dataTypeService, _userService, c));
+                        updated.Add(item.Result.ContentItem);
+                    }
+
+                    //Save xml to db and call following method to fire event:
+                    _publishingStrategy.PublishingFinalized(uow, updated, false);
+
+                    Audit(uow, AuditType.Publish, "Publish with Children performed by user", userId, content.Id);
+                    uow.Commit();
+
+                    return publishedOutcome;
+                }
+            }
+        }
+
+        /// <summary>
+        /// UnPublishes a single <see cref="IContent"/> object
+        /// </summary>
+        /// <param name="content">The <see cref="IContent"/> to publish</param>
+        /// <param name="omitCacheRefresh">Optional boolean to avoid having the cache refreshed when calling this Unpublish method. By default this method will update the cache.</param>
+        /// <param name="userId">Optional Id of the User issueing the publishing</param>
+        /// <returns>True if unpublishing succeeded, otherwise False</returns>
+        private Attempt<UnPublishStatus> UnPublishDo(IContent content, bool omitCacheRefresh = false, int userId = 0)
+        {
+            var newest = GetById(content.Id); // ensure we have the newest version
+            if (content.Version != newest.Version) // but use the original object if it's already the newest version
+                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
+            }
+
+            using (var uow = UowProvider.GetUnitOfWork())
+            {
+                var unpublished = _publishingStrategy.UnPublish(uow, content, userId);
+                if (unpublished == false)
+                {
+                    uow.Commit();
+                    return Attempt.Fail(new UnPublishStatus(content, UnPublishedStatusType.FailedCancelledByEvent, evtMsgs));
+                }
+
+                var repository = RepositoryFactory.CreateContentRepository(uow);
+
+                content.WriterId = userId;
+                repository.AddOrUpdate(content);
+                // is published is not newest, reset the published flag on published version
+                if (published.Version != content.Version)
+                    repository.ClearPublished(published);
+                repository.DeleteContentXml(content);
+
+                //Delete xml from db? and call following method to fire event through PublishingStrategy to update cache
+                if (omitCacheRefresh == false)
+                    _publishingStrategy.UnPublishingFinalized(uow, content);
+
+                Audit(uow, AuditType.UnPublish, "UnPublish performed by user", userId, content.Id);
+                uow.Commit();
+            }
+
+            return Attempt.Succeed(new UnPublishStatus(content, UnPublishedStatusType.Success, evtMsgs));
+        }
+
+        /// <summary>
+        /// Saves and Publishes a single <see cref="IContent"/> object
+        /// </summary>
+        /// <param name="content">The <see cref="IContent"/> to save and publish</param>
+        /// <param name="userId">Optional Id of the User issueing the publishing</param>
+        /// <param name="raiseEvents">Optional boolean indicating whether or not to raise save events.</param>
+        /// <returns>True if publishing succeeded, otherwise False</returns>
+        private Attempt<PublishStatus> SaveAndPublishDo(IContent content, int userId = 0, bool raiseEvents = true)
+        {
+            var evtMsgs = EventMessagesFactory.Get();
+
+            using (new WriteLock(Locker))
+            {
+                using (var uow = UowProvider.GetUnitOfWork())
+                {
+                    var saveEventArgs = new SaveEventArgs<IContent>(content, evtMsgs);
+                    if (raiseEvents && uow.Events.DispatchCancelable(Saving, this, saveEventArgs, "Saving"))
+                    {
+                        uow.Commit();
+                        return Attempt.Fail(new PublishStatus(content, PublishStatusType.FailedCancelledByEvent, evtMsgs));
+                    }
+
+                    //Has this content item previously been published? If so, we don't need to refresh the children
+                    var previouslyPublished = content.HasIdentity && HasPublishedVersion(content.Id); //content might not have an id
+                    var publishStatus = new PublishStatus(content, PublishStatusType.Success, evtMsgs); //initially set to success
+
+                    //Check if parent is published (although not if its a root node) - if parent isn't published this Content cannot be published
+                    publishStatus.StatusType = CheckAndLogIsPublishable(content);
+                    //if it is not successful, then check if the props are valid
+                    if ((int)publishStatus.StatusType < 10)
+                    {
+                        //Content contains invalid property values and can therefore not be published - fire event?
+                        publishStatus.StatusType = CheckAndLogIsValid(content);
+                        //set the invalid properties (if there are any)
+                        publishStatus.InvalidProperties = ((ContentBase)content).LastInvalidProperties;
+                    }
+                    //if we're still successful, then publish using the strategy
+                    if (publishStatus.StatusType == PublishStatusType.Success)
+                    {
+                        //Publish and then update the database with new status
+                        var publishResult = _publishingStrategy.Publish(uow, content, userId);
+                        //set the status type to the publish result
+                        publishStatus.StatusType = publishResult.Result.StatusType;
+                    }
+
+                    //we are successfully published if our publishStatus is still Successful
+                    bool published = publishStatus.StatusType == PublishStatusType.Success;
+
+                    var repository = RepositoryFactory.CreateContentRepository(uow);
+
+                    if (published == false)
+                    {
+                        content.ChangePublishedState(PublishedState.Saved);
+                    }
+                    //Since this is the Save and Publish method, the content should be saved even though the publish fails or isn't allowed
+                    if (content.HasIdentity == false)
+                    {
+                        content.CreatorId = userId;
+                    }
+                    content.WriterId = userId;
+
+                    repository.AddOrUpdate(content);
+                    repository.AddOrUpdatePreviewXml(content, c => _entitySerializer.Serialize(this, _dataTypeService, _userService, c));
+
+                    if (published)
+                    {
+                        //Content Xml
+                        repository.AddOrUpdateContentXml(content, c => _entitySerializer.Serialize(this, _dataTypeService, _userService, c));
+                    }
+
+                    if (raiseEvents)
+                    {
+                        saveEventArgs.CanCancel = false;
+                        uow.Events.Dispatch(Saved, this, saveEventArgs, "Saved");
+                    }
+
+                    //Save xml to db and call following method to fire event through PublishingStrategy to update cache
+                    if (published)
+                    {
+                        _publishingStrategy.PublishingFinalized(uow, content);
+                    }
+
+                    //We need to check if children and their publish state to ensure that we 'republish' content that was previously published
+                    if (published && previouslyPublished == false && HasChildren(content.Id))
+                    {
+                    //TODO: Horrible for performance if there are lots of descendents! We should page if anything but this is crazy
+                        var descendants = GetPublishedDescendants(content);
+                        _publishingStrategy.PublishingFinalized(uow, descendants, false);
+                    }
+
+                    uow.Commit();
+
+                    if (publishStatus.StatusType == PublishStatusType.Success)
+                    {
+                        Audit(uow, AuditType.Publish, "Save and Publish performed by user", userId, content.Id);
+                    }
+                    else
+                    {
+                        Audit(uow, AuditType.Save, "Save performed by user", userId, content.Id);
+                    }
+                    uow.Commit();
+
+                    return Attempt.If(publishStatus.StatusType == PublishStatusType.Success, publishStatus);
+                }
+            }
+        }
+
+        /// <summary>
+        /// Saves a single <see cref="IContent"/> object
+        /// </summary>
+        /// <param name="content">The <see cref="IContent"/> to save</param>
+        /// <param name="changeState">Boolean indicating whether or not to change the Published state upon saving</param>
+        /// <param name="userId">Optional Id of the User saving the Content</param>
+        /// <param name="raiseEvents">Optional boolean indicating whether or not to raise events.</param>
+        private Attempt<OperationStatus> Save(IContent content, bool changeState, int userId = 0, bool raiseEvents = true)
+        {
+            var evtMsgs = EventMessagesFactory.Get();
+
+            using (new WriteLock(Locker))
+            {
+                var currVersion = content.Version;
+
+                using (var uow = UowProvider.GetUnitOfWork())
+                {
+                    var saveEventArgs = new SaveEventArgs<IContent>(content, evtMsgs);
+                    if (raiseEvents && uow.Events.DispatchCancelable(Saving, this, saveEventArgs, "Saving"))
+                    {
+                        uow.Commit();
+                        return OperationStatus.Cancelled(evtMsgs);
+                    }
+
+                    if (string.IsNullOrWhiteSpace(content.Name))
+                    {
+                        throw new ArgumentException("Cannot save content with empty name.");
+                    }
+
+                    var repository = RepositoryFactory.CreateContentRepository(uow);
+
+                    if (content.HasIdentity == false)
+                    {
+                        content.CreatorId = userId;
+                    }
+                    content.WriterId = userId;
+
+                    //Only change the publish state if the "previous" version was actually published or marked as unpublished
+                    if (changeState && (content.Published || ((Content)content).PublishedState == PublishedState.Unpublished))
+                        content.ChangePublishedState(PublishedState.Saved);
+
+                    repository.AddOrUpdate(content);
+
+                    //Generate a new preview
+                    repository.AddOrUpdatePreviewXml(content, c => _entitySerializer.Serialize(this, _dataTypeService, _userService, c));
+
+                    if (raiseEvents)
+                    {
+                        saveEventArgs.CanCancel = false;
+                        uow.Events.Dispatch(Saved, this, saveEventArgs, "Saved");
+                    }
+
+                    Audit(uow, AuditType.Save, "Save Content performed by user", userId, content.Id);
+                    uow.Commit();
+                }
+
+                return currVersion == content.Version
+                    ? OperationStatus.NoOperation(evtMsgs)
+                    : OperationStatus.Success(evtMsgs);
+            }
+        }
+
+        private PublishStatusType CheckAndLogIsPublishable(IContent content)
+        {
+            //Check if parent is published (although not if its a root node) - if parent isn't published this Content cannot be published
+            if (content.ParentId != Constants.System.Root && content.ParentId != Constants.System.RecycleBinContent && IsPublishable(content) == false)
+            {
+                Logger.Info<ContentService>(
+                    string.Format(
+                        "Content '{0}' with Id '{1}' could not be published because its parent is not published.",
+                        content.Name, content.Id));
+                return PublishStatusType.FailedPathNotPublished;
+            }
+
+            if (content.ExpireDate.HasValue && content.ExpireDate.Value > DateTime.MinValue && DateTime.Now > content.ExpireDate.Value)
+            {
+                Logger.Info<ContentService>(
+                    string.Format(
+                        "Content '{0}' with Id '{1}' has expired and could not be published.",
+                        content.Name, content.Id));
+                return PublishStatusType.FailedHasExpired;
+            }
+
+            if (content.ReleaseDate.HasValue && content.ReleaseDate.Value > DateTime.MinValue && content.ReleaseDate.Value > DateTime.Now)
+            {
+                Logger.Info<ContentService>(
+                    string.Format(
+                        "Content '{0}' with Id '{1}' is awaiting release and could not be published.",
+                        content.Name, content.Id));
+                return PublishStatusType.FailedAwaitingRelease;
+            }
+
+            return PublishStatusType.Success;
+        }
+
+        private PublishStatusType CheckAndLogIsValid(IContent content)
+        {
+            //Content contains invalid property values and can therefore not be published - fire event?
+            if (content.IsValid() == false)
+            {
+                Logger.Info<ContentService>(
+                    string.Format(
+                        "Content '{0}' with Id '{1}' could not be published because of invalid properties.",
+                        content.Name, content.Id));
+                return PublishStatusType.FailedContentInvalid;
+            }
+
+            return PublishStatusType.Success;
+        }
+
+        private IContentType FindContentTypeByAlias(string contentTypeAlias)
+        {
+            using (var uow = UowProvider.GetUnitOfWork(readOnly: true))
+            {
+                var repository = RepositoryFactory.CreateContentTypeRepository(uow);
+
+                var query = Query<IContentType>.Builder.Where(x => x.Alias == contentTypeAlias);
+                var types = repository.GetByQuery(query);
+
+                if (types.Any() == false)
+                    throw new Exception(
+                        string.Format("No ContentType matching the passed in Alias: '{0}' was found",
+                                      contentTypeAlias));
+
+                var contentType = types.First();
+
+                if (contentType == null)
+                    throw new Exception(string.Format("ContentType matching the passed in Alias: '{0}' was null",
+                                                      contentTypeAlias));
+                return contentType;
+            }
+        }
+
+        #endregion
+
+        #region Proxy Event Handlers
+        /// <summary>
+        /// Occurs before publish.
+        /// </summary>
+        /// <remarks>Proxy to the real event on the <see cref="PublishingStrategy"/></remarks>
+        public static event TypedEventHandler<IPublishingStrategy, PublishEventArgs<IContent>> Publishing
+        {
+            add { PublishingStrategy.Publishing += value; }
+            remove { PublishingStrategy.Publishing -= value; }
+        }
+
+        /// <summary>
+        /// Occurs after publish.
+        /// </summary>
+        /// <remarks>Proxy to the real event on the <see cref="PublishingStrategy"/></remarks>
+        public static event TypedEventHandler<IPublishingStrategy, PublishEventArgs<IContent>> Published
+        {
+            add { PublishingStrategy.Published += value; }
+            remove { PublishingStrategy.Published -= value; }
+        }
+        /// <summary>
+        /// Occurs before unpublish.
+        /// </summary>
+        /// <remarks>Proxy to the real event on the <see cref="PublishingStrategy"/></remarks>
+        public static event TypedEventHandler<IPublishingStrategy, PublishEventArgs<IContent>> UnPublishing
+        {
+            add { PublishingStrategy.UnPublishing += value; }
+            remove { PublishingStrategy.UnPublishing -= value; }
+        }
+
+        /// <summary>
+        /// Occurs after unpublish.
+        /// </summary>
+        /// <remarks>Proxy to the real event on the <see cref="PublishingStrategy"/></remarks>
+        public static event TypedEventHandler<IPublishingStrategy, PublishEventArgs<IContent>> UnPublished
+        {
+            add { PublishingStrategy.UnPublished += value; }
+            remove { PublishingStrategy.UnPublished -= value; }
+        }
+        #endregion
+
+        #region Event Handlers
+        /// <summary>
+        /// Occurs before Delete
+        /// </summary>
+        public static event TypedEventHandler<IContentService, DeleteEventArgs<IContent>> Deleting;
+
+        /// <summary>
+        /// Occurs after Delete
+        /// </summary>
+        public static event TypedEventHandler<IContentService, DeleteEventArgs<IContent>> Deleted;
+
+        /// <summary>
+        /// Occurs before Delete Versions
+        /// </summary>
+        public static event TypedEventHandler<IContentService, DeleteRevisionsEventArgs> DeletingVersions;
+
+        /// <summary>
+        /// Occurs after Delete Versions
+        /// </summary>
+        public static event TypedEventHandler<IContentService, DeleteRevisionsEventArgs> DeletedVersions;
+
+        /// <summary>
+        /// Occurs before Save
+        /// </summary>
+        public static event TypedEventHandler<IContentService, SaveEventArgs<IContent>> Saving;
+
+        /// <summary>
+        /// Occurs after Save
+        /// </summary>
+        public static event TypedEventHandler<IContentService, SaveEventArgs<IContent>> Saved;
+
+        /// <summary>
+        /// Occurs before Create
+        /// </summary>
+        [Obsolete("Use the Created event instead, the Creating and Created events both offer the same functionality, Creating event has been deprecated.")]
+        public static event TypedEventHandler<IContentService, NewEventArgs<IContent>> Creating;
+
+        /// <summary>
+        /// Occurs after Create
+        /// </summary>
+        /// <remarks>
+        /// Please note that the Content object has been created, but might not have been saved
+        /// so it does not have an identity yet (meaning no Id has been set).
+        /// </remarks>
+        public static event TypedEventHandler<IContentService, NewEventArgs<IContent>> Created;
+
+        /// <summary>
+        /// Occurs before Copy
+        /// </summary>
+        public static event TypedEventHandler<IContentService, CopyEventArgs<IContent>> Copying;
+
+        /// <summary>
+        /// Occurs after Copy
+        /// </summary>
+        public static event TypedEventHandler<IContentService, CopyEventArgs<IContent>> Copied;
+
+        /// <summary>
+        /// Occurs before Content is moved to Recycle Bin
+        /// </summary>
+        public static event TypedEventHandler<IContentService, MoveEventArgs<IContent>> Trashing;
+
+        /// <summary>
+        /// Occurs after Content is moved to Recycle Bin
+        /// </summary>
+        public static event TypedEventHandler<IContentService, MoveEventArgs<IContent>> Trashed;
+
+        /// <summary>
+        /// Occurs before Move
+        /// </summary>
+        public static event TypedEventHandler<IContentService, MoveEventArgs<IContent>> Moving;
+
+        /// <summary>
+        /// Occurs after Move
+        /// </summary>
+        public static event TypedEventHandler<IContentService, MoveEventArgs<IContent>> Moved;
+
+        /// <summary>
+        /// Occurs before Rollback
+        /// </summary>
+        public static event TypedEventHandler<IContentService, RollbackEventArgs<IContent>> RollingBack;
+
+        /// <summary>
+        /// Occurs after Rollback
+        /// </summary>
+        public static event TypedEventHandler<IContentService, RollbackEventArgs<IContent>> RolledBack;
+
+        /// <summary>
+        /// Occurs before Send to Publish
+        /// </summary>
+        public static event TypedEventHandler<IContentService, SendToPublishEventArgs<IContent>> SendingToPublish;
+
+        /// <summary>
+        /// Occurs after Send to Publish
+        /// </summary>
+        public static event TypedEventHandler<IContentService, SendToPublishEventArgs<IContent>> SentToPublish;
+
+        /// <summary>
+        /// Occurs before the Recycle Bin is emptied
+        /// </summary>
+        public static event TypedEventHandler<IContentService, RecycleBinEventArgs> EmptyingRecycleBin;
+
+        /// <summary>
+        /// Occurs after the Recycle Bin has been Emptied
+        /// </summary>
+        public static event TypedEventHandler<IContentService, RecycleBinEventArgs> EmptiedRecycleBin;
+
+        /// <summary>
+        /// Occurs after a blueprint has been saved.
+        /// </summary>
+        public static event TypedEventHandler<IContentService, SaveEventArgs<IContent>> SavedBlueprint;
+
+        /// <summary>
+        /// Occurs after a blueprint has been deleted.
+        /// </summary>
+        public static event TypedEventHandler<IContentService, DeleteEventArgs<IContent>> DeletedBlueprint;
+
+        #endregion
+    }
+}
diff --git a/src/Umbraco.Web/Editors/ContentController.cs b/src/Umbraco.Web/Editors/ContentController.cs
index 1ac8318f9c..8bb7af0077 100644
--- a/src/Umbraco.Web/Editors/ContentController.cs
+++ b/src/Umbraco.Web/Editors/ContentController.cs
@@ -1,1219 +1,1223 @@
-using System;
-using System.Collections.Generic;
-using System.Globalization;
-using System.IO;
-using System.Linq;
-using System.Net;
-using System.Net.Http;
-using System.Text;
-using System.Web.Http;
-using System.Web.Http.Controllers;
-using System.Web.Http.ModelBinding;
-using AutoMapper;
-using Umbraco.Core;
-using Umbraco.Core.Logging;
-using Umbraco.Core.Models;
-using Umbraco.Core.Models.Membership;
-using Umbraco.Core.Persistence.DatabaseModelDefinitions;
-using Umbraco.Core.Publishing;
-using Umbraco.Core.Services;
-using Umbraco.Web.Models.ContentEditing;
-using Umbraco.Web.Models.Mapping;
-using Umbraco.Web.Mvc;
-using Umbraco.Web.WebApi;
-using Umbraco.Web.WebApi.Binders;
-using Umbraco.Web.WebApi.Filters;
-using Umbraco.Core.Events;
-using Constants = Umbraco.Core.Constants;
-using umbraco.cms.businesslogic;
-using System.Collections;
-using umbraco;
-
-namespace Umbraco.Web.Editors
-{
-    /// <summary>
-    /// The API controller used for editing content
-    /// </summary>
-    /// <remarks>
-    /// This controller is decorated with the UmbracoApplicationAuthorizeAttribute which means that any user requesting
-    /// access to ALL of the methods on this controller will need access to the content application.
-    /// </remarks>
-    [PluginController("UmbracoApi")]
-    [UmbracoApplicationAuthorize(Constants.Applications.Content)]
-    [ContentControllerConfiguration]
-    public class ContentController : ContentControllerBase
-    {
-        /// <summary>
-        /// Constructor
-        /// </summary>
-        public ContentController()
-                : this(UmbracoContext.Current)
-        {
-        }
-
-        /// <summary>
-        /// Constructor
-        /// </summary>
-        /// <param name="umbracoContext"></param>
-        public ContentController(UmbracoContext umbracoContext)
-                : base(umbracoContext)
-        {
-        }
-
-        /// <summary>
-        /// Configures this controller with a custom action selector
-        /// </summary>
-        private class ContentControllerConfigurationAttribute : Attribute, IControllerConfiguration
-        {
-            public void Initialize(HttpControllerSettings controllerSettings, HttpControllerDescriptor controllerDescriptor)
-            {
-                controllerSettings.Services.Replace(typeof(IHttpActionSelector), new ParameterSwapControllerActionSelector(
-                    new ParameterSwapControllerActionSelector.ParameterSwapInfo("GetNiceUrl", "id", typeof(int), typeof(Guid), typeof(Udi)),
-                    new ParameterSwapControllerActionSelector.ParameterSwapInfo("GetById", "id", typeof(int), typeof(Guid), typeof(Udi))
-                ));
-            }
-        }
-
-        /// <summary>
-        /// Return content for the specified ids
-        /// </summary>
-        /// <param name="ids"></param>
-        /// <returns></returns>
-        [FilterAllowedOutgoingContent(typeof(IEnumerable<ContentItemDisplay>))]
-        public IEnumerable<ContentItemDisplay> GetByIds([FromUri]int[] ids)
-        {
-            var foundContent = Services.ContentService.GetByIds(ids);
-            return foundContent.Select(content => AutoMapperExtensions.MapWithUmbracoContext<IContent, ContentItemDisplay>(content, UmbracoContext));
-        }
-
-        /// <summary>
-        /// Updates the permissions for a content item for a particular user group
-        /// </summary>
-        /// <param name="saveModel"></param>
-        /// <returns></returns>
-        /// <remarks>
-        /// Permission check is done for letter 'R' which is for <see cref="ActionRights"/> which the user must have access to to update
-        /// </remarks>
-        [EnsureUserPermissionForContent("saveModel.ContentId", 'R')]
-        public IEnumerable<AssignedUserGroupPermissions> PostSaveUserGroupPermissions(UserGroupPermissionsSave saveModel)
-        {
-            if (saveModel.ContentId <= 0) throw new HttpResponseException(Request.CreateResponse(HttpStatusCode.NotFound));
-
-            //TODO: Should non-admins be alowed to set granular permissions?
-
-            var content = Services.ContentService.GetById(saveModel.ContentId);
-            if (content == null) throw new HttpResponseException(Request.CreateResponse(HttpStatusCode.NotFound));
-
-            //current permissions explicitly assigned to this content item
-            var contentPermissions = Services.ContentService.GetPermissionsForEntity(content)
-                .ToDictionary(x => x.UserGroupId, x => x);
-
-            var allUserGroups = Services.UserService.GetAllUserGroups().ToArray();
-
-            //loop through each user group
-            foreach (var userGroup in allUserGroups)
-            {
-                //check if there's a permission set posted up for this user group
-                IEnumerable<string> groupPermissions;
-                if (saveModel.AssignedPermissions.TryGetValue(userGroup.Id, out groupPermissions))
-                {
-                    //create a string collection of the assigned letters
-                    var groupPermissionCodes = groupPermissions.ToArray();
-
-                    //check if there are no permissions assigned for this group save model, if that is the case we want to reset the permissions
-                    //for this group/node which will go back to the defaults
-                    if (groupPermissionCodes.Length == 0)
-                    {
-                        Services.UserService.RemoveUserGroupPermissions(userGroup.Id, content.Id);
-                    }
-                    //check if they are the defaults, if so we should just remove them if they exist since it's more overhead having them stored
-                    else if (userGroup.Permissions.UnsortedSequenceEqual(groupPermissionCodes))
-                    {
-                        //only remove them if they are actually currently assigned
-                        if (contentPermissions.ContainsKey(userGroup.Id))
-                        {
-                            //remove these permissions from this node for this group since the ones being assigned are the same as the defaults
-                            Services.UserService.RemoveUserGroupPermissions(userGroup.Id, content.Id);
-                        }
-                    }
-                    //if they are different we need to update, otherwise there's nothing to update
-                    else if (contentPermissions.ContainsKey(userGroup.Id) == false || contentPermissions[userGroup.Id].AssignedPermissions.UnsortedSequenceEqual(groupPermissionCodes) == false)
-                    {
-
-                        Services.UserService.ReplaceUserGroupPermissions(userGroup.Id, groupPermissionCodes.Select(x => x[0]), content.Id);
-                    }
-                }
-            }
-
-            return GetDetailedPermissions(content, allUserGroups);
-        }
-
-        /// <summary>
-        /// Returns the user group permissions for user groups assigned to this node
-        /// </summary>
-        /// <param name="contentId"></param>
-        /// <returns></returns>
-        /// <remarks>
-        /// Permission check is done for letter 'R' which is for <see cref="ActionRights"/> which the user must have access to to view
-        /// </remarks>
-        [EnsureUserPermissionForContent("contentId", 'R')]
-        public IEnumerable<AssignedUserGroupPermissions> GetDetailedPermissions(int contentId)
-        {
-            if (contentId <= 0) throw new HttpResponseException(Request.CreateResponse(HttpStatusCode.NotFound));
-            var content = Services.ContentService.GetById(contentId);
-            if (content == null) throw new HttpResponseException(Request.CreateResponse(HttpStatusCode.NotFound));
-
-            //TODO: Should non-admins be able to see detailed permissions?
-
-            var allUserGroups = Services.UserService.GetAllUserGroups();
-
-            return GetDetailedPermissions(content, allUserGroups);
-        }
-
-        private IEnumerable<AssignedUserGroupPermissions> GetDetailedPermissions(IContent content, IEnumerable<IUserGroup> allUserGroups)
-        {
-            //get all user groups and map their default permissions to the AssignedUserGroupPermissions model.
-            //we do this because not all groups will have true assigned permissions for this node so if they don't have assigned permissions, we need to show the defaults.
-
-            var defaultPermissionsByGroup = Mapper.Map<IEnumerable<AssignedUserGroupPermissions>>(allUserGroups).ToArray();
-
-            var defaultPermissionsAsDictionary = defaultPermissionsByGroup
-                .ToDictionary(x => Convert.ToInt32(x.Id), x => x);
-
-            //get the actual assigned permissions
-            var assignedPermissionsByGroup = Services.ContentService.GetPermissionsForEntity(content).ToArray();
-
-            //iterate over assigned and update the defaults with the real values
-            foreach (var assignedGroupPermission in assignedPermissionsByGroup)
-            {
-                var defaultUserGroupPermissions = defaultPermissionsAsDictionary[assignedGroupPermission.UserGroupId];
-
-                //clone the default permissions model to the assigned ones
-                defaultUserGroupPermissions.AssignedPermissions = AssignedUserGroupPermissions.ClonePermissions(defaultUserGroupPermissions.DefaultPermissions);
-
-                //since there is custom permissions assigned to this node for this group, we need to clear all of the default permissions
-                //and we'll re-check it if it's one of the explicitly assigned ones
-                foreach (var permission in defaultUserGroupPermissions.AssignedPermissions.SelectMany(x => x.Value))
-                {
-                    permission.Checked = false;
-                    permission.Checked = assignedGroupPermission.AssignedPermissions.Contains(permission.PermissionCode, StringComparer.InvariantCulture);
-                }
-
-            }
-
-            return defaultPermissionsByGroup;
-        }
-
-        /// <summary>
-        /// Returns an item to be used to display the recycle bin for content
-        /// </summary>
-        /// <returns></returns>
-        public ContentItemDisplay GetRecycleBin()
-        {
-            var display = new ContentItemDisplay
-            {
-                Id = Constants.System.RecycleBinContent,
-                Alias = "recycleBin",
-                ParentId = -1,
-                Name = Services.TextService.Localize("general/recycleBin"),
-                ContentTypeAlias = "recycleBin",
-                CreateDate = DateTime.Now,
-                IsContainer = true,
-                Path = "-1," + Constants.System.RecycleBinContent
-            };
-
-            TabsAndPropertiesResolver<IContent>.AddListView(display, "content", Services.DataTypeService, Services.TextService);
-
-            return display;
-        }
-
-        public ContentItemDisplay GetBlueprintById(int id)
-        {
-            var foundContent = Services.ContentService.GetBlueprintById(id);
-            if (foundContent == null)
-            {
-                HandleContentNotFound(id);
-            }
-
-            var content = AutoMapperExtensions.MapWithUmbracoContext<IContent, ContentItemDisplay>(foundContent, UmbracoContext);
-
-            SetupBlueprint(content, foundContent);
-
-            return content;
-        }
-
-        private static void SetupBlueprint(ContentItemDisplay content, IContent persistedContent)
-        {
-            content.AllowPreview = false;
-
-            //set a custom path since the tree that renders this has the content type id as the parent
-            content.Path = string.Format("-1,{0},{1}", persistedContent.ContentTypeId, content.Id);
-
-            content.AllowedActions = new[] { "A" };
-            content.IsBlueprint = true;
-
-            var excludeProps = new[] { "_umb_urls", "_umb_releasedate", "_umb_expiredate", "_umb_template" };
-            var propsTab = content.Tabs.Last();
-            propsTab.Properties = propsTab.Properties
-                .Where(p => excludeProps.Contains(p.Alias) == false);
-        }
-
-        /// <summary>
-        /// Gets the content json for the content id
-        /// </summary>
-        /// <param name="id"></param>
-        /// <returns></returns>
-        [OutgoingEditorModelEvent]
-        [EnsureUserPermissionForContent("id")]
-        public ContentItemDisplay GetById(int id)
-        {
-            var foundContent = GetObjectFromRequest(() => Services.ContentService.GetById(id));
-            if (foundContent == null)
-            {
-                HandleContentNotFound(id);
-            }
-
-            var content = AutoMapperExtensions.MapWithUmbracoContext<IContent, ContentItemDisplay>(foundContent, UmbracoContext);
-            return content;
-        }
-
-        /// <summary>
-        /// Gets the content json for the content id
-        /// </summary>
-        /// <param name="id"></param>
-        /// <returns></returns>
-        [OutgoingEditorModelEvent]
-        [EnsureUserPermissionForContent("id")]
-        public ContentItemDisplay GetById(Guid id)
-        {
-            var foundContent = GetObjectFromRequest(() => Services.ContentService.GetById(id));
-            if (foundContent == null)
-            {
-                HandleContentNotFound(id);
-            }
-
-            var content = AutoMapperExtensions.MapWithUmbracoContext<IContent, ContentItemDisplay>(foundContent, UmbracoContext);
-            return content;
-        }
-
-        /// <summary>
-        /// Gets the content json for the content id
-        /// </summary>
-        /// <param name="id"></param>
-        /// <returns></returns>
-        [OutgoingEditorModelEvent]
-        [EnsureUserPermissionForContent("id")]
-        public ContentItemDisplay GetById(Udi id)
-        {
-            var guidUdi = id as GuidUdi;
-            if (guidUdi != null)
-            {
-                return GetById(guidUdi.Guid);
-            }
-
-            throw new HttpResponseException(HttpStatusCode.NotFound);
-        }
-
-        [EnsureUserPermissionForContent("id")]
-        public ContentItemDisplay GetWithTreeDefinition(int id)
-        {
-            var foundContent = GetObjectFromRequest(() => Services.ContentService.GetById(id));
-            if (foundContent == null)
-            {
-                HandleContentNotFound(id);
-            }
-
-            var content = AutoMapperExtensions.MapWithUmbracoContext<IContent, ContentItemDisplay>(foundContent, UmbracoContext);
-            return content;
-        }
-
-        /// <summary>
-        /// Gets an empty content item for the
-        /// </summary>
-        /// <param name="contentTypeAlias"></param>
-        /// <param name="parentId"></param>
-        /// <returns>
-        /// If this is a container type, we'll remove the umbContainerView tab for a new item since
-        /// it cannot actually list children if it doesn't exist yet.
-        /// </returns>
-        [OutgoingEditorModelEvent]
-        public ContentItemDisplay GetEmpty(string contentTypeAlias, int parentId)
-        {
-            var contentType = Services.ContentTypeService.GetContentType(contentTypeAlias);
-            if (contentType == null)
-            {
-                throw new HttpResponseException(HttpStatusCode.NotFound);
-            }
-
-            var emptyContent = Services.ContentService.CreateContent("", parentId, contentType.Alias, UmbracoUser.Id);
-            var mapped = AutoMapperExtensions.MapWithUmbracoContext<IContent, ContentItemDisplay>(emptyContent, UmbracoContext);
-            // translate the content type name if applicable
-            mapped.ContentTypeName = Services.TextService.UmbracoDictionaryTranslate(mapped.ContentTypeName);
-            // if your user type doesn't have access to the Settings section it would not get this property mapped
-            if(mapped.DocumentType != null)
-                mapped.DocumentType.Name = Services.TextService.UmbracoDictionaryTranslate(mapped.DocumentType.Name);
-
-            //remove this tab if it exists: umbContainerView
-            var containerTab = mapped.Tabs.FirstOrDefault(x => x.Alias == Constants.Conventions.PropertyGroups.ListViewGroupName);
-            mapped.Tabs = mapped.Tabs.Except(new[] { containerTab });
-            return mapped;
-        }
-
-        [OutgoingEditorModelEvent]
-        public ContentItemDisplay GetEmpty(int blueprintId, int parentId)
-        {
-            var blueprint = Services.ContentService.GetBlueprintById(blueprintId);
-            if (blueprint == null)
-            {
-                throw new HttpResponseException(HttpStatusCode.NotFound);
-            }
-
-            blueprint.Id = 0;
-            blueprint.Name = string.Empty;
-            blueprint.ParentId = parentId;
-
-            var mapped = Mapper.Map<ContentItemDisplay>(blueprint);
-
-            //remove this tab if it exists: umbContainerView
-            var containerTab = mapped.Tabs.FirstOrDefault(x => x.Alias == Constants.Conventions.PropertyGroups.ListViewGroupName);
-            mapped.Tabs = mapped.Tabs.Except(new[] { containerTab });
-            return mapped;
-        }
-
-        /// <summary>
-        /// Gets the Url for a given node ID
-        /// </summary>
-        /// <param name="id"></param>
-        /// <returns></returns>
-        public HttpResponseMessage GetNiceUrl(int id)
-        {
-            var url = Umbraco.NiceUrl(id);
-            var response = Request.CreateResponse(HttpStatusCode.OK);
-            response.Content = new StringContent(url, Encoding.UTF8, "application/json");
-            return response;
-        }
-
-        /// <summary>
-        /// Gets the Url for a given node ID
-        /// </summary>
-        /// <param name="id"></param>
-        /// <returns></returns>
-        public HttpResponseMessage GetNiceUrl(Guid id)
-        {
-            var url = Umbraco.UrlProvider.GetUrl(id);
-            var response = Request.CreateResponse(HttpStatusCode.OK);
-            response.Content = new StringContent(url, Encoding.UTF8, "application/json");
-            return response;
-        }
-
-        /// <summary>
-        /// Gets the Url for a given node ID
-        /// </summary>
-        /// <param name="id"></param>
-        /// <returns></returns>
-        public HttpResponseMessage GetNiceUrl(Udi id)
-        {
-            var guidUdi = id as GuidUdi;
-            if (guidUdi != null)
-            {
-                return GetNiceUrl(guidUdi.Guid);
-            }
-            throw new HttpResponseException(HttpStatusCode.NotFound);
-        }
-
-        /// <summary>
-        /// Gets the children for the content id passed in
-        /// </summary>
-        /// <returns></returns>
-        [FilterAllowedOutgoingContent(typeof(IEnumerable<ContentItemBasic<ContentPropertyBasic, IContent>>), "Items")]
-        public PagedResult<ContentItemBasic<ContentPropertyBasic, IContent>> GetChildren(
-                int id,
-                int pageNumber = 0,  //TODO: This should be '1' as it's not the index
-                int pageSize = 0,
-                string orderBy = "SortOrder",
-                Direction orderDirection = Direction.Ascending,
-                bool orderBySystemField = true,
-                string filter = "")
-        {
-            return GetChildren(id, null, pageNumber, pageSize, orderBy, orderDirection, orderBySystemField, filter);
-        }
-
-        /// <summary>
-        /// Gets the children for the content id passed in
-        /// </summary>
-        /// <returns></returns>
-        [FilterAllowedOutgoingContent(typeof(IEnumerable<ContentItemBasic<ContentPropertyBasic, IContent>>), "Items")]
-        public PagedResult<ContentItemBasic<ContentPropertyBasic, IContent>> GetChildren(
-                int id,
-                string includeProperties,
-                int pageNumber = 0,  //TODO: This should be '1' as it's not the index
-                int pageSize = 0,
-                string orderBy = "SortOrder",
-                Direction orderDirection = Direction.Ascending,
-                bool orderBySystemField = true,
-                string filter = "")
-        {
-            long totalChildren;
-            IContent[] children;
-            if (pageNumber > 0 && pageSize > 0)
-            {
-                children = Services.ContentService
-                 .GetPagedChildren(id, (pageNumber - 1), pageSize, out totalChildren
-                 , orderBy, orderDirection, orderBySystemField, filter).ToArray();
-            }
-            else
-            {
-                children = Services.ContentService.GetChildren(id).ToArray();
-                totalChildren = children.Length;
-            }
-
-            if (totalChildren == 0)
-            {
-                return new PagedResult<ContentItemBasic<ContentPropertyBasic, IContent>>(0, 0, 0);
-            }
-
-            var pagedResult = new PagedResult<ContentItemBasic<ContentPropertyBasic, IContent>>(totalChildren, pageNumber, pageSize);
-            pagedResult.Items = children.Select(content =>
-                Mapper.Map<IContent, ContentItemBasic<ContentPropertyBasic, IContent>>(content,
-                    opts =>
-                    {
-                        // if there's a list of property aliases to map - we will make sure to store this in the mapping context.
-                        if (String.IsNullOrWhiteSpace(includeProperties) == false)
-                        {
-                            opts.Items["IncludeProperties"] = includeProperties.Split(new[] { ", ", "," }, StringSplitOptions.RemoveEmptyEntries);
-                        }
-                    }));
-
-            return pagedResult;
-        }
-
-        [Obsolete("Dont use this, it is incorrectly named, use HasPermission instead")]
-        public bool GetHasPermission(string permissionToCheck, int nodeId)
-        {
-            return HasPermission(permissionToCheck, nodeId);
-        }
-
-        /// <summary>
-        /// Returns permissions for all nodes passed in for the current user
-        /// TODO: This should be moved to the CurrentUserController?
-        /// </summary>
-        /// <param name="nodeIds"></param>
-        /// <returns></returns>
-        [HttpPost]
-        public Dictionary<int, string[]> GetPermissions(int[] nodeIds)
-        {
-            var permissions = Services.UserService
-                    .GetPermissions(Security.CurrentUser, nodeIds);
-
-            var permissionsDictionary = new Dictionary<int, string[]>();
-            foreach (var nodeId in nodeIds)
-            {
-                var aggregatePerms = permissions.GetAllPermissions(nodeId).ToArray();
-                permissionsDictionary.Add(nodeId, aggregatePerms);
-            }
-
-            return permissionsDictionary;
-        }
-
-        /// <summary>
-        /// Checks a nodes permission for the current user
-        /// TODO: This should be moved to the CurrentUserController?
-        /// </summary>
-        /// <param name="permissionToCheck"></param>
-        /// <param name="nodeId"></param>
-        /// <returns></returns>
-        [HttpGet]
-        public bool HasPermission(string permissionToCheck, int nodeId)
-        {
-            var p = Services.UserService.GetPermissions(Security.CurrentUser, nodeId).GetAllPermissions();
-            if (p.Contains(permissionToCheck.ToString(CultureInfo.InvariantCulture)))
-            {
-                return true;
-            }
-
-            return false;
-        }
-
-        /// <summary>
-        /// Creates a blueprint from a content item
-        /// </summary>
-        /// <param name="contentId">The content id to copy</param>
-        /// <param name="name">The name of the blueprint</param>
-        /// <returns></returns>
-        [HttpPost]
-        public SimpleNotificationModel CreateBlueprintFromContent([FromUri]int contentId, [FromUri]string name)
-        {
-            if (string.IsNullOrWhiteSpace(name)) throw new ArgumentException("Value cannot be null or whitespace.", "name");
-
-            var content = Services.ContentService.GetById(contentId);
-            if (content == null)
-                throw new HttpResponseException(Request.CreateResponse(HttpStatusCode.NotFound));
-
-            EnsureUniqueName(name, content, "name");
-
-            var blueprint = Services.ContentService.CreateContentFromBlueprint(content, name, Security.CurrentUser.Id);
-
-            Services.ContentService.SaveBlueprint(blueprint, Security.CurrentUser.Id);
-
-            var notificationModel = new SimpleNotificationModel();
-            notificationModel.AddSuccessNotification(
-                Services.TextService.Localize("blueprints/createdBlueprintHeading"),
-                Services.TextService.Localize("blueprints/createdBlueprintMessage", new[] { content.Name })
-            );
-
-            return notificationModel;
-        }
-
-        private void EnsureUniqueName(string name, IContent content, string modelName)
-        {
-            var existing = Services.ContentService.GetBlueprintsForContentTypes(content.ContentTypeId);
-            if (existing.Any(x => x.Name == name && x.Id != content.Id))
-            {
-                ModelState.AddModelError(modelName, Services.TextService.Localize("blueprints/duplicateBlueprintMessage"));
-                throw new HttpResponseException(Request.CreateValidationErrorResponse(ModelState));
-            }
-        }
-
-        /// <summary>
-        /// Saves content
-        /// </summary>
-        /// <returns></returns>
-        [FileUploadCleanupFilter]
-        [ContentPostValidate]
-        public ContentItemDisplay PostSaveBlueprint(
-            [ModelBinder(typeof(BlueprintItemBinder))] ContentItemSave contentItem)
-        {
-            var contentItemDisplay = PostSaveInternal(contentItem,
-                content =>
-                {
-                    EnsureUniqueName(content.Name, content, "Name");
-
-                    Services.ContentService.SaveBlueprint(contentItem.PersistedContent, Security.CurrentUser.Id);
-                    //we need to reuse the underlying logic so return the result that it wants
-                    return Attempt<OperationStatus>.Succeed(new OperationStatus(OperationStatusType.Success, new EventMessages()));
-                });
-            SetupBlueprint(contentItemDisplay, contentItemDisplay.PersistedContent);
-
-            return contentItemDisplay;
-        }
-
-        /// <summary>
-        /// Saves content
-        /// </summary>
-        /// <returns></returns>
-        [FileUploadCleanupFilter]
-        [ContentPostValidate]
-        [OutgoingEditorModelEvent]
-        public ContentItemDisplay PostSave(
-                [ModelBinder(typeof(ContentItemBinder))]
-                                ContentItemSave contentItem)
-        {
-            return PostSaveInternal(contentItem,
-                content => Services.ContentService.WithResult().Save(contentItem.PersistedContent, Security.CurrentUser.Id));
-        }
-
-        private ContentItemDisplay PostSaveInternal(ContentItemSave contentItem, Func<IContent, Attempt<OperationStatus>> saveMethod)
-        {
-            //Recent versions of IE/Edge may send in the full clientside file path instead of just the file name.
-            //To ensure similar behavior across all browsers no matter what they do - we strip the FileName property of all
-            //uploaded files to being *only* the actual file name (as it should be).
-            if (contentItem.UploadedFiles != null && contentItem.UploadedFiles.Any())
-            {
-                foreach (var file in contentItem.UploadedFiles)
-                {
-                    file.FileName = Path.GetFileName(file.FileName);
-                }
-            }
-
-            //If we've reached here it means:
-            // * Our model has been bound
-            // * and validated
-            // * any file attachments have been saved to their temporary location for us to use
-            // * we have a reference to the DTO object and the persisted object
-            // * Permissions are valid
-            MapPropertyValues(contentItem);
-
-            //We need to manually check the validation results here because:
-            // * We still need to save the entity even if there are validation value errors
-            // * Depending on if the entity is new, and if there are non property validation errors (i.e. the name is null)
-            //      then we cannot continue saving, we can only display errors
-            // * If there are validation errors and they were attempting to publish, we can only save, NOT publish and display
-            //      a message indicating this
-            if (ModelState.IsValid == false)
-            {
-                if (ValidationHelper.ModelHasRequiredForPersistenceErrors(contentItem) && IsCreatingAction(contentItem.Action))
-                {
-                    //ok, so the absolute mandatory data is invalid and it's new, we cannot actually continue!
-                    // add the modelstate to the outgoing object and throw a validation message
-                    var forDisplay = AutoMapperExtensions.MapWithUmbracoContext<IContent, ContentItemDisplay>(contentItem.PersistedContent, UmbracoContext);
-                    forDisplay.Errors = ModelState.ToErrorDictionary();
-                    throw new HttpResponseException(Request.CreateValidationErrorResponse(forDisplay));
-
-                }
-
-                //if the model state is not valid we cannot publish so change it to save
-                switch (contentItem.Action)
-                {
-                    case ContentSaveAction.Publish:
-                        contentItem.Action = ContentSaveAction.Save;
-                        break;
-                    case ContentSaveAction.PublishNew:
-                        contentItem.Action = ContentSaveAction.SaveNew;
-                        break;
-                }
-            }
-
-            //initialize this to successful
-            var publishStatus = Attempt<PublishStatus>.Succeed();
-            var wasCancelled = false;
-
-            if (contentItem.Action == ContentSaveAction.Save || contentItem.Action == ContentSaveAction.SaveNew)
-            {
-                //save the item
-                var saveResult = saveMethod(contentItem.PersistedContent);
-
-                wasCancelled = saveResult.Success == false && saveResult.Result.StatusType == OperationStatusType.FailedCancelledByEvent;
-            }
-            else if (contentItem.Action == ContentSaveAction.SendPublish || contentItem.Action == ContentSaveAction.SendPublishNew)
-            {
-                var sendResult = Services.ContentService.SendToPublication(contentItem.PersistedContent, Security.CurrentUser.Id);
-                wasCancelled = sendResult == false;
-            }
-            else
-            {
-                //publish the item and check if it worked, if not we will show a diff msg below
-                publishStatus = Services.ContentService.SaveAndPublishWithStatus(contentItem.PersistedContent, Security.CurrentUser.Id);
-                wasCancelled = publishStatus.Result.StatusType == PublishStatusType.FailedCancelledByEvent;
-            }
-
-            //return the updated model
-            var display = AutoMapperExtensions.MapWithUmbracoContext<IContent, ContentItemDisplay>(contentItem.PersistedContent, UmbracoContext);
-
-            //lasty, if it is not valid, add the modelstate to the outgoing object and throw a 403
-            HandleInvalidModelState(display);
-
-            //put the correct msgs in
-            switch (contentItem.Action)
-            {
-                case ContentSaveAction.Save:
-                case ContentSaveAction.SaveNew:
-                    if (wasCancelled == false)
-                    {
-                        display.AddSuccessNotification(
-                            Services.TextService.Localize("speechBubbles/editContentSavedHeader"),
-                            contentItem.ReleaseDate.HasValue
-                                ? Services.TextService.Localize("speechBubbles/editContentSavedWithReleaseDateText", new [] { contentItem.ReleaseDate.Value.ToLongDateString(), contentItem.ReleaseDate.Value.ToShortTimeString() })
-                                : Services.TextService.Localize("speechBubbles/editContentSavedText")
-                        );
-                    }
-                    else
-                    {
-                        AddCancelMessage(display);
-                    }
-                    break;
-                case ContentSaveAction.SendPublish:
-                case ContentSaveAction.SendPublishNew:
-                    if (wasCancelled == false)
-                    {
-                        display.AddSuccessNotification(
-                            Services.TextService.Localize("speechBubbles/editContentSendToPublish"),
-                            Services.TextService.Localize("speechBubbles/editContentSendToPublishText"));
-                    }
-                    else
-                    {
-                        AddCancelMessage(display);
-                    }
-                    break;
-                case ContentSaveAction.Publish:
-                case ContentSaveAction.PublishNew:
-                    ShowMessageForPublishStatus(publishStatus.Result, display, contentItem.ExpireDate);
-                    break;
-            }
-
-            //If the item is new and the operation was cancelled, we need to return a different
-            // status code so the UI can handle it since it won't be able to redirect since there
-            // is no Id to redirect to!
-            if (wasCancelled && IsCreatingAction(contentItem.Action))
-            {
-                throw new HttpResponseException(Request.CreateValidationErrorResponse(display));
-            }
-
-            display.PersistedContent = contentItem.PersistedContent;
-
-            return display;
-        }
-
-        /// <summary>
-        /// Publishes a document with a given ID
-        /// </summary>
-        /// <param name="id"></param>
-        /// <returns></returns>
-        /// <remarks>
-        /// The CanAccessContentAuthorize attribute will deny access to this method if the current user
-        /// does not have Publish access to this node.
-        /// </remarks>
-        ///
-        [EnsureUserPermissionForContent("id", 'U')]
-        public HttpResponseMessage PostPublishById(int id)
-        {
-            var foundContent = GetObjectFromRequest(() => Services.ContentService.GetById(id));
-
-            if (foundContent == null)
-            {
-                return HandleContentNotFound(id, false);
-            }
-
-            var publishResult = Services.ContentService.PublishWithStatus(foundContent, Security.CurrentUser.Id);
-            if (publishResult.Success == false)
-            {
-                var notificationModel = new SimpleNotificationModel();
-                ShowMessageForPublishStatus(publishResult.Result, notificationModel, foundContent.ExpireDate);
-                return Request.CreateValidationErrorResponse(notificationModel);
-            }
-
-            //return ok
-            return Request.CreateResponse(HttpStatusCode.OK);
-
-        }
-
-        [HttpDelete]
-        [HttpPost]
-        public HttpResponseMessage DeleteBlueprint(int id)
-        {
-            var found = Services.ContentService.GetBlueprintById(id);
-
-            if (found == null)
-            {
-                return HandleContentNotFound(id, false);
-            }
-
-            Services.ContentService.DeleteBlueprint(found);
-
-            return Request.CreateResponse(HttpStatusCode.OK);
-        }
-
-        /// <summary>
-        /// Moves an item to the recycle bin, if it is already there then it will permanently delete it
-        /// </summary>
-        /// <param name="id"></param>
-        /// <returns></returns>
-        /// <remarks>
-        /// The CanAccessContentAuthorize attribute will deny access to this method if the current user
-        /// does not have Delete access to this node.
-        /// </remarks>
-        [EnsureUserPermissionForContent("id", 'D')]
-        [HttpDelete]
-        [HttpPost]
-        public HttpResponseMessage DeleteById(int id)
-        {
-            var foundContent = GetObjectFromRequest(() => Services.ContentService.GetById(id));
-
-            if (foundContent == null)
-            {
-                return HandleContentNotFound(id, false);
-            }
-
-            //if the current item is in the recycle bin
-            if (foundContent.IsInRecycleBin() == false)
-            {
-                var moveResult = Services.ContentService.WithResult().MoveToRecycleBin(foundContent, Security.CurrentUser.Id);
-                if (moveResult == false)
-                {
-                    //returning an object of INotificationModel will ensure that any pending
-                    // notification messages are added to the response.
-                    return Request.CreateValidationErrorResponse(new SimpleNotificationModel());
-                }
-            }
-            else
-            {
-                var deleteResult = Services.ContentService.WithResult().Delete(foundContent, Security.CurrentUser.Id);
-                if (deleteResult == false)
-                {
-                    //returning an object of INotificationModel will ensure that any pending
-                    // notification messages are added to the response.
-                    return Request.CreateValidationErrorResponse(new SimpleNotificationModel());
-                }
-            }
-
-            return Request.CreateResponse(HttpStatusCode.OK);
-        }
-
-        /// <summary>
-        /// Empties the recycle bin
-        /// </summary>
-        /// <returns></returns>
-        /// <remarks>
-        /// attributed with EnsureUserPermissionForContent to verify the user has access to the recycle bin
-        /// </remarks>
-        [HttpDelete]
-        [HttpPost]
-        [EnsureUserPermissionForContent(Constants.System.RecycleBinContent, 'D')]
-        public HttpResponseMessage EmptyRecycleBin()
-        {
-            Services.ContentService.EmptyRecycleBin(Security.CurrentUser.Id);
-
-            return Request.CreateNotificationSuccessResponse(Services.TextService.Localize("defaultdialogs/recycleBinIsEmpty"));
-        }
-
-        /// <summary>
-        /// Change the sort order for content
-        /// </summary>
-        /// <param name="sorted"></param>
-        /// <returns></returns>
-        [EnsureUserPermissionForContent("sorted.ParentId", 'S')]
-        public HttpResponseMessage PostSort(ContentSortOrder sorted)
-        {
-            if (sorted == null)
-            {
-                return Request.CreateResponse(HttpStatusCode.NotFound);
-            }
-
-            //if there's nothing to sort just return ok
-            if (sorted.IdSortOrder.Length == 0)
-            {
-                return Request.CreateResponse(HttpStatusCode.OK);
-            }
-
-            try
-            {
-                var contentService = Services.ContentService;
-
-                // Save content with new sort order and update content xml in db accordingly
-                if (contentService.Sort(sorted.IdSortOrder, Security.CurrentUser.Id) == false)
-                {
-                    LogHelper.Warn<ContentController>("Content sorting failed, this was probably caused by an event being cancelled");
-                    return Request.CreateValidationErrorResponse("Content sorting failed, this was probably caused by an event being cancelled");
-                }
-                return Request.CreateResponse(HttpStatusCode.OK);
-            }
-            catch (Exception ex)
-            {
-                LogHelper.Error<ContentController>("Could not update content sort order", ex);
-                throw;
-            }
-        }
-
-        /// <summary>
-        /// Change the sort order for media
-        /// </summary>
-        /// <param name="move"></param>
-        /// <returns></returns>
-        [EnsureUserPermissionForContent("move.ParentId", 'M')]
-        public HttpResponseMessage PostMove(MoveOrCopy move)
-        {
-            var toMove = ValidateMoveOrCopy(move);
-
-            Services.ContentService.Move(toMove, move.ParentId, Security.CurrentUser.Id);
-
-            var response = Request.CreateResponse(HttpStatusCode.OK);
-            response.Content = new StringContent(toMove.Path, Encoding.UTF8, "application/json");
-            return response;
-        }
-
-        /// <summary>
-        /// Copies a content item and places the copy as a child of a given parent Id
-        /// </summary>
-        /// <param name="copy"></param>
-        /// <returns></returns>
-        [EnsureUserPermissionForContent("copy.ParentId", 'C')]
-        public HttpResponseMessage PostCopy(MoveOrCopy copy)
-        {
-            var toCopy = ValidateMoveOrCopy(copy);
-
-            var c = Services.ContentService.Copy(toCopy, copy.ParentId, copy.RelateToOriginal, copy.Recursive, Security.CurrentUser.Id);
-
-            var response = Request.CreateResponse(HttpStatusCode.OK);
-            response.Content = new StringContent(c.Path, Encoding.UTF8, "application/json");
-            return response;
-        }
-
-        /// <summary>
-        /// Unpublishes a node with a given Id and returns the unpublished entity
-        /// </summary>
-        /// <param name="id"></param>
-        /// <returns></returns>
-        [EnsureUserPermissionForContent("id", 'U')]
-        [OutgoingEditorModelEvent]
-        public ContentItemDisplay PostUnPublish(int id)
-        {
-            var foundContent = GetObjectFromRequest(() => Services.ContentService.GetById(id));
-
-            if (foundContent == null)
-                HandleContentNotFound(id);
-
-            var unpublishResult = Services.ContentService.WithResult().UnPublish(foundContent, Security.CurrentUser.Id);
-
-            var content = AutoMapperExtensions.MapWithUmbracoContext<IContent, ContentItemDisplay>(foundContent, UmbracoContext);
-
-            if (unpublishResult == false)
-            {
-                AddCancelMessage(content);
-                throw new HttpResponseException(Request.CreateValidationErrorResponse(content));
-            }
-            else
-            {
-                content.AddSuccessNotification(Services.TextService.Localize("content/unPublish"), Services.TextService.Localize("speechBubbles/contentUnpublished"));
-                return content;
-            }
-        }
-
-        /// <summary>
-        /// Maps the dto property values to the persisted model
-        /// </summary>
-        /// <param name="contentItem"></param>
-        private void MapPropertyValues(ContentItemSave contentItem)
-        {
-            UpdateName(contentItem);
-
-            //TODO: We need to support 'send to publish'
-
-            contentItem.PersistedContent.ExpireDate = contentItem.ExpireDate;
-            contentItem.PersistedContent.ReleaseDate = contentItem.ReleaseDate;
-            //only set the template if it didn't change
-            var templateChanged = (contentItem.PersistedContent.Template == null && contentItem.TemplateAlias.IsNullOrWhiteSpace() == false)
-                                                        || (contentItem.PersistedContent.Template != null && contentItem.PersistedContent.Template.Alias != contentItem.TemplateAlias)
-                                                        || (contentItem.PersistedContent.Template != null && contentItem.TemplateAlias.IsNullOrWhiteSpace());
-            if (templateChanged)
-            {
-                var template = Services.FileService.GetTemplate(contentItem.TemplateAlias);
-                if (template == null && contentItem.TemplateAlias.IsNullOrWhiteSpace() == false)
-                {
-                    //ModelState.AddModelError("Template", "No template exists with the specified alias: " + contentItem.TemplateAlias);
-                    LogHelper.Warn<ContentController>("No template exists with the specified alias: " + contentItem.TemplateAlias);
-                }
-                else
-                {
-                    //NOTE: this could be null if there was a template and the posted template is null, this should remove the assigned template
-                    contentItem.PersistedContent.Template = template;
-                }
-            }
-
-            base.MapPropertyValues(contentItem);
-        }
-
-        /// <summary>
-        /// Ensures the item can be moved/copied to the new location
-        /// </summary>
-        /// <param name="model"></param>
-        /// <returns></returns>
-        private IContent ValidateMoveOrCopy(MoveOrCopy model)
-        {
-            if (model == null)
-            {
-                throw new HttpResponseException(HttpStatusCode.NotFound);
-            }
-
-            var contentService = Services.ContentService;
-            var toMove = contentService.GetById(model.Id);
-            if (toMove == null)
-            {
-                throw new HttpResponseException(HttpStatusCode.NotFound);
-            }
-            if (model.ParentId < 0)
-            {
-                //cannot move if the content item is not allowed at the root
-                if (toMove.ContentType.AllowedAsRoot == false)
-                {
-                    throw new HttpResponseException(
-                            Request.CreateNotificationValidationErrorResponse(
-                                    Services.TextService.Localize("moveOrCopy/notAllowedAtRoot")));
-                }
-            }
-            else
-            {
-                var parent = contentService.GetById(model.ParentId);
-                if (parent == null)
-                {
-                    throw new HttpResponseException(HttpStatusCode.NotFound);
-                }
-
-                //check if the item is allowed under this one
-                if (parent.ContentType.AllowedContentTypes.Select(x => x.Id).ToArray()
-                        .Any(x => x.Value == toMove.ContentType.Id) == false)
-                {
-                    throw new HttpResponseException(
-                            Request.CreateNotificationValidationErrorResponse(
-                                    Services.TextService.Localize("moveOrCopy/notAllowedByContentType")));
-                }
-
-                // Check on paths
-                if ((string.Format(",{0},", parent.Path)).IndexOf(string.Format(",{0},", toMove.Id), StringComparison.Ordinal) > -1)
-                {
-                    throw new HttpResponseException(
-                            Request.CreateNotificationValidationErrorResponse(
-                                    Services.TextService.Localize("moveOrCopy/notAllowedByPath")));
-                }
-            }
-
-            return toMove;
-        }
-
-        private void ShowMessageForPublishStatus(PublishStatus status, INotificationModel display, DateTime? expireDate)
-        {
-            switch (status.StatusType)
-            {
-                case PublishStatusType.Success:
-                case PublishStatusType.SuccessAlreadyPublished:
-                    display.AddSuccessNotification(
-                            Services.TextService.Localize("speechBubbles/editContentPublishedHeader"),
-                            expireDate.HasValue
-                                ? Services.TextService.Localize("speechBubbles/editContentPublishedWithExpireDateText", new [] { expireDate.Value.ToLongDateString(), expireDate.Value.ToShortTimeString() })
-                                : Services.TextService.Localize("speechBubbles/editContentPublishedText")
-                    );
-                    break;
-                case PublishStatusType.FailedPathNotPublished:
-                    display.AddWarningNotification(
-                            Services.TextService.Localize("publish"),
-                            Services.TextService.Localize("publish/contentPublishedFailedByParent",
-                                    new[] { string.Format("{0} ({1})", status.ContentItem.Name, status.ContentItem.Id) }).Trim());
-                    break;
-                case PublishStatusType.FailedCancelledByEvent:
-                    AddCancelMessage(display, "publish", "speechBubbles/contentPublishedFailedByEvent");
-                    break;
-                case PublishStatusType.FailedAwaitingRelease:
-                    display.AddWarningNotification(
-                            Services.TextService.Localize("publish"),
-                            Services.TextService.Localize("publish/contentPublishedFailedAwaitingRelease",
-                                    new[] { string.Format("{0} ({1})", status.ContentItem.Name, status.ContentItem.Id) }).Trim());
-                    break;
-                case PublishStatusType.FailedHasExpired:
-                    display.AddWarningNotification(
-                            Services.TextService.Localize("publish"),
-                            Services.TextService.Localize("publish/contentPublishedFailedExpired",
-                                    new[]
-                                    {
-                                                                string.Format("{0} ({1})", status.ContentItem.Name, status.ContentItem.Id),
-                                    }).Trim());
-                    break;
-                case PublishStatusType.FailedIsTrashed:
-                    //TODO: We should add proper error messaging for this!
-                    break;
-                case PublishStatusType.FailedContentInvalid:
-                    display.AddWarningNotification(
-                            Services.TextService.Localize("publish"),
-                            Services.TextService.Localize("publish/contentPublishedFailedInvalid",
-                                    new[]
-                                    {
-                                                                string.Format("{0} ({1})", status.ContentItem.Name, status.ContentItem.Id),
-                                                                string.Join(",", status.InvalidProperties.Select(x => x.Alias))
-                                    }).Trim());
-                    break;
-                default:
-                    throw new IndexOutOfRangeException();
-            }
-        }
-
-
-        /// <summary>
-        /// Performs a permissions check for the user to check if it has access to the node based on
-        /// start node and/or permissions for the node
-        /// </summary>
-        /// <param name="storage">The storage to add the content item to so it can be reused</param>
-        /// <param name="user"></param>
-        /// <param name="userService"></param>
-        /// <param name="contentService"></param>
-        /// <param name="entityService"></param>
-        /// <param name="nodeId">The content to lookup, if the contentItem is not specified</param>
-        /// <param name="permissionsToCheck"></param>
-        /// <param name="contentItem">Specifies the already resolved content item to check against</param>
-        /// <returns></returns>
-        internal static bool CheckPermissions(
-                IDictionary<string, object> storage,
-                IUser user,
-                IUserService userService,
-                IContentService contentService,
-                IEntityService entityService,
-                int nodeId,
-                char[] permissionsToCheck = null,
-                IContent contentItem = null)
-        {
-            if (storage == null) throw new ArgumentNullException("storage");
-            if (user == null) throw new ArgumentNullException("user");
-            if (userService == null) throw new ArgumentNullException("userService");
-            if (contentService == null) throw new ArgumentNullException("contentService");
-            if (entityService == null) throw new ArgumentNullException("entityService");
-
-            if (contentItem == null && nodeId != Constants.System.Root && nodeId != Constants.System.RecycleBinContent)
-            {
-                contentItem = contentService.GetById(nodeId);
-                //put the content item into storage so it can be retreived
-                // in the controller (saves a lookup)
-                storage[typeof(IContent).ToString()] = contentItem;
-            }
-
-            if (contentItem == null && nodeId != Constants.System.Root && nodeId != Constants.System.RecycleBinContent)
-            {
-                throw new HttpResponseException(HttpStatusCode.NotFound);
-            }
-
-            var hasPathAccess = (nodeId == Constants.System.Root)
-                ? user.HasContentRootAccess(entityService)
-                : (nodeId == Constants.System.RecycleBinContent)
-                    ? user.HasContentBinAccess(entityService)
-                    : user.HasPathAccess(contentItem, entityService);
-
-            if (hasPathAccess == false)
-            {
-                return false;
-            }
-
-            if (permissionsToCheck == null || permissionsToCheck.Length == 0)
-            {
-                return true;
-            }
-
-            //get the implicit/inherited permissions for the user for this path,
-            //if there is no content item for this id, than just use the id as the path (i.e. -1 or -20)
-            var path = contentItem != null ? contentItem.Path : nodeId.ToString();
-            var permission = userService.GetPermissionsForPath(user, path);
-
-            var allowed = true;
-            foreach (var p in permissionsToCheck)
-            {
-                if (permission == null
-                    || permission.GetAllPermissions().Contains(p.ToString(CultureInfo.InvariantCulture)) == false)
-                {
-                    allowed = false;
-                }
-            }
-            return allowed;
-        }
-
-        [EnsureUserPermissionForContent("contentId", 'F')]
-        public IEnumerable<NotifySetting> GetNotificationOptions(int contentId)
-        {
-            var notifications = new List<NotifySetting>();
-            if (contentId <= 0) throw new HttpResponseException(Request.CreateResponse(HttpStatusCode.NotFound));
-
-            var content = Services.ContentService.GetById(contentId);
-            if (content == null) throw new HttpResponseException(Request.CreateResponse(HttpStatusCode.NotFound));
-
-            var actionList = ActionsResolver.Current.Actions;
-            foreach (var a in actionList)
-            {
-                if (a.ShowInNotifier)
-                {
-                    NotifySetting n = new NotifySetting
-                    {
-                        Name = ui.Text("actions", a.Alias),
-                        Checked = (UmbracoUser.GetNotifications(content.Path).IndexOf(a.Letter) > -1),
-                        NotifyCode = a.Letter.ToString()
-                    };
-                    notifications.Add(n);
-                }
-            }
-            return notifications;
-        }
-
-        public void PostNotificationOptions(int contentId, string notifyOptions = "")
-        {
-            if (contentId <= 0) throw new HttpResponseException(Request.CreateResponse(HttpStatusCode.NotFound));
-            var content = Services.ContentService.GetById(contentId);
-
-            if (content == null) throw new HttpResponseException(Request.CreateResponse(HttpStatusCode.NotFound));
-            var node = new CMSNode(contentId);
-
-            global::umbraco.cms.businesslogic.workflow.Notification.UpdateNotifications(UmbracoUser, node, notifyOptions ?? "");
-        }
-    }
-}
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.IO;
+using System.Linq;
+using System.Net;
+using System.Net.Http;
+using System.Text;
+using System.Web.Http;
+using System.Web.Http.Controllers;
+using System.Web.Http.ModelBinding;
+using AutoMapper;
+using Umbraco.Core;
+using Umbraco.Core.Logging;
+using Umbraco.Core.Models;
+using Umbraco.Core.Models.Membership;
+using Umbraco.Core.Persistence.DatabaseModelDefinitions;
+using Umbraco.Core.Publishing;
+using Umbraco.Core.Services;
+using Umbraco.Web.Models.ContentEditing;
+using Umbraco.Web.Models.Mapping;
+using Umbraco.Web.Mvc;
+using Umbraco.Web.WebApi;
+using Umbraco.Web.WebApi.Binders;
+using Umbraco.Web.WebApi.Filters;
+using Umbraco.Core.Events;
+using Constants = Umbraco.Core.Constants;
+using umbraco.cms.businesslogic;
+using System.Collections;
+using umbraco;
+
+namespace Umbraco.Web.Editors
+{
+    /// <summary>
+    /// The API controller used for editing content
+    /// </summary>
+    /// <remarks>
+    /// This controller is decorated with the UmbracoApplicationAuthorizeAttribute which means that any user requesting
+    /// access to ALL of the methods on this controller will need access to the content application.
+    /// </remarks>
+    [PluginController("UmbracoApi")]
+    [UmbracoApplicationAuthorize(Constants.Applications.Content)]
+    [ContentControllerConfiguration]
+    public class ContentController : ContentControllerBase
+    {
+        /// <summary>
+        /// Constructor
+        /// </summary>
+        public ContentController()
+                : this(UmbracoContext.Current)
+        {
+        }
+
+        /// <summary>
+        /// Constructor
+        /// </summary>
+        /// <param name="umbracoContext"></param>
+        public ContentController(UmbracoContext umbracoContext)
+                : base(umbracoContext)
+        {
+        }
+
+        /// <summary>
+        /// Configures this controller with a custom action selector
+        /// </summary>
+        private class ContentControllerConfigurationAttribute : Attribute, IControllerConfiguration
+        {
+            public void Initialize(HttpControllerSettings controllerSettings, HttpControllerDescriptor controllerDescriptor)
+            {
+                controllerSettings.Services.Replace(typeof(IHttpActionSelector), new ParameterSwapControllerActionSelector(
+                    new ParameterSwapControllerActionSelector.ParameterSwapInfo("GetNiceUrl", "id", typeof(int), typeof(Guid), typeof(Udi)),
+                    new ParameterSwapControllerActionSelector.ParameterSwapInfo("GetById", "id", typeof(int), typeof(Guid), typeof(Udi))
+                ));
+            }
+        }
+
+        /// <summary>
+        /// Return content for the specified ids
+        /// </summary>
+        /// <param name="ids"></param>
+        /// <returns></returns>
+        [FilterAllowedOutgoingContent(typeof(IEnumerable<ContentItemDisplay>))]
+        public IEnumerable<ContentItemDisplay> GetByIds([FromUri]int[] ids)
+        {
+            var foundContent = Services.ContentService.GetByIds(ids);
+            return foundContent.Select(content => AutoMapperExtensions.MapWithUmbracoContext<IContent, ContentItemDisplay>(content, UmbracoContext));
+        }
+
+        /// <summary>
+        /// Updates the permissions for a content item for a particular user group
+        /// </summary>
+        /// <param name="saveModel"></param>
+        /// <returns></returns>
+        /// <remarks>
+        /// Permission check is done for letter 'R' which is for <see cref="ActionRights"/> which the user must have access to to update
+        /// </remarks>
+        [EnsureUserPermissionForContent("saveModel.ContentId", 'R')]
+        public IEnumerable<AssignedUserGroupPermissions> PostSaveUserGroupPermissions(UserGroupPermissionsSave saveModel)
+        {
+            if (saveModel.ContentId <= 0) throw new HttpResponseException(Request.CreateResponse(HttpStatusCode.NotFound));
+
+            //TODO: Should non-admins be alowed to set granular permissions?
+
+            var content = Services.ContentService.GetById(saveModel.ContentId);
+            if (content == null) throw new HttpResponseException(Request.CreateResponse(HttpStatusCode.NotFound));
+
+            //current permissions explicitly assigned to this content item
+            var contentPermissions = Services.ContentService.GetPermissionsForEntity(content)
+                .ToDictionary(x => x.UserGroupId, x => x);
+
+            var allUserGroups = Services.UserService.GetAllUserGroups().ToArray();
+
+            //loop through each user group
+            foreach (var userGroup in allUserGroups)
+            {
+                //check if there's a permission set posted up for this user group
+                IEnumerable<string> groupPermissions;
+                if (saveModel.AssignedPermissions.TryGetValue(userGroup.Id, out groupPermissions))
+                {
+                    //create a string collection of the assigned letters
+                    var groupPermissionCodes = groupPermissions.ToArray();
+
+                    //check if there are no permissions assigned for this group save model, if that is the case we want to reset the permissions
+                    //for this group/node which will go back to the defaults
+                    if (groupPermissionCodes.Length == 0)
+                    {
+                        Services.UserService.RemoveUserGroupPermissions(userGroup.Id, content.Id);
+                    }
+                    //check if they are the defaults, if so we should just remove them if they exist since it's more overhead having them stored
+                    else if (userGroup.Permissions.UnsortedSequenceEqual(groupPermissionCodes))
+                    {
+                        //only remove them if they are actually currently assigned
+                        if (contentPermissions.ContainsKey(userGroup.Id))
+                        {
+                            //remove these permissions from this node for this group since the ones being assigned are the same as the defaults
+                            Services.UserService.RemoveUserGroupPermissions(userGroup.Id, content.Id);
+                        }
+                    }
+                    //if they are different we need to update, otherwise there's nothing to update
+                    else if (contentPermissions.ContainsKey(userGroup.Id) == false || contentPermissions[userGroup.Id].AssignedPermissions.UnsortedSequenceEqual(groupPermissionCodes) == false)
+                    {
+
+                        Services.UserService.ReplaceUserGroupPermissions(userGroup.Id, groupPermissionCodes.Select(x => x[0]), content.Id);
+                    }
+                }
+            }
+
+            return GetDetailedPermissions(content, allUserGroups);
+        }
+
+        /// <summary>
+        /// Returns the user group permissions for user groups assigned to this node
+        /// </summary>
+        /// <param name="contentId"></param>
+        /// <returns></returns>
+        /// <remarks>
+        /// Permission check is done for letter 'R' which is for <see cref="ActionRights"/> which the user must have access to to view
+        /// </remarks>
+        [EnsureUserPermissionForContent("contentId", 'R')]
+        public IEnumerable<AssignedUserGroupPermissions> GetDetailedPermissions(int contentId)
+        {
+            if (contentId <= 0) throw new HttpResponseException(Request.CreateResponse(HttpStatusCode.NotFound));
+            var content = Services.ContentService.GetById(contentId);
+            if (content == null) throw new HttpResponseException(Request.CreateResponse(HttpStatusCode.NotFound));
+
+            //TODO: Should non-admins be able to see detailed permissions?
+
+            var allUserGroups = Services.UserService.GetAllUserGroups();
+
+            return GetDetailedPermissions(content, allUserGroups);
+        }
+
+        private IEnumerable<AssignedUserGroupPermissions> GetDetailedPermissions(IContent content, IEnumerable<IUserGroup> allUserGroups)
+        {
+            //get all user groups and map their default permissions to the AssignedUserGroupPermissions model.
+            //we do this because not all groups will have true assigned permissions for this node so if they don't have assigned permissions, we need to show the defaults.
+
+            var defaultPermissionsByGroup = Mapper.Map<IEnumerable<AssignedUserGroupPermissions>>(allUserGroups).ToArray();
+
+            var defaultPermissionsAsDictionary = defaultPermissionsByGroup
+                .ToDictionary(x => Convert.ToInt32(x.Id), x => x);
+
+            //get the actual assigned permissions
+            var assignedPermissionsByGroup = Services.ContentService.GetPermissionsForEntity(content).ToArray();
+
+            //iterate over assigned and update the defaults with the real values
+            foreach (var assignedGroupPermission in assignedPermissionsByGroup)
+            {
+                var defaultUserGroupPermissions = defaultPermissionsAsDictionary[assignedGroupPermission.UserGroupId];
+
+                //clone the default permissions model to the assigned ones
+                defaultUserGroupPermissions.AssignedPermissions = AssignedUserGroupPermissions.ClonePermissions(defaultUserGroupPermissions.DefaultPermissions);
+
+                //since there is custom permissions assigned to this node for this group, we need to clear all of the default permissions
+                //and we'll re-check it if it's one of the explicitly assigned ones
+                foreach (var permission in defaultUserGroupPermissions.AssignedPermissions.SelectMany(x => x.Value))
+                {
+                    permission.Checked = false;
+                    permission.Checked = assignedGroupPermission.AssignedPermissions.Contains(permission.PermissionCode, StringComparer.InvariantCulture);
+                }
+
+            }
+
+            return defaultPermissionsByGroup;
+        }
+
+        /// <summary>
+        /// Returns an item to be used to display the recycle bin for content
+        /// </summary>
+        /// <returns></returns>
+        public ContentItemDisplay GetRecycleBin()
+        {
+            var display = new ContentItemDisplay
+            {
+                Id = Constants.System.RecycleBinContent,
+                Alias = "recycleBin",
+                ParentId = -1,
+                Name = Services.TextService.Localize("general/recycleBin"),
+                ContentTypeAlias = "recycleBin",
+                CreateDate = DateTime.Now,
+                IsContainer = true,
+                Path = "-1," + Constants.System.RecycleBinContent
+            };
+
+            TabsAndPropertiesResolver<IContent>.AddListView(display, "content", Services.DataTypeService, Services.TextService);
+
+            return display;
+        }
+
+        public ContentItemDisplay GetBlueprintById(int id)
+        {
+            var foundContent = Services.ContentService.GetBlueprintById(id);
+            if (foundContent == null)
+            {
+                HandleContentNotFound(id);
+            }
+
+            var content = AutoMapperExtensions.MapWithUmbracoContext<IContent, ContentItemDisplay>(foundContent, UmbracoContext);
+
+            SetupBlueprint(content, foundContent);
+
+            return content;
+        }
+
+        private static void SetupBlueprint(ContentItemDisplay content, IContent persistedContent)
+        {
+            content.AllowPreview = false;
+
+            //set a custom path since the tree that renders this has the content type id as the parent
+            content.Path = string.Format("-1,{0},{1}", persistedContent.ContentTypeId, content.Id);
+
+            content.AllowedActions = new[] { "A" };
+            content.IsBlueprint = true;
+
+            var excludeProps = new[] { "_umb_urls", "_umb_releasedate", "_umb_expiredate", "_umb_template" };
+            var propsTab = content.Tabs.Last();
+            propsTab.Properties = propsTab.Properties
+                .Where(p => excludeProps.Contains(p.Alias) == false);
+        }
+
+        /// <summary>
+        /// Gets the content json for the content id
+        /// </summary>
+        /// <param name="id"></param>
+        /// <returns></returns>
+        [OutgoingEditorModelEvent]
+        [EnsureUserPermissionForContent("id")]
+        public ContentItemDisplay GetById(int id)
+        {
+            var foundContent = GetObjectFromRequest(() => Services.ContentService.GetById(id));
+            if (foundContent == null)
+            {
+                HandleContentNotFound(id);
+            }
+
+            var content = AutoMapperExtensions.MapWithUmbracoContext<IContent, ContentItemDisplay>(foundContent, UmbracoContext);
+            return content;
+        }
+
+        /// <summary>
+        /// Gets the content json for the content id
+        /// </summary>
+        /// <param name="id"></param>
+        /// <returns></returns>
+        [OutgoingEditorModelEvent]
+        [EnsureUserPermissionForContent("id")]
+        public ContentItemDisplay GetById(Guid id)
+        {
+            var foundContent = GetObjectFromRequest(() => Services.ContentService.GetById(id));
+            if (foundContent == null)
+            {
+                HandleContentNotFound(id);
+            }
+
+            var content = AutoMapperExtensions.MapWithUmbracoContext<IContent, ContentItemDisplay>(foundContent, UmbracoContext);
+            return content;
+        }
+
+        /// <summary>
+        /// Gets the content json for the content id
+        /// </summary>
+        /// <param name="id"></param>
+        /// <returns></returns>
+        [OutgoingEditorModelEvent]
+        [EnsureUserPermissionForContent("id")]
+        public ContentItemDisplay GetById(Udi id)
+        {
+            var guidUdi = id as GuidUdi;
+            if (guidUdi != null)
+            {
+                return GetById(guidUdi.Guid);
+            }
+
+            throw new HttpResponseException(HttpStatusCode.NotFound);
+        }
+
+        [EnsureUserPermissionForContent("id")]
+        public ContentItemDisplay GetWithTreeDefinition(int id)
+        {
+            var foundContent = GetObjectFromRequest(() => Services.ContentService.GetById(id));
+            if (foundContent == null)
+            {
+                HandleContentNotFound(id);
+            }
+
+            var content = AutoMapperExtensions.MapWithUmbracoContext<IContent, ContentItemDisplay>(foundContent, UmbracoContext);
+            return content;
+        }
+
+        /// <summary>
+        /// Gets an empty content item for the
+        /// </summary>
+        /// <param name="contentTypeAlias"></param>
+        /// <param name="parentId"></param>
+        /// <returns>
+        /// If this is a container type, we'll remove the umbContainerView tab for a new item since
+        /// it cannot actually list children if it doesn't exist yet.
+        /// </returns>
+        [OutgoingEditorModelEvent]
+        public ContentItemDisplay GetEmpty(string contentTypeAlias, int parentId)
+        {
+            var contentType = Services.ContentTypeService.GetContentType(contentTypeAlias);
+            if (contentType == null)
+            {
+                throw new HttpResponseException(HttpStatusCode.NotFound);
+            }
+
+            var emptyContent = Services.ContentService.CreateContent("", parentId, contentType.Alias, UmbracoUser.Id);
+            var mapped = AutoMapperExtensions.MapWithUmbracoContext<IContent, ContentItemDisplay>(emptyContent, UmbracoContext);
+            // translate the content type name if applicable
+            mapped.ContentTypeName = Services.TextService.UmbracoDictionaryTranslate(mapped.ContentTypeName);
+            // if your user type doesn't have access to the Settings section it would not get this property mapped
+            if(mapped.DocumentType != null)
+                mapped.DocumentType.Name = Services.TextService.UmbracoDictionaryTranslate(mapped.DocumentType.Name);
+
+            //remove this tab if it exists: umbContainerView
+            var containerTab = mapped.Tabs.FirstOrDefault(x => x.Alias == Constants.Conventions.PropertyGroups.ListViewGroupName);
+            mapped.Tabs = mapped.Tabs.Except(new[] { containerTab });
+            return mapped;
+        }
+
+        [OutgoingEditorModelEvent]
+        public ContentItemDisplay GetEmpty(int blueprintId, int parentId)
+        {
+            var blueprint = Services.ContentService.GetBlueprintById(blueprintId);
+            if (blueprint == null)
+            {
+                throw new HttpResponseException(HttpStatusCode.NotFound);
+            }
+
+            blueprint.Id = 0;
+            blueprint.Name = string.Empty;
+            blueprint.ParentId = parentId;
+
+            var mapped = Mapper.Map<ContentItemDisplay>(blueprint);
+
+            //remove this tab if it exists: umbContainerView
+            var containerTab = mapped.Tabs.FirstOrDefault(x => x.Alias == Constants.Conventions.PropertyGroups.ListViewGroupName);
+            mapped.Tabs = mapped.Tabs.Except(new[] { containerTab });
+            return mapped;
+        }
+
+        /// <summary>
+        /// Gets the Url for a given node ID
+        /// </summary>
+        /// <param name="id"></param>
+        /// <returns></returns>
+        public HttpResponseMessage GetNiceUrl(int id)
+        {
+            var url = Umbraco.NiceUrl(id);
+            var response = Request.CreateResponse(HttpStatusCode.OK);
+            response.Content = new StringContent(url, Encoding.UTF8, "application/json");
+            return response;
+        }
+
+        /// <summary>
+        /// Gets the Url for a given node ID
+        /// </summary>
+        /// <param name="id"></param>
+        /// <returns></returns>
+        public HttpResponseMessage GetNiceUrl(Guid id)
+        {
+            var url = Umbraco.UrlProvider.GetUrl(id);
+            var response = Request.CreateResponse(HttpStatusCode.OK);
+            response.Content = new StringContent(url, Encoding.UTF8, "application/json");
+            return response;
+        }
+
+        /// <summary>
+        /// Gets the Url for a given node ID
+        /// </summary>
+        /// <param name="id"></param>
+        /// <returns></returns>
+        public HttpResponseMessage GetNiceUrl(Udi id)
+        {
+            var guidUdi = id as GuidUdi;
+            if (guidUdi != null)
+            {
+                return GetNiceUrl(guidUdi.Guid);
+            }
+            throw new HttpResponseException(HttpStatusCode.NotFound);
+        }
+
+        /// <summary>
+        /// Gets the children for the content id passed in
+        /// </summary>
+        /// <returns></returns>
+        [FilterAllowedOutgoingContent(typeof(IEnumerable<ContentItemBasic<ContentPropertyBasic, IContent>>), "Items")]
+        public PagedResult<ContentItemBasic<ContentPropertyBasic, IContent>> GetChildren(
+                int id,
+                int pageNumber = 0,  //TODO: This should be '1' as it's not the index
+                int pageSize = 0,
+                string orderBy = "SortOrder",
+                Direction orderDirection = Direction.Ascending,
+                bool orderBySystemField = true,
+                string filter = "")
+        {
+            return GetChildren(id, null, pageNumber, pageSize, orderBy, orderDirection, orderBySystemField, filter);
+        }
+
+        /// <summary>
+        /// Gets the children for the content id passed in
+        /// </summary>
+        /// <returns></returns>
+        [FilterAllowedOutgoingContent(typeof(IEnumerable<ContentItemBasic<ContentPropertyBasic, IContent>>), "Items")]
+        public PagedResult<ContentItemBasic<ContentPropertyBasic, IContent>> GetChildren(
+                int id,
+                string includeProperties,
+                int pageNumber = 0,  //TODO: This should be '1' as it's not the index
+                int pageSize = 0,
+                string orderBy = "SortOrder",
+                Direction orderDirection = Direction.Ascending,
+                bool orderBySystemField = true,
+                string filter = "")
+        {
+            long totalChildren;
+            IContent[] children;
+            if (pageNumber > 0 && pageSize > 0)
+            {
+                children = Services.ContentService
+                 .GetPagedChildren(id, (pageNumber - 1), pageSize, out totalChildren
+                 , orderBy, orderDirection, orderBySystemField, filter).ToArray();
+            }
+            else
+            {
+                children = Services.ContentService.GetChildren(id).ToArray();
+                totalChildren = children.Length;
+            }
+
+            if (totalChildren == 0)
+            {
+                return new PagedResult<ContentItemBasic<ContentPropertyBasic, IContent>>(0, 0, 0);
+            }
+
+            var pagedResult = new PagedResult<ContentItemBasic<ContentPropertyBasic, IContent>>(totalChildren, pageNumber, pageSize);
+            pagedResult.Items = children.Select(content =>
+                Mapper.Map<IContent, ContentItemBasic<ContentPropertyBasic, IContent>>(content,
+                    opts =>
+                    {
+                        // if there's a list of property aliases to map - we will make sure to store this in the mapping context.
+                        if (String.IsNullOrWhiteSpace(includeProperties) == false)
+                        {
+                            opts.Items["IncludeProperties"] = includeProperties.Split(new[] { ", ", "," }, StringSplitOptions.RemoveEmptyEntries);
+                        }
+                    }));
+
+            return pagedResult;
+        }
+
+        [Obsolete("Dont use this, it is incorrectly named, use HasPermission instead")]
+        public bool GetHasPermission(string permissionToCheck, int nodeId)
+        {
+            return HasPermission(permissionToCheck, nodeId);
+        }
+
+        /// <summary>
+        /// Returns permissions for all nodes passed in for the current user
+        /// TODO: This should be moved to the CurrentUserController?
+        /// </summary>
+        /// <param name="nodeIds"></param>
+        /// <returns></returns>
+        [HttpPost]
+        public Dictionary<int, string[]> GetPermissions(int[] nodeIds)
+        {
+            var permissions = Services.UserService
+                    .GetPermissions(Security.CurrentUser, nodeIds);
+
+            var permissionsDictionary = new Dictionary<int, string[]>();
+            foreach (var nodeId in nodeIds)
+            {
+                var aggregatePerms = permissions.GetAllPermissions(nodeId).ToArray();
+                permissionsDictionary.Add(nodeId, aggregatePerms);
+            }
+
+            return permissionsDictionary;
+        }
+
+        /// <summary>
+        /// Checks a nodes permission for the current user
+        /// TODO: This should be moved to the CurrentUserController?
+        /// </summary>
+        /// <param name="permissionToCheck"></param>
+        /// <param name="nodeId"></param>
+        /// <returns></returns>
+        [HttpGet]
+        public bool HasPermission(string permissionToCheck, int nodeId)
+        {
+            var p = Services.UserService.GetPermissions(Security.CurrentUser, nodeId).GetAllPermissions();
+            if (p.Contains(permissionToCheck.ToString(CultureInfo.InvariantCulture)))
+            {
+                return true;
+            }
+
+            return false;
+        }
+
+        /// <summary>
+        /// Creates a blueprint from a content item
+        /// </summary>
+        /// <param name="contentId">The content id to copy</param>
+        /// <param name="name">The name of the blueprint</param>
+        /// <returns></returns>
+        [HttpPost]
+        public SimpleNotificationModel CreateBlueprintFromContent([FromUri]int contentId, [FromUri]string name)
+        {
+            if (string.IsNullOrWhiteSpace(name)) throw new ArgumentException("Value cannot be null or whitespace.", "name");
+
+            var content = Services.ContentService.GetById(contentId);
+            if (content == null)
+                throw new HttpResponseException(Request.CreateResponse(HttpStatusCode.NotFound));
+
+            EnsureUniqueName(name, content, "name");
+
+            var blueprint = Services.ContentService.CreateContentFromBlueprint(content, name, Security.CurrentUser.Id);
+
+            Services.ContentService.SaveBlueprint(blueprint, Security.CurrentUser.Id);
+
+            var notificationModel = new SimpleNotificationModel();
+            notificationModel.AddSuccessNotification(
+                Services.TextService.Localize("blueprints/createdBlueprintHeading"),
+                Services.TextService.Localize("blueprints/createdBlueprintMessage", new[] { content.Name })
+            );
+
+            return notificationModel;
+        }
+
+        private void EnsureUniqueName(string name, IContent content, string modelName)
+        {
+            var existing = Services.ContentService.GetBlueprintsForContentTypes(content.ContentTypeId);
+            if (existing.Any(x => x.Name == name && x.Id != content.Id))
+            {
+                ModelState.AddModelError(modelName, Services.TextService.Localize("blueprints/duplicateBlueprintMessage"));
+                throw new HttpResponseException(Request.CreateValidationErrorResponse(ModelState));
+            }
+        }
+
+        /// <summary>
+        /// Saves content
+        /// </summary>
+        /// <returns></returns>
+        [FileUploadCleanupFilter]
+        [ContentPostValidate]
+        public ContentItemDisplay PostSaveBlueprint(
+            [ModelBinder(typeof(BlueprintItemBinder))] ContentItemSave contentItem)
+        {
+            var contentItemDisplay = PostSaveInternal(contentItem,
+                content =>
+                {
+                    EnsureUniqueName(content.Name, content, "Name");
+
+                    Services.ContentService.SaveBlueprint(contentItem.PersistedContent, Security.CurrentUser.Id);
+                    //we need to reuse the underlying logic so return the result that it wants
+                    return Attempt<OperationStatus>.Succeed(new OperationStatus(OperationStatusType.Success, new EventMessages()));
+                });
+            SetupBlueprint(contentItemDisplay, contentItemDisplay.PersistedContent);
+
+            return contentItemDisplay;
+        }
+
+        /// <summary>
+        /// Saves content
+        /// </summary>
+        /// <returns></returns>
+        [FileUploadCleanupFilter]
+        [ContentPostValidate]
+        [OutgoingEditorModelEvent]
+        public ContentItemDisplay PostSave(
+                [ModelBinder(typeof(ContentItemBinder))]
+                                ContentItemSave contentItem)
+        {
+            return PostSaveInternal(contentItem,
+                content => Services.ContentService.WithResult().Save(contentItem.PersistedContent, Security.CurrentUser.Id));
+        }
+
+        private ContentItemDisplay PostSaveInternal(ContentItemSave contentItem, Func<IContent, Attempt<OperationStatus>> saveMethod)
+        {
+            //Recent versions of IE/Edge may send in the full clientside file path instead of just the file name.
+            //To ensure similar behavior across all browsers no matter what they do - we strip the FileName property of all
+            //uploaded files to being *only* the actual file name (as it should be).
+            if (contentItem.UploadedFiles != null && contentItem.UploadedFiles.Any())
+            {
+                foreach (var file in contentItem.UploadedFiles)
+                {
+                    file.FileName = Path.GetFileName(file.FileName);
+                }
+            }
+
+            //If we've reached here it means:
+            // * Our model has been bound
+            // * and validated
+            // * any file attachments have been saved to their temporary location for us to use
+            // * we have a reference to the DTO object and the persisted object
+            // * Permissions are valid
+            MapPropertyValues(contentItem);
+
+            //We need to manually check the validation results here because:
+            // * We still need to save the entity even if there are validation value errors
+            // * Depending on if the entity is new, and if there are non property validation errors (i.e. the name is null)
+            //      then we cannot continue saving, we can only display errors
+            // * If there are validation errors and they were attempting to publish, we can only save, NOT publish and display
+            //      a message indicating this
+            if (ModelState.IsValid == false)
+            {
+                if (ValidationHelper.ModelHasRequiredForPersistenceErrors(contentItem) && IsCreatingAction(contentItem.Action))
+                {
+                    //ok, so the absolute mandatory data is invalid and it's new, we cannot actually continue!
+                    // add the modelstate to the outgoing object and throw a validation message
+                    var forDisplay = AutoMapperExtensions.MapWithUmbracoContext<IContent, ContentItemDisplay>(contentItem.PersistedContent, UmbracoContext);
+                    forDisplay.Errors = ModelState.ToErrorDictionary();
+                    throw new HttpResponseException(Request.CreateValidationErrorResponse(forDisplay));
+
+                }
+
+                //if the model state is not valid we cannot publish so change it to save
+                switch (contentItem.Action)
+                {
+                    case ContentSaveAction.Publish:
+                        contentItem.Action = ContentSaveAction.Save;
+                        break;
+                    case ContentSaveAction.PublishNew:
+                        contentItem.Action = ContentSaveAction.SaveNew;
+                        break;
+                }
+            }
+
+            //initialize this to successful
+            var publishStatus = Attempt<PublishStatus>.Succeed();
+            var wasCancelled = false;   //tracks if the operation was cancelled
+            var noop = false;           //tracks if the operation performed no operation (nothing to save)
+
+            if (contentItem.Action == ContentSaveAction.Save || contentItem.Action == ContentSaveAction.SaveNew)
+            {
+                //save the item
+                var saveResult = saveMethod(contentItem.PersistedContent);
+
+                wasCancelled = saveResult.Success == false && saveResult.Result.StatusType == OperationStatusType.FailedCancelledByEvent;
+                noop = saveResult.Result.StatusType == OperationStatusType.NoOperation;
+            }
+            else if (contentItem.Action == ContentSaveAction.SendPublish || contentItem.Action == ContentSaveAction.SendPublishNew)
+            {
+                var sendResult = Services.ContentService.SendToPublication(contentItem.PersistedContent, Security.CurrentUser.Id);
+                wasCancelled = sendResult == false;
+            }
+            else
+            {
+                //publish the item and check if it worked, if not we will show a diff msg below
+                publishStatus = Services.ContentService.SaveAndPublishWithStatus(contentItem.PersistedContent, Security.CurrentUser.Id);
+                wasCancelled = publishStatus.Result.StatusType == PublishStatusType.FailedCancelledByEvent;
+            }
+
+            //return the updated model
+            var display = AutoMapperExtensions.MapWithUmbracoContext<IContent, ContentItemDisplay>(contentItem.PersistedContent, UmbracoContext);
+
+            //lasty, if it is not valid, add the modelstate to the outgoing object and throw a 403
+            HandleInvalidModelState(display);
+
+            //put the correct msgs in
+            switch (contentItem.Action)
+            {
+                case ContentSaveAction.Save:
+                case ContentSaveAction.SaveNew:
+                    if (wasCancelled)
+                    {
+                        AddCancelMessage(display);
+                        
+                    }
+                    else if (noop == false)
+                    {
+                        display.AddSuccessNotification(
+                            Services.TextService.Localize("speechBubbles/editContentSavedHeader"),
+                            contentItem.ReleaseDate.HasValue
+                                ? Services.TextService.Localize("speechBubbles/editContentSavedWithReleaseDateText", new[] { contentItem.ReleaseDate.Value.ToLongDateString(), contentItem.ReleaseDate.Value.ToShortTimeString() })
+                                : Services.TextService.Localize("speechBubbles/editContentSavedText")
+                        );
+                    }
+                    break;
+                case ContentSaveAction.SendPublish:
+                case ContentSaveAction.SendPublishNew:
+                    if (wasCancelled)
+                    {
+                        AddCancelMessage(display);
+                    }
+                    else if (noop == false)
+                    {
+                        display.AddSuccessNotification(
+                            Services.TextService.Localize("speechBubbles/editContentSendToPublish"),
+                            Services.TextService.Localize("speechBubbles/editContentSendToPublishText"));
+                    }
+
+                    break;
+                case ContentSaveAction.Publish:
+                case ContentSaveAction.PublishNew:
+                    ShowMessageForPublishStatus(publishStatus.Result, display, contentItem.ExpireDate);
+                    break;
+            }
+
+            //If the item is new and the operation was cancelled, we need to return a different
+            // status code so the UI can handle it since it won't be able to redirect since there
+            // is no Id to redirect to!
+            if (wasCancelled && IsCreatingAction(contentItem.Action))
+            {
+                throw new HttpResponseException(Request.CreateValidationErrorResponse(display));
+            }
+
+            display.PersistedContent = contentItem.PersistedContent;
+
+            return display;
+        }
+
+        /// <summary>
+        /// Publishes a document with a given ID
+        /// </summary>
+        /// <param name="id"></param>
+        /// <returns></returns>
+        /// <remarks>
+        /// The CanAccessContentAuthorize attribute will deny access to this method if the current user
+        /// does not have Publish access to this node.
+        /// </remarks>
+        ///
+        [EnsureUserPermissionForContent("id", 'U')]
+        public HttpResponseMessage PostPublishById(int id)
+        {
+            var foundContent = GetObjectFromRequest(() => Services.ContentService.GetById(id));
+
+            if (foundContent == null)
+            {
+                return HandleContentNotFound(id, false);
+            }
+
+            var publishResult = Services.ContentService.PublishWithStatus(foundContent, Security.CurrentUser.Id);
+            if (publishResult.Success == false)
+            {
+                var notificationModel = new SimpleNotificationModel();
+                ShowMessageForPublishStatus(publishResult.Result, notificationModel, foundContent.ExpireDate);
+                return Request.CreateValidationErrorResponse(notificationModel);
+            }
+
+            //return ok
+            return Request.CreateResponse(HttpStatusCode.OK);
+
+        }
+
+        [HttpDelete]
+        [HttpPost]
+        public HttpResponseMessage DeleteBlueprint(int id)
+        {
+            var found = Services.ContentService.GetBlueprintById(id);
+
+            if (found == null)
+            {
+                return HandleContentNotFound(id, false);
+            }
+
+            Services.ContentService.DeleteBlueprint(found);
+
+            return Request.CreateResponse(HttpStatusCode.OK);
+        }
+
+        /// <summary>
+        /// Moves an item to the recycle bin, if it is already there then it will permanently delete it
+        /// </summary>
+        /// <param name="id"></param>
+        /// <returns></returns>
+        /// <remarks>
+        /// The CanAccessContentAuthorize attribute will deny access to this method if the current user
+        /// does not have Delete access to this node.
+        /// </remarks>
+        [EnsureUserPermissionForContent("id", 'D')]
+        [HttpDelete]
+        [HttpPost]
+        public HttpResponseMessage DeleteById(int id)
+        {
+            var foundContent = GetObjectFromRequest(() => Services.ContentService.GetById(id));
+
+            if (foundContent == null)
+            {
+                return HandleContentNotFound(id, false);
+            }
+
+            //if the current item is in the recycle bin
+            if (foundContent.IsInRecycleBin() == false)
+            {
+                var moveResult = Services.ContentService.WithResult().MoveToRecycleBin(foundContent, Security.CurrentUser.Id);
+                if (moveResult == false)
+                {
+                    //returning an object of INotificationModel will ensure that any pending
+                    // notification messages are added to the response.
+                    return Request.CreateValidationErrorResponse(new SimpleNotificationModel());
+                }
+            }
+            else
+            {
+                var deleteResult = Services.ContentService.WithResult().Delete(foundContent, Security.CurrentUser.Id);
+                if (deleteResult == false)
+                {
+                    //returning an object of INotificationModel will ensure that any pending
+                    // notification messages are added to the response.
+                    return Request.CreateValidationErrorResponse(new SimpleNotificationModel());
+                }
+            }
+
+            return Request.CreateResponse(HttpStatusCode.OK);
+        }
+
+        /// <summary>
+        /// Empties the recycle bin
+        /// </summary>
+        /// <returns></returns>
+        /// <remarks>
+        /// attributed with EnsureUserPermissionForContent to verify the user has access to the recycle bin
+        /// </remarks>
+        [HttpDelete]
+        [HttpPost]
+        [EnsureUserPermissionForContent(Constants.System.RecycleBinContent, 'D')]
+        public HttpResponseMessage EmptyRecycleBin()
+        {
+            Services.ContentService.EmptyRecycleBin(Security.CurrentUser.Id);
+
+            return Request.CreateNotificationSuccessResponse(Services.TextService.Localize("defaultdialogs/recycleBinIsEmpty"));
+        }
+
+        /// <summary>
+        /// Change the sort order for content
+        /// </summary>
+        /// <param name="sorted"></param>
+        /// <returns></returns>
+        [EnsureUserPermissionForContent("sorted.ParentId", 'S')]
+        public HttpResponseMessage PostSort(ContentSortOrder sorted)
+        {
+            if (sorted == null)
+            {
+                return Request.CreateResponse(HttpStatusCode.NotFound);
+            }
+
+            //if there's nothing to sort just return ok
+            if (sorted.IdSortOrder.Length == 0)
+            {
+                return Request.CreateResponse(HttpStatusCode.OK);
+            }
+
+            try
+            {
+                var contentService = Services.ContentService;
+
+                // Save content with new sort order and update content xml in db accordingly
+                if (contentService.Sort(sorted.IdSortOrder, Security.CurrentUser.Id) == false)
+                {
+                    LogHelper.Warn<ContentController>("Content sorting failed, this was probably caused by an event being cancelled");
+                    return Request.CreateValidationErrorResponse("Content sorting failed, this was probably caused by an event being cancelled");
+                }
+                return Request.CreateResponse(HttpStatusCode.OK);
+            }
+            catch (Exception ex)
+            {
+                LogHelper.Error<ContentController>("Could not update content sort order", ex);
+                throw;
+            }
+        }
+
+        /// <summary>
+        /// Change the sort order for media
+        /// </summary>
+        /// <param name="move"></param>
+        /// <returns></returns>
+        [EnsureUserPermissionForContent("move.ParentId", 'M')]
+        public HttpResponseMessage PostMove(MoveOrCopy move)
+        {
+            var toMove = ValidateMoveOrCopy(move);
+
+            Services.ContentService.Move(toMove, move.ParentId, Security.CurrentUser.Id);
+
+            var response = Request.CreateResponse(HttpStatusCode.OK);
+            response.Content = new StringContent(toMove.Path, Encoding.UTF8, "application/json");
+            return response;
+        }
+
+        /// <summary>
+        /// Copies a content item and places the copy as a child of a given parent Id
+        /// </summary>
+        /// <param name="copy"></param>
+        /// <returns></returns>
+        [EnsureUserPermissionForContent("copy.ParentId", 'C')]
+        public HttpResponseMessage PostCopy(MoveOrCopy copy)
+        {
+            var toCopy = ValidateMoveOrCopy(copy);
+
+            var c = Services.ContentService.Copy(toCopy, copy.ParentId, copy.RelateToOriginal, copy.Recursive, Security.CurrentUser.Id);
+
+            var response = Request.CreateResponse(HttpStatusCode.OK);
+            response.Content = new StringContent(c.Path, Encoding.UTF8, "application/json");
+            return response;
+        }
+
+        /// <summary>
+        /// Unpublishes a node with a given Id and returns the unpublished entity
+        /// </summary>
+        /// <param name="id"></param>
+        /// <returns></returns>
+        [EnsureUserPermissionForContent("id", 'U')]
+        [OutgoingEditorModelEvent]
+        public ContentItemDisplay PostUnPublish(int id)
+        {
+            var foundContent = GetObjectFromRequest(() => Services.ContentService.GetById(id));
+
+            if (foundContent == null)
+                HandleContentNotFound(id);
+
+            var unpublishResult = Services.ContentService.WithResult().UnPublish(foundContent, Security.CurrentUser.Id);
+
+            var content = AutoMapperExtensions.MapWithUmbracoContext<IContent, ContentItemDisplay>(foundContent, UmbracoContext);
+
+            if (unpublishResult == false)
+            {
+                AddCancelMessage(content);
+                throw new HttpResponseException(Request.CreateValidationErrorResponse(content));
+            }
+            else
+            {
+                content.AddSuccessNotification(Services.TextService.Localize("content/unPublish"), Services.TextService.Localize("speechBubbles/contentUnpublished"));
+                return content;
+            }
+        }
+
+        /// <summary>
+        /// Maps the dto property values to the persisted model
+        /// </summary>
+        /// <param name="contentItem"></param>
+        private void MapPropertyValues(ContentItemSave contentItem)
+        {
+            UpdateName(contentItem);
+
+            //TODO: We need to support 'send to publish'
+
+            contentItem.PersistedContent.ExpireDate = contentItem.ExpireDate;
+            contentItem.PersistedContent.ReleaseDate = contentItem.ReleaseDate;
+            //only set the template if it didn't change
+            var templateChanged = (contentItem.PersistedContent.Template == null && contentItem.TemplateAlias.IsNullOrWhiteSpace() == false)
+                                                        || (contentItem.PersistedContent.Template != null && contentItem.PersistedContent.Template.Alias != contentItem.TemplateAlias)
+                                                        || (contentItem.PersistedContent.Template != null && contentItem.TemplateAlias.IsNullOrWhiteSpace());
+            if (templateChanged)
+            {
+                var template = Services.FileService.GetTemplate(contentItem.TemplateAlias);
+                if (template == null && contentItem.TemplateAlias.IsNullOrWhiteSpace() == false)
+                {
+                    //ModelState.AddModelError("Template", "No template exists with the specified alias: " + contentItem.TemplateAlias);
+                    LogHelper.Warn<ContentController>("No template exists with the specified alias: " + contentItem.TemplateAlias);
+                }
+                else
+                {
+                    //NOTE: this could be null if there was a template and the posted template is null, this should remove the assigned template
+                    contentItem.PersistedContent.Template = template;
+                }
+            }
+
+            base.MapPropertyValues(contentItem);
+        }
+
+        /// <summary>
+        /// Ensures the item can be moved/copied to the new location
+        /// </summary>
+        /// <param name="model"></param>
+        /// <returns></returns>
+        private IContent ValidateMoveOrCopy(MoveOrCopy model)
+        {
+            if (model == null)
+            {
+                throw new HttpResponseException(HttpStatusCode.NotFound);
+            }
+
+            var contentService = Services.ContentService;
+            var toMove = contentService.GetById(model.Id);
+            if (toMove == null)
+            {
+                throw new HttpResponseException(HttpStatusCode.NotFound);
+            }
+            if (model.ParentId < 0)
+            {
+                //cannot move if the content item is not allowed at the root
+                if (toMove.ContentType.AllowedAsRoot == false)
+                {
+                    throw new HttpResponseException(
+                            Request.CreateNotificationValidationErrorResponse(
+                                    Services.TextService.Localize("moveOrCopy/notAllowedAtRoot")));
+                }
+            }
+            else
+            {
+                var parent = contentService.GetById(model.ParentId);
+                if (parent == null)
+                {
+                    throw new HttpResponseException(HttpStatusCode.NotFound);
+                }
+
+                //check if the item is allowed under this one
+                if (parent.ContentType.AllowedContentTypes.Select(x => x.Id).ToArray()
+                        .Any(x => x.Value == toMove.ContentType.Id) == false)
+                {
+                    throw new HttpResponseException(
+                            Request.CreateNotificationValidationErrorResponse(
+                                    Services.TextService.Localize("moveOrCopy/notAllowedByContentType")));
+                }
+
+                // Check on paths
+                if ((string.Format(",{0},", parent.Path)).IndexOf(string.Format(",{0},", toMove.Id), StringComparison.Ordinal) > -1)
+                {
+                    throw new HttpResponseException(
+                            Request.CreateNotificationValidationErrorResponse(
+                                    Services.TextService.Localize("moveOrCopy/notAllowedByPath")));
+                }
+            }
+
+            return toMove;
+        }
+
+        private void ShowMessageForPublishStatus(PublishStatus status, INotificationModel display, DateTime? expireDate)
+        {
+            switch (status.StatusType)
+            {
+                case PublishStatusType.Success:
+                case PublishStatusType.SuccessAlreadyPublished:
+                    display.AddSuccessNotification(
+                            Services.TextService.Localize("speechBubbles/editContentPublishedHeader"),
+                            expireDate.HasValue
+                                ? Services.TextService.Localize("speechBubbles/editContentPublishedWithExpireDateText", new [] { expireDate.Value.ToLongDateString(), expireDate.Value.ToShortTimeString() })
+                                : Services.TextService.Localize("speechBubbles/editContentPublishedText")
+                    );
+                    break;
+                case PublishStatusType.FailedPathNotPublished:
+                    display.AddWarningNotification(
+                            Services.TextService.Localize("publish"),
+                            Services.TextService.Localize("publish/contentPublishedFailedByParent",
+                                    new[] { string.Format("{0} ({1})", status.ContentItem.Name, status.ContentItem.Id) }).Trim());
+                    break;
+                case PublishStatusType.FailedCancelledByEvent:
+                    AddCancelMessage(display, "publish", "speechBubbles/contentPublishedFailedByEvent");
+                    break;
+                case PublishStatusType.FailedAwaitingRelease:
+                    display.AddWarningNotification(
+                            Services.TextService.Localize("publish"),
+                            Services.TextService.Localize("publish/contentPublishedFailedAwaitingRelease",
+                                    new[] { string.Format("{0} ({1})", status.ContentItem.Name, status.ContentItem.Id) }).Trim());
+                    break;
+                case PublishStatusType.FailedHasExpired:
+                    display.AddWarningNotification(
+                            Services.TextService.Localize("publish"),
+                            Services.TextService.Localize("publish/contentPublishedFailedExpired",
+                                    new[]
+                                    {
+                                                                string.Format("{0} ({1})", status.ContentItem.Name, status.ContentItem.Id),
+                                    }).Trim());
+                    break;
+                case PublishStatusType.FailedIsTrashed:
+                    //TODO: We should add proper error messaging for this!
+                    break;
+                case PublishStatusType.FailedContentInvalid:
+                    display.AddWarningNotification(
+                            Services.TextService.Localize("publish"),
+                            Services.TextService.Localize("publish/contentPublishedFailedInvalid",
+                                    new[]
+                                    {
+                                                                string.Format("{0} ({1})", status.ContentItem.Name, status.ContentItem.Id),
+                                                                string.Join(",", status.InvalidProperties.Select(x => x.Alias))
+                                    }).Trim());
+                    break;
+                default:
+                    throw new IndexOutOfRangeException();
+            }
+        }
+
+
+        /// <summary>
+        /// Performs a permissions check for the user to check if it has access to the node based on
+        /// start node and/or permissions for the node
+        /// </summary>
+        /// <param name="storage">The storage to add the content item to so it can be reused</param>
+        /// <param name="user"></param>
+        /// <param name="userService"></param>
+        /// <param name="contentService"></param>
+        /// <param name="entityService"></param>
+        /// <param name="nodeId">The content to lookup, if the contentItem is not specified</param>
+        /// <param name="permissionsToCheck"></param>
+        /// <param name="contentItem">Specifies the already resolved content item to check against</param>
+        /// <returns></returns>
+        internal static bool CheckPermissions(
+                IDictionary<string, object> storage,
+                IUser user,
+                IUserService userService,
+                IContentService contentService,
+                IEntityService entityService,
+                int nodeId,
+                char[] permissionsToCheck = null,
+                IContent contentItem = null)
+        {
+            if (storage == null) throw new ArgumentNullException("storage");
+            if (user == null) throw new ArgumentNullException("user");
+            if (userService == null) throw new ArgumentNullException("userService");
+            if (contentService == null) throw new ArgumentNullException("contentService");
+            if (entityService == null) throw new ArgumentNullException("entityService");
+
+            if (contentItem == null && nodeId != Constants.System.Root && nodeId != Constants.System.RecycleBinContent)
+            {
+                contentItem = contentService.GetById(nodeId);
+                //put the content item into storage so it can be retreived
+                // in the controller (saves a lookup)
+                storage[typeof(IContent).ToString()] = contentItem;
+            }
+
+            if (contentItem == null && nodeId != Constants.System.Root && nodeId != Constants.System.RecycleBinContent)
+            {
+                throw new HttpResponseException(HttpStatusCode.NotFound);
+            }
+
+            var hasPathAccess = (nodeId == Constants.System.Root)
+                ? user.HasContentRootAccess(entityService)
+                : (nodeId == Constants.System.RecycleBinContent)
+                    ? user.HasContentBinAccess(entityService)
+                    : user.HasPathAccess(contentItem, entityService);
+
+            if (hasPathAccess == false)
+            {
+                return false;
+            }
+
+            if (permissionsToCheck == null || permissionsToCheck.Length == 0)
+            {
+                return true;
+            }
+
+            //get the implicit/inherited permissions for the user for this path,
+            //if there is no content item for this id, than just use the id as the path (i.e. -1 or -20)
+            var path = contentItem != null ? contentItem.Path : nodeId.ToString();
+            var permission = userService.GetPermissionsForPath(user, path);
+
+            var allowed = true;
+            foreach (var p in permissionsToCheck)
+            {
+                if (permission == null
+                    || permission.GetAllPermissions().Contains(p.ToString(CultureInfo.InvariantCulture)) == false)
+                {
+                    allowed = false;
+                }
+            }
+            return allowed;
+        }
+
+        [EnsureUserPermissionForContent("contentId", 'F')]
+        public IEnumerable<NotifySetting> GetNotificationOptions(int contentId)
+        {
+            var notifications = new List<NotifySetting>();
+            if (contentId <= 0) throw new HttpResponseException(Request.CreateResponse(HttpStatusCode.NotFound));
+
+            var content = Services.ContentService.GetById(contentId);
+            if (content == null) throw new HttpResponseException(Request.CreateResponse(HttpStatusCode.NotFound));
+
+            var actionList = ActionsResolver.Current.Actions;
+            foreach (var a in actionList)
+            {
+                if (a.ShowInNotifier)
+                {
+                    NotifySetting n = new NotifySetting
+                    {
+                        Name = ui.Text("actions", a.Alias),
+                        Checked = (UmbracoUser.GetNotifications(content.Path).IndexOf(a.Letter) > -1),
+                        NotifyCode = a.Letter.ToString()
+                    };
+                    notifications.Add(n);
+                }
+            }
+            return notifications;
+        }
+
+        public void PostNotificationOptions(int contentId, string notifyOptions = "")
+        {
+            if (contentId <= 0) throw new HttpResponseException(Request.CreateResponse(HttpStatusCode.NotFound));
+            var content = Services.ContentService.GetById(contentId);
+
+            if (content == null) throw new HttpResponseException(Request.CreateResponse(HttpStatusCode.NotFound));
+            var node = new CMSNode(contentId);
+
+            global::umbraco.cms.businesslogic.workflow.Notification.UpdateNotifications(UmbracoUser, node, notifyOptions ?? "");
+        }
+    }
+}

From b4495d0ae5142d0e6cb02c09b1bcabe3b8091dc3 Mon Sep 17 00:00:00 2001
From: martin j griffiths <martin.griffiths@lcp.uk.com>
Date: Thu, 19 Sep 2019 10:30:51 +0100
Subject: [PATCH 11/14] Update rte.controller.js

Fix issue where an embedded macro prevents editor from returning to pristine/valid after a publish
---
 .../src/views/propertyeditors/rte/rte.controller.js          | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/src/Umbraco.Web.UI.Client/src/views/propertyeditors/rte/rte.controller.js b/src/Umbraco.Web.UI.Client/src/views/propertyeditors/rte/rte.controller.js
index 109aa37fbb..eb049ea1b3 100644
--- a/src/Umbraco.Web.UI.Client/src/views/propertyeditors/rte/rte.controller.js
+++ b/src/Umbraco.Web.UI.Client/src/views/propertyeditors/rte/rte.controller.js
@@ -257,7 +257,10 @@ angular.module("umbraco")
                     // Update model on change, i.e. copy/pasted text, plugins altering content
                     editor.on('SetContent', function (e) {
                         if (!e.initial) {
-                            syncContent(editor);
+                              // sync content if editor is dirty
+                              if (!editor.isNotDirty) {
+                                syncContent(editor);
+                            }
                         }
                     });
 

From 4535885bdb4598031a5b5bd7ec5abe22d24532af Mon Sep 17 00:00:00 2001
From: martin j griffiths <martin.griffiths@lcp.uk.com>
Date: Thu, 19 Sep 2019 10:30:51 +0100
Subject: [PATCH 12/14] Update rte.controller.js

Fix issue where an embedded macro prevents editor from returning to pristine/valid after a publish

(cherry picked from commit b4495d0ae5142d0e6cb02c09b1bcabe3b8091dc3)
---
 .../src/views/propertyeditors/rte/rte.controller.js          | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/src/Umbraco.Web.UI.Client/src/views/propertyeditors/rte/rte.controller.js b/src/Umbraco.Web.UI.Client/src/views/propertyeditors/rte/rte.controller.js
index 109aa37fbb..eb049ea1b3 100644
--- a/src/Umbraco.Web.UI.Client/src/views/propertyeditors/rte/rte.controller.js
+++ b/src/Umbraco.Web.UI.Client/src/views/propertyeditors/rte/rte.controller.js
@@ -257,7 +257,10 @@ angular.module("umbraco")
                     // Update model on change, i.e. copy/pasted text, plugins altering content
                     editor.on('SetContent', function (e) {
                         if (!e.initial) {
-                            syncContent(editor);
+                              // sync content if editor is dirty
+                              if (!editor.isNotDirty) {
+                                syncContent(editor);
+                            }
                         }
                     });
 

From 98e39ed3ef3277216df9c423494ecbc1d259476c Mon Sep 17 00:00:00 2001
From: stevemegson <steve@megson.org>
Date: Fri, 20 Sep 2019 10:38:44 +0100
Subject: [PATCH 13/14] V7: Error upgrading due to SecurityStamp being null
 (#6343)

* Allow login with a null SecurityStamp when upgrading

* Added migration to fill in missing SecurityStamp

* Make sure we initialize UmbracoContext as it is needed in some tests that use UmbracoBackOfficeIdentity.AddUserDataClaims

* Moved check for null SecurityStamp

* Generate new SecurityStamp in C#

* Bump version to 7.15.4
---
 src/SolutionInfo.cs                           |  4 ++--
 .../Configuration/UmbracoVersion.cs           |  2 +-
 .../PopulateMissingSecurityStamps.cs          | 24 +++++++++++++++++++
 .../Security/UmbracoBackOfficeIdentity.cs     |  8 +++++++
 src/Umbraco.Core/Umbraco.Core.csproj          |  1 +
 .../UmbracoBackOfficeIdentityTests.cs         | 22 ++++++++++++++++-
 src/Umbraco.Web.UI/Umbraco.Web.UI.csproj      |  4 ++--
 7 files changed, 59 insertions(+), 6 deletions(-)
 create mode 100644 src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSevenFifteenFour/PopulateMissingSecurityStamps.cs

diff --git a/src/SolutionInfo.cs b/src/SolutionInfo.cs
index 97ebd98e8c..b5a8fbc738 100644
--- a/src/SolutionInfo.cs
+++ b/src/SolutionInfo.cs
@@ -11,5 +11,5 @@ using System.Resources;
 
 [assembly: AssemblyVersion("1.0.*")]
 
-[assembly: AssemblyFileVersion("7.15.3")]
-[assembly: AssemblyInformationalVersion("7.15.3")]
+[assembly: AssemblyFileVersion("7.15.4")]
+[assembly: AssemblyInformationalVersion("7.15.4")]
diff --git a/src/Umbraco.Core/Configuration/UmbracoVersion.cs b/src/Umbraco.Core/Configuration/UmbracoVersion.cs
index 8c8755577a..65bd4f8694 100644
--- a/src/Umbraco.Core/Configuration/UmbracoVersion.cs
+++ b/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.15.3");
+        private static readonly Version Version = new Version("7.15.4");
 
         /// <summary>
         /// Gets the current version of Umbraco.
diff --git a/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSevenFifteenFour/PopulateMissingSecurityStamps.cs b/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSevenFifteenFour/PopulateMissingSecurityStamps.cs
new file mode 100644
index 0000000000..042a003c75
--- /dev/null
+++ b/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSevenFifteenFour/PopulateMissingSecurityStamps.cs
@@ -0,0 +1,24 @@
+using System;
+using Umbraco.Core.Logging;
+using Umbraco.Core.Persistence.SqlSyntax;
+
+namespace Umbraco.Core.Persistence.Migrations.Upgrades.TargetVersionSevenFifteenFour
+{
+    [Migration("7.15.4", 1, Constants.System.UmbracoMigrationName)]
+    public class PopulateMissingSecurityStamps : MigrationBase
+    {
+        public PopulateMissingSecurityStamps(ISqlSyntaxProvider sqlSyntax, ILogger logger) : base(sqlSyntax, logger)
+        {
+        }
+
+        public override void Up()
+        {
+            // A user with a NULL securityStampToken can't log in after v7.8.0
+            Execute.Sql($@"UPDATE umbracoUser SET securityStampToken = '{Guid.NewGuid().ToString()}' WHERE securityStampToken IS NULL");
+        }
+
+        public override void Down()
+        {
+        }
+    }
+}
diff --git a/src/Umbraco.Core/Security/UmbracoBackOfficeIdentity.cs b/src/Umbraco.Core/Security/UmbracoBackOfficeIdentity.cs
index fcb5547027..7772b198c6 100644
--- a/src/Umbraco.Core/Security/UmbracoBackOfficeIdentity.cs
+++ b/src/Umbraco.Core/Security/UmbracoBackOfficeIdentity.cs
@@ -115,6 +115,12 @@ namespace Umbraco.Core.Security
                 AddClaim(new Claim(ClaimTypes.CookiePath, "/", ClaimValueTypes.String, Issuer, Issuer, this));
             }
 
+            // if upgrading from a pre-7.3.0 version, SecurityStamp will be null
+            if (userdata.SecurityStamp == null && ApplicationContext.Current.IsUpgrading)
+            {
+                userdata.SecurityStamp = Guid.NewGuid().ToString();
+            }
+
             _currentIssuer = claimsIdentity.AuthenticationType;
             UserData = userdata;
             AddExistingClaims(claimsIdentity);
@@ -227,7 +233,9 @@ namespace Umbraco.Core.Security
             //The security stamp claim is also required... this is because this claim type is hard coded
             // by the SecurityStampValidator, see: https://katanaproject.codeplex.com/workitem/444
             if (HasClaim(x => x.Type == Microsoft.AspNet.Identity.Constants.DefaultSecurityStampClaimType) == false)
+            {
                 AddClaim(new Claim(Microsoft.AspNet.Identity.Constants.DefaultSecurityStampClaimType, SecurityStamp, ClaimValueTypes.String, Issuer, Issuer, this));
+            }
 
             //Add each app as a separate claim
             if (HasClaim(x => x.Type == Constants.Security.AllowedApplicationsClaimType) == false)
diff --git a/src/Umbraco.Core/Umbraco.Core.csproj b/src/Umbraco.Core/Umbraco.Core.csproj
index 3b5d0aaff6..fe822e10bc 100644
--- a/src/Umbraco.Core/Umbraco.Core.csproj
+++ b/src/Umbraco.Core/Umbraco.Core.csproj
@@ -576,6 +576,7 @@
     <Compile Include="Persistence\Migrations\Upgrades\TargetVersionSevenEightZero\AddInstructionCountColumn.cs" />
     <Compile Include="Persistence\Migrations\Upgrades\TargetVersionSevenEightZero\AddCmsMediaTable.cs" />
     <Compile Include="Persistence\Migrations\Upgrades\TargetVersionSevenEightZero\AddUserLoginTable.cs" />
+    <Compile Include="Persistence\Migrations\Upgrades\TargetVersionSevenFifteenFour\PopulateMissingSecurityStamps.cs" />
     <Compile Include="Persistence\Migrations\Upgrades\TargetVersionSevenFourteenZero\UpdateMemberGroupPickerData.cs" />
     <Compile Include="Persistence\Migrations\Upgrades\TargetVersionSevenTwelveZero\RenameTrueFalseField.cs" />
     <Compile Include="Persistence\Migrations\Upgrades\TargetVersionSevenTwelveZero\SetDefaultTagsStorageType.cs" />
diff --git a/src/Umbraco.Tests/Security/UmbracoBackOfficeIdentityTests.cs b/src/Umbraco.Tests/Security/UmbracoBackOfficeIdentityTests.cs
index d9ab9c9a3d..950c2b898f 100644
--- a/src/Umbraco.Tests/Security/UmbracoBackOfficeIdentityTests.cs
+++ b/src/Umbraco.Tests/Security/UmbracoBackOfficeIdentityTests.cs
@@ -4,9 +4,14 @@ using System.Security.Claims;
 using System.Text;
 using System.Threading.Tasks;
 using System.Web.Security;
+using Moq;
 using Newtonsoft.Json;
 using NUnit.Framework;
 using Umbraco.Core;
+using Umbraco.Core.Logging;
+using Umbraco.Core.Persistence.SqlSyntax;
+using Umbraco.Core.Profiling;
+using Umbraco.Core.Scoping;
 using Umbraco.Core.Security;
 using Umbraco.Core.Services;
 
@@ -15,9 +20,24 @@ namespace Umbraco.Tests.Security
     [TestFixture]
     public class UmbracoBackOfficeIdentityTests
     {
-
         public const string TestIssuer = "TestIssuer";
 
+        [SetUp]
+        public void Initialize()
+        {
+            var sqlSyntax = new SqlCeSyntaxProvider();
+
+            //This is needed because the Migration resolver is creating migration instances with their full ctors
+            ApplicationContext.EnsureContext(
+                new ApplicationContext(
+                    new DatabaseContext(Mock.Of<IScopeProviderInternal>(), Mock.Of<ILogger>(), sqlSyntax, "test"),
+                    new ServiceContext(),
+                    CacheHelper.CreateDisabledCacheHelper(),
+                    new ProfilingLogger(Mock.Of<ILogger>(), Mock.Of<IProfiler>())),
+                true);
+        }
+
+
         [Test]
         public void Create_From_Claims_Identity()
         {
diff --git a/src/Umbraco.Web.UI/Umbraco.Web.UI.csproj b/src/Umbraco.Web.UI/Umbraco.Web.UI.csproj
index 76d2765672..3e0ce457e1 100644
--- a/src/Umbraco.Web.UI/Umbraco.Web.UI.csproj
+++ b/src/Umbraco.Web.UI/Umbraco.Web.UI.csproj
@@ -1028,9 +1028,9 @@ xcopy "$(ProjectDir)"..\packages\SqlServerCE.4.0.0.1\x86\*.* "$(TargetDir)x86\"
         <WebProjectProperties>
           <UseIIS>True</UseIIS>
           <AutoAssignPort>True</AutoAssignPort>
-          <DevelopmentServerPort>7153</DevelopmentServerPort>
+          <DevelopmentServerPort>7154</DevelopmentServerPort>
           <DevelopmentServerVPath>/</DevelopmentServerVPath>
-          <IISUrl>http://localhost:7153</IISUrl>
+          <IISUrl>http://localhost:7154</IISUrl>
           <NTLMAuthentication>False</NTLMAuthentication>
           <UseCustomServer>False</UseCustomServer>
           <CustomServerUrl>

From 2adb6636bd2bb122d711293ff1ba17f5e1a01761 Mon Sep 17 00:00:00 2001
From: stevemegson <steve@megson.org>
Date: Fri, 20 Sep 2019 10:38:44 +0100
Subject: [PATCH 14/14] V7: Error upgrading due to SecurityStamp being null
 (#6343)

* Allow login with a null SecurityStamp when upgrading

* Added migration to fill in missing SecurityStamp

* Make sure we initialize UmbracoContext as it is needed in some tests that use UmbracoBackOfficeIdentity.AddUserDataClaims

* Moved check for null SecurityStamp

* Generate new SecurityStamp in C#

* Bump version to 7.15.4
---
 src/SolutionInfo.cs                           |  4 ++--
 .../Configuration/UmbracoVersion.cs           |  2 +-
 .../PopulateMissingSecurityStamps.cs          | 24 +++++++++++++++++++
 .../Security/UmbracoBackOfficeIdentity.cs     |  8 +++++++
 src/Umbraco.Core/Umbraco.Core.csproj          |  1 +
 .../UmbracoBackOfficeIdentityTests.cs         | 22 ++++++++++++++++-
 src/Umbraco.Web.UI/Umbraco.Web.UI.csproj      |  4 ++--
 7 files changed, 59 insertions(+), 6 deletions(-)
 create mode 100644 src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSevenFifteenFour/PopulateMissingSecurityStamps.cs

diff --git a/src/SolutionInfo.cs b/src/SolutionInfo.cs
index 97ebd98e8c..b5a8fbc738 100644
--- a/src/SolutionInfo.cs
+++ b/src/SolutionInfo.cs
@@ -11,5 +11,5 @@ using System.Resources;
 
 [assembly: AssemblyVersion("1.0.*")]
 
-[assembly: AssemblyFileVersion("7.15.3")]
-[assembly: AssemblyInformationalVersion("7.15.3")]
+[assembly: AssemblyFileVersion("7.15.4")]
+[assembly: AssemblyInformationalVersion("7.15.4")]
diff --git a/src/Umbraco.Core/Configuration/UmbracoVersion.cs b/src/Umbraco.Core/Configuration/UmbracoVersion.cs
index 8c8755577a..65bd4f8694 100644
--- a/src/Umbraco.Core/Configuration/UmbracoVersion.cs
+++ b/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.15.3");
+        private static readonly Version Version = new Version("7.15.4");
 
         /// <summary>
         /// Gets the current version of Umbraco.
diff --git a/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSevenFifteenFour/PopulateMissingSecurityStamps.cs b/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSevenFifteenFour/PopulateMissingSecurityStamps.cs
new file mode 100644
index 0000000000..042a003c75
--- /dev/null
+++ b/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSevenFifteenFour/PopulateMissingSecurityStamps.cs
@@ -0,0 +1,24 @@
+using System;
+using Umbraco.Core.Logging;
+using Umbraco.Core.Persistence.SqlSyntax;
+
+namespace Umbraco.Core.Persistence.Migrations.Upgrades.TargetVersionSevenFifteenFour
+{
+    [Migration("7.15.4", 1, Constants.System.UmbracoMigrationName)]
+    public class PopulateMissingSecurityStamps : MigrationBase
+    {
+        public PopulateMissingSecurityStamps(ISqlSyntaxProvider sqlSyntax, ILogger logger) : base(sqlSyntax, logger)
+        {
+        }
+
+        public override void Up()
+        {
+            // A user with a NULL securityStampToken can't log in after v7.8.0
+            Execute.Sql($@"UPDATE umbracoUser SET securityStampToken = '{Guid.NewGuid().ToString()}' WHERE securityStampToken IS NULL");
+        }
+
+        public override void Down()
+        {
+        }
+    }
+}
diff --git a/src/Umbraco.Core/Security/UmbracoBackOfficeIdentity.cs b/src/Umbraco.Core/Security/UmbracoBackOfficeIdentity.cs
index fcb5547027..7772b198c6 100644
--- a/src/Umbraco.Core/Security/UmbracoBackOfficeIdentity.cs
+++ b/src/Umbraco.Core/Security/UmbracoBackOfficeIdentity.cs
@@ -115,6 +115,12 @@ namespace Umbraco.Core.Security
                 AddClaim(new Claim(ClaimTypes.CookiePath, "/", ClaimValueTypes.String, Issuer, Issuer, this));
             }
 
+            // if upgrading from a pre-7.3.0 version, SecurityStamp will be null
+            if (userdata.SecurityStamp == null && ApplicationContext.Current.IsUpgrading)
+            {
+                userdata.SecurityStamp = Guid.NewGuid().ToString();
+            }
+
             _currentIssuer = claimsIdentity.AuthenticationType;
             UserData = userdata;
             AddExistingClaims(claimsIdentity);
@@ -227,7 +233,9 @@ namespace Umbraco.Core.Security
             //The security stamp claim is also required... this is because this claim type is hard coded
             // by the SecurityStampValidator, see: https://katanaproject.codeplex.com/workitem/444
             if (HasClaim(x => x.Type == Microsoft.AspNet.Identity.Constants.DefaultSecurityStampClaimType) == false)
+            {
                 AddClaim(new Claim(Microsoft.AspNet.Identity.Constants.DefaultSecurityStampClaimType, SecurityStamp, ClaimValueTypes.String, Issuer, Issuer, this));
+            }
 
             //Add each app as a separate claim
             if (HasClaim(x => x.Type == Constants.Security.AllowedApplicationsClaimType) == false)
diff --git a/src/Umbraco.Core/Umbraco.Core.csproj b/src/Umbraco.Core/Umbraco.Core.csproj
index 3b5d0aaff6..fe822e10bc 100644
--- a/src/Umbraco.Core/Umbraco.Core.csproj
+++ b/src/Umbraco.Core/Umbraco.Core.csproj
@@ -576,6 +576,7 @@
     <Compile Include="Persistence\Migrations\Upgrades\TargetVersionSevenEightZero\AddInstructionCountColumn.cs" />
     <Compile Include="Persistence\Migrations\Upgrades\TargetVersionSevenEightZero\AddCmsMediaTable.cs" />
     <Compile Include="Persistence\Migrations\Upgrades\TargetVersionSevenEightZero\AddUserLoginTable.cs" />
+    <Compile Include="Persistence\Migrations\Upgrades\TargetVersionSevenFifteenFour\PopulateMissingSecurityStamps.cs" />
     <Compile Include="Persistence\Migrations\Upgrades\TargetVersionSevenFourteenZero\UpdateMemberGroupPickerData.cs" />
     <Compile Include="Persistence\Migrations\Upgrades\TargetVersionSevenTwelveZero\RenameTrueFalseField.cs" />
     <Compile Include="Persistence\Migrations\Upgrades\TargetVersionSevenTwelveZero\SetDefaultTagsStorageType.cs" />
diff --git a/src/Umbraco.Tests/Security/UmbracoBackOfficeIdentityTests.cs b/src/Umbraco.Tests/Security/UmbracoBackOfficeIdentityTests.cs
index d9ab9c9a3d..950c2b898f 100644
--- a/src/Umbraco.Tests/Security/UmbracoBackOfficeIdentityTests.cs
+++ b/src/Umbraco.Tests/Security/UmbracoBackOfficeIdentityTests.cs
@@ -4,9 +4,14 @@ using System.Security.Claims;
 using System.Text;
 using System.Threading.Tasks;
 using System.Web.Security;
+using Moq;
 using Newtonsoft.Json;
 using NUnit.Framework;
 using Umbraco.Core;
+using Umbraco.Core.Logging;
+using Umbraco.Core.Persistence.SqlSyntax;
+using Umbraco.Core.Profiling;
+using Umbraco.Core.Scoping;
 using Umbraco.Core.Security;
 using Umbraco.Core.Services;
 
@@ -15,9 +20,24 @@ namespace Umbraco.Tests.Security
     [TestFixture]
     public class UmbracoBackOfficeIdentityTests
     {
-
         public const string TestIssuer = "TestIssuer";
 
+        [SetUp]
+        public void Initialize()
+        {
+            var sqlSyntax = new SqlCeSyntaxProvider();
+
+            //This is needed because the Migration resolver is creating migration instances with their full ctors
+            ApplicationContext.EnsureContext(
+                new ApplicationContext(
+                    new DatabaseContext(Mock.Of<IScopeProviderInternal>(), Mock.Of<ILogger>(), sqlSyntax, "test"),
+                    new ServiceContext(),
+                    CacheHelper.CreateDisabledCacheHelper(),
+                    new ProfilingLogger(Mock.Of<ILogger>(), Mock.Of<IProfiler>())),
+                true);
+        }
+
+
         [Test]
         public void Create_From_Claims_Identity()
         {
diff --git a/src/Umbraco.Web.UI/Umbraco.Web.UI.csproj b/src/Umbraco.Web.UI/Umbraco.Web.UI.csproj
index 76d2765672..3e0ce457e1 100644
--- a/src/Umbraco.Web.UI/Umbraco.Web.UI.csproj
+++ b/src/Umbraco.Web.UI/Umbraco.Web.UI.csproj
@@ -1028,9 +1028,9 @@ xcopy "$(ProjectDir)"..\packages\SqlServerCE.4.0.0.1\x86\*.* "$(TargetDir)x86\"
         <WebProjectProperties>
           <UseIIS>True</UseIIS>
           <AutoAssignPort>True</AutoAssignPort>
-          <DevelopmentServerPort>7153</DevelopmentServerPort>
+          <DevelopmentServerPort>7154</DevelopmentServerPort>
           <DevelopmentServerVPath>/</DevelopmentServerVPath>
-          <IISUrl>http://localhost:7153</IISUrl>
+          <IISUrl>http://localhost:7154</IISUrl>
           <NTLMAuthentication>False</NTLMAuthentication>
           <UseCustomServer>False</UseCustomServer>
           <CustomServerUrl>