bumps version to 7.6.0 rtm

U4-9775 AlreadyClosedException is thrown when retrieving media if the…

.editorconfig

@@ -0,0 +1,10 @@
+root=true
+
+[*]
+end_of_line = lf
+indent_style = space
+indent_size = 2
+trim_trailing_whitespace = true
+
+[*.{cs,cshtml,csx,vb,vbx,vbhtml,fs,fsx,txt,ps1,sql}]
+indent_size = 4

build/NuSpecs/UmbracoCms.Core.nuspec

@@ -14,12 +14,13 @@
     <summary>Contains the core assemblies needed to run Umbraco Cms</summary>
     <language>en-US</language>
     <tags>umbraco</tags>
-    <dependencies>
-      <!--Must be this way because 2.0.5 is actually 1.2.15.0 and 2.0.6 is actually 2.0.6 !-->
-      <dependency id="log4net" version="[2.0.5,2.0.6)" />
+    <dependencies>      
+      <dependency id="log4net" version="[2.0.8,3.0.0)" />
+      <dependency id="Log4Net.Async" version="[2.0.4,3.0.0)" />
       <dependency id="Microsoft.AspNet.Mvc" version="[5.2.3,6.0.0)" />
       <dependency id="Microsoft.AspNet.WebApi" version="[5.2.3,6.0.0)" />
       <dependency id="Microsoft.AspNet.Identity.Owin" version="[2.2.1, 3.0.0)" />
+      <dependency id="Microsoft.AspNet.SignalR.Core" version="[2.2.1, 3.0.0)" />
       <dependency id="Microsoft.Owin.Security.Cookies" version="[3.0.1, 4.0.0)" />
       <dependency id="Microsoft.Owin.Security.OAuth" version="[3.0.1, 4.0.0)" />
       <dependency id="Microsoft.Owin.Host.SystemWeb" version="[3.0.1, 4.0.0)" />
@@ -27,19 +28,19 @@
       <dependency id="HtmlAgilityPack" version="[1.4.9.5, 2.0.0)" />
       <dependency id="Lucene.Net" version="[2.9.4.1, 3.0.0.0)" />
       <dependency id="SharpZipLib" version="[0.86.0, 1.0.0)" />
-      <dependency id="MySql.Data" version="[6.9.8, 7.0.0)" />
+      <dependency id="MySql.Data" version="[6.9.9, 7.0.0)" />
       <dependency id="xmlrpcnet" version="[2.5.0, 3.0.0)" />
       <dependency id="ClientDependency" version="[1.9.2, 2.0.0)" />
       <dependency id="ClientDependency-Mvc5" version="[1.8.0.0, 2.0.0)" />
       <dependency id="AutoMapper" version="[3.3.1, 4.0.0)" />
-      <dependency id="Newtonsoft.Json" version="[9.0.1, 10.0.0)" />
+      <dependency id="Newtonsoft.Json" version="[10.0.2, 11.0.0)" />
       <dependency id="Examine" version="[0.1.82, 1.0.0)" />
-      <dependency id="ImageProcessor" version="[2.5.2, 3.0.0)" />
-      <dependency id="ImageProcessor.Web" version="[4.8.2, 5.0.0)" />
-      <dependency id="semver" version="[2.0.4, 3.0.0)" />
-	  <!-- Markdown can not be updated due to: https://github.com/hey-red/markdownsharp/issues/71#issuecomment-233585487 -->
+      <dependency id="ImageProcessor" version="[2.5.3, 3.0.0)" />
+      <dependency id="ImageProcessor.Web" version="[4.8.3, 5.0.0)" />
+      <dependency id="semver" version="[1.1.2, 3.0.0)" />
+	    <!-- Markdown can not be updated due to: https://github.com/hey-red/markdownsharp/issues/71#issuecomment-233585487 -->
       <dependency id="Markdown" version="[1.14.7, 2.0.0)" />
-      <dependency id="System.Threading.Tasks.Dataflow" version="[4.6.0, 5.0.0)" />
+      <dependency id="System.Threading.Tasks.Dataflow" version="[4.7.0, 5.0.0)" />
     </dependencies>
   </metadata>
   <files>

build/NuSpecs/UmbracoCms.nuspec

@@ -16,10 +16,10 @@
     <tags>umbraco</tags>
     <dependencies>
       <dependency id="UmbracoCms.Core" version="[$version$]" />
-      <dependency id="Newtonsoft.Json" version="[9.0.1, 10.0.0)" />
-      <dependency id="Umbraco.ModelsBuilder" version="[3.0.6, 4.0.0)" />
+      <dependency id="Newtonsoft.Json" version="[10.0.2, 11.0.0)" />
+      <dependency id="Umbraco.ModelsBuilder" version="[3.0.7, 4.0.0)" />
       <dependency id="Microsoft.AspNet.SignalR.Core" version="[2.2.1, 3.0.0)" />
-	  <dependency id="ImageProcessor.Web.Config" version="[2.3.0, 3.0.0)" />
+	    <dependency id="ImageProcessor.Web.Config" version="[2.3.0, 3.0.0)" />
     </dependencies>
   </metadata>
   <files>

build/NuSpecs/tools/ReadmeUpgrade.txt

@@ -8,8 +8,16 @@
                                                    
 ----------------------------------------------------
 
-Don't forget to build!
+*** IMPORTANT NOTICE FOR 7.6 UPGRADES ***
 
+Be sure to read the version specific upgrade information before proceeding:
+https://our.umbraco.org/documentation/Getting-Started/Setup/Upgrading/version-specific#version-7-6-0
+
+You will most likely need to make some changes to your web.config and you will need to be 
+aware of the breaking changes listed there to see if these affect your installation.
+
+
+Don't forget to build!
 
 We've done our best to transform your configuration files but in case something is not quite right: remember we
 backed up your files in App_Data\NuGetBackup so you can find the original files before they were transformed.

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

@@ -330,6 +330,8 @@
       <dependentAssembly xdt:Locator="Condition(./_defaultNamespace:assemblyIdentity/@name='Microsoft.Owin.Security')" xdt:Transform="Remove" />
       <dependentAssembly xdt:Locator="Condition(./_defaultNamespace:assemblyIdentity/@name='Microsoft.Owin.Security.Cookies')" xdt:Transform="Remove" />
       <dependentAssembly xdt:Locator="Condition(./_defaultNamespace:assemblyIdentity/@name='System.Net.Http.Formatting')" xdt:Transform="Remove" />
+      <dependentAssembly xdt:Locator="Condition(./_defaultNamespace:assemblyIdentity/@name='Microsoft.CodeAnalysis.CSharp')" xdt:Transform="Remove" />
+      <dependentAssembly xdt:Locator="Condition(./_defaultNamespace:assemblyIdentity/@name='log4net')" xdt:Transform="Remove" />
     </assemblyBinding>
   </runtime>
 
@@ -349,7 +351,7 @@
       </dependentAssembly>
       <dependentAssembly xdt:Transform="Insert">
         <assemblyIdentity name="Newtonsoft.Json" publicKeyToken="30ad4fe6b2a6aeed" culture="neutral" />
-        <bindingRedirect oldVersion="0.0.0.0-6.0.0.0" newVersion="6.0.0.0" />
+        <bindingRedirect oldVersion="0.0.0.0-10.0.0.0" newVersion="10.0.0.0" />
       </dependentAssembly>
       <dependentAssembly xdt:Transform="Insert">
         <assemblyIdentity name="System.Web.Mvc" publicKeyToken="31bf3856ad364e35" culture="neutral" />
@@ -383,6 +385,10 @@
         <assemblyIdentity name="System.Net.Http.Formatting" publicKeyToken="31bf3856ad364e35" culture="neutral" />
         <bindingRedirect oldVersion="0.0.0.0-5.2.3.0" newVersion="5.2.3.0" />
       </dependentAssembly>
+      <dependentAssembly xdt:Transform="Insert">
+        <assemblyIdentity name="log4net" publicKeyToken="669e0ddf0bb1aa2a" culture="neutral"/>
+        <bindingRedirect oldVersion="0.0.0.0-2.0.8.0" newVersion="2.0.8.0"/>
+      </dependentAssembly>
     </assemblyBinding>
   </runtime>
 

build/UmbracoVersion.txt

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

src/SQLCE4Umbraco/app.config

@@ -4,7 +4,7 @@
     <assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
       <dependentAssembly>
         <assemblyIdentity name="Newtonsoft.Json" publicKeyToken="30ad4fe6b2a6aeed" culture="neutral" />
-        <bindingRedirect oldVersion="0.0.0.0-9.0.0.0" newVersion="9.0.0.0" />
+        <bindingRedirect oldVersion="0.0.0.0-10.0.0.0" newVersion="10.0.0.0" />
       </dependentAssembly>
       <dependentAssembly>
         <assemblyIdentity name="System.Web.Mvc" publicKeyToken="31bf3856ad364e35" culture="neutral" />
@@ -30,6 +30,10 @@
         <assemblyIdentity name="Microsoft.Owin.Security.Cookies" publicKeyToken="31bf3856ad364e35" culture="neutral" />
         <bindingRedirect oldVersion="0.0.0.0-3.0.1.0" newVersion="3.0.1.0" />
       </dependentAssembly>
+      <dependentAssembly>
+        <assemblyIdentity name="log4net" publicKeyToken="669e0ddf0bb1aa2a" culture="neutral" />
+        <bindingRedirect oldVersion="0.0.0.0-2.0.8.0" newVersion="2.0.8.0" />
+      </dependentAssembly>
     </assemblyBinding>
   </runtime>
 <startup><supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.5" /></startup></configuration>

src/SolutionInfo.cs

@@ -12,4 +12,4 @@ using System.Resources;
 [assembly: AssemblyVersion("1.0.*")]
 
 [assembly: AssemblyFileVersion("7.6.0")]
-[assembly: AssemblyInformationalVersion("7.6.0-RC")]
+[assembly: AssemblyInformationalVersion("7.6.0")]

src/Umbraco.Core/BindingRedirects.cs

@@ -4,12 +4,14 @@ using System.Text.RegularExpressions;
 using System.Web;
 using Umbraco.Core;
 
+[assembly: PreApplicationStartMethod(typeof(BindingRedirects), "Initialize")]
+
 namespace Umbraco.Core
 {
     /// <summary>
-    /// Manages any assembly binding redirects that cannot be done via config
+    /// Manages any assembly binding redirects that cannot be done via config (i.e. unsigned --> signed assemblies)
     /// </summary>
-    internal class BindingRedirects
+    public sealed class BindingRedirects
     {
         public static void Initialize()
         {
@@ -17,12 +19,9 @@ namespace Umbraco.Core
             AppDomain.CurrentDomain.AssemblyResolve += CurrentDomain_AssemblyResolve;
         }
 
-        private static readonly Regex Log4NetAssemblyPattern = new Regex("log4net, Version=([\\d\\.]+?), Culture=neutral, PublicKeyToken=null");
-        private const string Log4NetReplacement = "log4net, Version=1.2.15.0, Culture=neutral, PublicKeyToken=669e0ddf0bb1aa2a";
-
-        private static readonly Regex HtmlAgilityAssemblyPattern = new Regex("HtmlAgilityPack, Version=([\\d\\.]+?), Culture=neutral, PublicKeyToken=bd319b19eaf3b43a");
-        private const string HtmlAgilityReplacement = "HtmlAgilityPack, Version=1.4.9.5, Culture=neutral, PublicKeyToken=bd319b19eaf3b43a";
-
+        private static readonly Regex Log4NetAssemblyPattern = new Regex("log4net, Version=([\\d\\.]+?), Culture=neutral, PublicKeyToken=\\w+$", RegexOptions.Compiled);
+        private const string Log4NetReplacement = "log4net, Version=2.0.8.0, Culture=neutral, PublicKeyToken=669e0ddf0bb1aa2a";
+        
         /// <summary>
         /// This is used to do an assembly binding redirect via code - normally required due to signature changes in assemblies
         /// </summary>
@@ -36,13 +35,7 @@ namespace Umbraco.Core
             {
                 return Assembly.Load(Log4NetAssemblyPattern.Replace(args.Name, Log4NetReplacement));
             }
-
-            //HtmlAgility:            
-            if (HtmlAgilityAssemblyPattern.IsMatch(args.Name) && args.Name != HtmlAgilityReplacement)
-            {
-                return Assembly.Load(HtmlAgilityAssemblyPattern.Replace(args.Name, HtmlAgilityReplacement));
-            }
-
+            
             //AutoMapper:
             // ensure the assembly is indeed AutoMapper and that the PublicKeyToken is null before trying to Load again
             // do NOT just replace this with 'return Assembly', as it will cause an infinite loop -> stackoverflow

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

@@ -8,6 +8,7 @@ namespace Umbraco.Core.Configuration.UmbracoSettings
         Guid Id { get;  }
         string RepositoryUrl { get; }
         string WebServiceUrl { get; }
-        bool HasCustomWebServiceUrl { get; }
+        bool HasCustomWebServiceUrl { get; }
+        string RestApiUrl { get; }
     }
 }

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

@@ -0,0 +1,19 @@
+using System;
+using System.Linq;
+
+namespace Umbraco.Core.Configuration.UmbracoSettings
+{
+    public static class RepositoryConfigExtensions
+    {
+        //Our package repo
+        private static readonly Guid RepoGuid = new Guid("65194810-1f85-11dd-bd0b-0800200c9a66");
+
+        public static IRepository GetDefault(this IRepositoriesSection repos)
+        {
+            var found = repos.Repositories.FirstOrDefault(x => x.Id == RepoGuid);
+            if (found == null)
+                throw new InvalidOperationException("No default package repository found with id " + RepoGuid);
+            return found;
+        }
+    }
+}

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

@@ -38,9 +38,16 @@ namespace Umbraco.Core.Configuration.UmbracoSettings
             get
             {
                 var prop = Properties["webserviceurl"];
-                var repoUrl = this[prop] as ConfigurationElement;
-                return (repoUrl != null && repoUrl.ElementInformation.IsPresent);
+                return (string) prop.DefaultValue != (string) this[prop];                
             }
         }
+
+        [ConfigurationProperty("restapiurl", DefaultValue = "https://our.umbraco.org/webapi/packages/v1")]
+        public string RestApiUrl
+        {
+            get { return (string)base["restapiurl"]; }
+            set { base["restapiurl"] = value; }
+        }
+        
     }
 }

src/Umbraco.Core/Configuration/UmbracoVersion.cs

@@ -24,7 +24,7 @@ namespace Umbraco.Core.Configuration
         /// Gets the version comment (like beta or RC).
         /// </summary>
         /// <value>The version comment.</value>
-        public static string CurrentComment { get { return "RC"; } }
+        public static string CurrentComment { get { return ""; } }
 
         // Get the version of the umbraco.dll by looking at a class in that dll
         // Had to do it like this due to medium trust issues, see: http://haacked.com/archive/2010/11/04/assembly-location-and-medium-trust.aspx

src/Umbraco.Core/Constants-ObjectTypes.cs

@@ -124,6 +124,11 @@ namespace Umbraco.Core
             /// </summary>
             public const string MemberGroup = "366E63B9-880F-4E13-A61C-98069B029728";
 
+            /// <summary>
+            /// Guid for a Member Group object.
+            /// </summary>
+            public static readonly Guid MemberGroupGuid = new Guid(MemberGroup);
+
             /// <summary>
             /// Guid for a Member Type object.
             /// </summary>

src/Umbraco.Core/Events/CancellableObjectEventArgs.cs

@@ -1,85 +1,177 @@
 using System;
+using System.Collections;
 using System.Collections.Generic;
+using System.Linq;
 using System.Security.Permissions;
 using Umbraco.Core.Models;
 using Umbraco.Core.Models.EntityBase;
 
 namespace Umbraco.Core.Events
 {
-	/// <summary>
-	/// Event args for a strongly typed object that can support cancellation
-	/// </summary>
-	/// <typeparam name="T"></typeparam>
-	[HostProtection(SecurityAction.LinkDemand, SharedState = true)]
-	public class CancellableObjectEventArgs<T> : CancellableEventArgs, IEquatable<CancellableObjectEventArgs<T>>
-	{
-	    public CancellableObjectEventArgs(T eventObject, bool canCancel, EventMessages messages, IDictionary<string, object> additionalData)
+    /// <summary>
+    /// Used as a base class for the generic type CancellableObjectEventArgs{T} so that we can get direct 'object' access to the underlying EventObject
+    /// </summary>
+    [HostProtection(SecurityAction.LinkDemand, SharedState = true)]
+    public abstract class CancellableObjectEventArgs : CancellableEventArgs
+    {
+        protected CancellableObjectEventArgs(object eventObject, bool canCancel, EventMessages messages, IDictionary<string, object> additionalData)
             : base(canCancel, messages, additionalData)
-	    {
+        {
             EventObject = eventObject;
         }
 
-	    public CancellableObjectEventArgs(T eventObject, bool canCancel, EventMessages eventMessages)
+        protected CancellableObjectEventArgs(object eventObject, bool canCancel, EventMessages eventMessages)
             : base(canCancel, eventMessages)
         {
             EventObject = eventObject;
         }
 
-        public CancellableObjectEventArgs(T eventObject, EventMessages eventMessages)
+        protected CancellableObjectEventArgs(object eventObject, EventMessages eventMessages)
             : this(eventObject, true, eventMessages)
         {
         }
 
+        protected CancellableObjectEventArgs(object eventObject, bool canCancel)
+            : base(canCancel)
+        {
+            EventObject = eventObject;
+        }
+
+        protected CancellableObjectEventArgs(object eventObject)
+            : this(eventObject, true)
+        {
+        }
+
+        /// <summary>
+        /// Returns the object relating to the event
+        /// </summary>
+        /// <remarks>
+        /// This is protected so that inheritors can expose it with their own name
+        /// </remarks>
+        internal object EventObject { get; set; }
+
+    }
+
+    /// <summary>
+    /// Event args for a strongly typed object that can support cancellation
+    /// </summary>
+    /// <typeparam name="T"></typeparam>
+    [HostProtection(SecurityAction.LinkDemand, SharedState = true)]
+    public class CancellableObjectEventArgs<T> : CancellableObjectEventArgs, IEquatable<CancellableObjectEventArgs<T>>
+    {
+        public CancellableObjectEventArgs(T eventObject, bool canCancel, EventMessages messages, IDictionary<string, object> additionalData)
+            : base(eventObject, canCancel, messages, additionalData)
+        {
+        }
+
+        public CancellableObjectEventArgs(T eventObject, bool canCancel, EventMessages eventMessages)
+            : base(eventObject, canCancel, eventMessages)
+        {
+        }
+
+        public CancellableObjectEventArgs(T eventObject, EventMessages eventMessages)
+            : base(eventObject, eventMessages)
+        {
+        }
+
         public CancellableObjectEventArgs(T eventObject, bool canCancel)
-			: base(canCancel)
-		{
-			EventObject = eventObject;
-		}
+            : base(eventObject, canCancel)
+        {
+        }
 
-		public CancellableObjectEventArgs(T eventObject)
-			: this(eventObject, true)
-		{
-		}
+        public CancellableObjectEventArgs(T eventObject)
+            : base(eventObject)
+        {
+        }
 
-		/// <summary>
-		/// Returns the object relating to the event
-		/// </summary>
-		/// <remarks>
-		/// This is protected so that inheritors can expose it with their own name
-		/// </remarks>
-		protected T EventObject { get; set; }
+        /// <summary>
+        /// Returns the object relating to the event
+        /// </summary>
+        /// <remarks>
+        /// This is protected so that inheritors can expose it with their own name
+        /// </remarks>
+        protected new T EventObject
+        {
+            get { return (T) base.EventObject; }
+            set { base.EventObject = value; }
+        }
 
-	    public bool Equals(CancellableObjectEventArgs<T> other)
-	    {
-	        if (ReferenceEquals(null, other)) return false;
-	        if (ReferenceEquals(this, other)) return true;
-	        return base.Equals(other) && EqualityComparer<T>.Default.Equals(EventObject, other.EventObject);
-	    }
+        public bool Equals(CancellableObjectEventArgs<T> other)
+        {
+            if (ReferenceEquals(null, other)) return false;
+            if (ReferenceEquals(this, other)) return true;
+            return base.Equals(other) && EqualityComparer<T>.Default.Equals(EventObject, other.EventObject);
+        }
 
-	    public override bool Equals(object obj)
-	    {
-	        if (ReferenceEquals(null, obj)) return false;
-	        if (ReferenceEquals(this, obj)) return true;
-	        if (obj.GetType() != this.GetType()) return false;
-	        return Equals((CancellableObjectEventArgs<T>) obj);
-	    }
+        public override bool Equals(object obj)
+        {
+            if (ReferenceEquals(null, obj)) return false;
+            if (ReferenceEquals(this, obj)) return true;
+            if (obj.GetType() != this.GetType()) return false;
+            return Equals((CancellableObjectEventArgs<T>)obj);
+        }
 
-	    public override int GetHashCode()
-	    {
-	        unchecked
-	        {
-	            return (base.GetHashCode() * 397) ^ EqualityComparer<T>.Default.GetHashCode(EventObject);
-	        }
-	    }
+        public override int GetHashCode()
+        {
+            unchecked
+            {
+                return (base.GetHashCode() * 397) ^ EqualityComparer<T>.Default.GetHashCode(EventObject);
+            }
+        }
 
-	    public static bool operator ==(CancellableObjectEventArgs<T> left, CancellableObjectEventArgs<T> right)
-	    {
-	        return Equals(left, right);
-	    }
+        public static bool operator ==(CancellableObjectEventArgs<T> left, CancellableObjectEventArgs<T> right)
+        {
+            return Equals(left, right);
+        }
 
-	    public static bool operator !=(CancellableObjectEventArgs<T> left, CancellableObjectEventArgs<T> right)
-	    {
-	        return !Equals(left, right);
-	    }
-	}
+        public static bool operator !=(CancellableObjectEventArgs<T> left, CancellableObjectEventArgs<T> right)
+        {
+            return !Equals(left, right);
+        }
+    }
+
+    [HostProtection(SecurityAction.LinkDemand, SharedState = true)]
+    public class CancellableEnumerableObjectEventArgs<T> : CancellableObjectEventArgs<IEnumerable<T>>, IEquatable<CancellableEnumerableObjectEventArgs<T>>
+    {
+        public CancellableEnumerableObjectEventArgs(IEnumerable<T> eventObject, bool canCancel, EventMessages messages, IDictionary<string, object> additionalData)
+            : base(eventObject, canCancel, messages, additionalData)
+        { }
+
+        public CancellableEnumerableObjectEventArgs(IEnumerable<T> eventObject, bool canCancel, EventMessages eventMessages)
+            : base(eventObject, canCancel, eventMessages)
+        { }
+
+        public CancellableEnumerableObjectEventArgs(IEnumerable<T> eventObject, EventMessages eventMessages)
+            : base(eventObject, eventMessages)
+        { }
+
+        public CancellableEnumerableObjectEventArgs(IEnumerable<T> eventObject, bool canCancel)
+            : base(eventObject, canCancel)
+        { }
+
+        public CancellableEnumerableObjectEventArgs(IEnumerable<T> eventObject)
+            : base(eventObject)
+        { }
+
+        public bool Equals(CancellableEnumerableObjectEventArgs<T> other)
+        {
+            if (ReferenceEquals(null, other)) return false;
+            if (ReferenceEquals(this, other)) return true;
+
+            return EventObject.SequenceEqual(other.EventObject);
+        }
+
+        public override bool Equals(object obj)
+        {
+            if (ReferenceEquals(null, obj)) return false;
+            if (ReferenceEquals(this, obj)) return true;
+            if (obj.GetType() != this.GetType()) return false;
+            return Equals((CancellableEnumerableObjectEventArgs<T>)obj);
+        }
+
+        public override int GetHashCode()
+        {
+            return HashCodeHelper.GetHashCode(EventObject);
+        }
+    }
 }

src/Umbraco.Core/Events/DeleteEventArgs.cs

@@ -1,9 +1,14 @@
 using System;
 using System.Collections.Generic;
+using System.Linq;
 
 namespace Umbraco.Core.Events
 {
-    public class DeleteEventArgs<TEntity> : CancellableObjectEventArgs<IEnumerable<TEntity>>, IEquatable<DeleteEventArgs<TEntity>>, IDeletingMediaFilesEventArgs
+    [SupersedeEvent(typeof(SaveEventArgs<>))]
+    [SupersedeEvent(typeof(PublishEventArgs<>))]
+    [SupersedeEvent(typeof(MoveEventArgs<>))]
+    [SupersedeEvent(typeof(CopyEventArgs<>))]
+    public class DeleteEventArgs<TEntity> : CancellableEnumerableObjectEventArgs<TEntity>, IEquatable<DeleteEventArgs<TEntity>>, IDeletingMediaFilesEventArgs
 	{
 	    /// <summary>
 	    /// Constructor accepting multiple entities that are used in the delete operation
@@ -106,7 +111,7 @@ namespace Umbraco.Core.Events
 	    {
 	        if (ReferenceEquals(null, other)) return false;
 	        if (ReferenceEquals(this, other)) return true;
-	        return base.Equals(other) && MediaFilesToDelete.Equals(other.MediaFilesToDelete);
+	        return base.Equals(other) && MediaFilesToDelete.SequenceEqual(other.MediaFilesToDelete);
 	    }
 
 	    public override bool Equals(object obj)

src/Umbraco.Core/Events/ImportEventArgs.cs

@@ -4,7 +4,7 @@ using System.Xml.Linq;
 
 namespace Umbraco.Core.Events
 {
-    public class ImportEventArgs<TEntity> : CancellableObjectEventArgs<IEnumerable<TEntity>>, IEquatable<ImportEventArgs<TEntity>>
+    public class ImportEventArgs<TEntity> : CancellableEnumerableObjectEventArgs<TEntity>, IEquatable<ImportEventArgs<TEntity>>
     {
         /// <summary>
         /// Constructor accepting an XElement with the xml being imported

src/Umbraco.Core/Events/ImportPackageEventArgs.cs

@@ -4,7 +4,7 @@ using Umbraco.Core.Packaging.Models;
 
 namespace Umbraco.Core.Events
 {
-    internal class ImportPackageEventArgs<TEntity> : CancellableObjectEventArgs<IEnumerable<TEntity>>, IEquatable<ImportPackageEventArgs<TEntity>>
+    internal class ImportPackageEventArgs<TEntity> : CancellableEnumerableObjectEventArgs<TEntity>, IEquatable<ImportPackageEventArgs<TEntity>>
     {
         private readonly MetaData _packageMetaData;
 
@@ -32,7 +32,8 @@ namespace Umbraco.Core.Events
         public bool Equals(ImportPackageEventArgs<TEntity> other)
         {
             if (ReferenceEquals(null, other)) return false;
-            if (ReferenceEquals(this, other)) return true;
+            if (ReferenceEquals(this, other)) return true;
+            //TODO: MetaData for package metadata has no equality operators :/
             return base.Equals(other) && _packageMetaData.Equals(other._packageMetaData);
         }
 

src/Umbraco.Core/Events/PassThroughEventDispatcher.cs

@@ -5,8 +5,10 @@ using System.Linq;
 namespace Umbraco.Core.Events
 {
     /// <summary>
-    /// This event manager supports event cancellation and will raise the events as soon as they are tracked, it does not store tracked events
+    /// An IEventDispatcher that immediately raise all events.
     /// </summary>
+    /// <remarks>This means that events will be raised during the scope transaction,
+    /// whatever happens, and the transaction could roll back in the end.</remarks>
     internal class PassThroughEventDispatcher : IEventDispatcher
     {
         public bool DispatchCancelable(EventHandler eventHandler, object sender, CancellableEventArgs args, string eventName = null)

src/Umbraco.Core/Events/PublishEventArgs.cs

@@ -3,7 +3,7 @@ using System.Collections.Generic;
 
 namespace Umbraco.Core.Events
 {
-    public class PublishEventArgs<TEntity> : CancellableObjectEventArgs<IEnumerable<TEntity>>, IEquatable<PublishEventArgs<TEntity>>
+    public class PublishEventArgs<TEntity> : CancellableEnumerableObjectEventArgs<TEntity>, IEquatable<PublishEventArgs<TEntity>>
     {
         /// <summary>
         /// Constructor accepting multiple entities that are used in the publish operation

src/Umbraco.Core/Events/SaveEventArgs.cs

@@ -1,8 +1,9 @@
 using System.Collections.Generic;
+using System.Linq;
 
 namespace Umbraco.Core.Events
 {
-	public class SaveEventArgs<TEntity> : CancellableObjectEventArgs<IEnumerable<TEntity>>
+	public class SaveEventArgs<TEntity> : CancellableEnumerableObjectEventArgs<TEntity>
 	{
         /// <summary>
         /// Constructor accepting multiple entities that are used in the saving operation
@@ -116,7 +117,5 @@ namespace Umbraco.Core.Events
 		{
 			get { return EventObject; }
 		}
-
-
 	}
 }

src/Umbraco.Core/Events/ScopeEventDispatcher.cs

@@ -3,11 +3,9 @@ using Umbraco.Core.IO;
 namespace Umbraco.Core.Events
 {
     /// <summary>
-    /// This event manager is created for each scope and is aware of if it is nested in an outer scope
+    /// An IEventDispatcher that queues events, and raise them when the scope
+    /// exits and has been completed.
     /// </summary>
-    /// <remarks>
-    /// The outer scope is the only scope that can raise events, the inner scope's will defer to the outer scope
-    /// </remarks>
     internal class ScopeEventDispatcher : ScopeEventDispatcherBase
     {
         public ScopeEventDispatcher()

src/Umbraco.Core/Events/ScopeEventDispatcherBase.cs

@@ -1,11 +1,23 @@
 using System;
+using System.Collections;
 using System.Collections.Generic;
 using System.Linq;
+using Umbraco.Core.Models.EntityBase;
 
 namespace Umbraco.Core.Events
 {
+    /// <summary>
+    /// An IEventDispatcher that queues events.
+    /// </summary>
+    /// <remarks>
+    /// <para>Can raise, or ignore, cancelable events, depending on option.</para>
+    /// <para>Implementations must override ScopeExitCompleted to define what
+    /// to do with the events when the scope exits and has been completed.</para>
+    /// <para>If the scope exits without being completed, events are ignored.</para>
+    /// </remarks>
     public abstract class ScopeEventDispatcherBase : IEventDispatcher
     {
+        //events will be enlisted in the order they are raised
         private List<IEventDefinition> _events;
         private readonly bool _raiseCancelable;
 
@@ -64,29 +76,263 @@ namespace Umbraco.Core.Events
         {
             if (_events == null)
                 return Enumerable.Empty<IEventDefinition>();
-
+            
             switch (filter)
             {
                 case EventDefinitionFilter.All:
-                    return _events;
+                    return FilterSupersededAndUpdateToLatestEntity(_events);
                 case EventDefinitionFilter.FirstIn:
                     var l1 = new OrderedHashSet<IEventDefinition>();
                     foreach (var e in _events)
                     {
                         l1.Add(e);
                     }
-                    return l1;
+                    return FilterSupersededAndUpdateToLatestEntity(l1);
                 case EventDefinitionFilter.LastIn:
                     var l2 = new OrderedHashSet<IEventDefinition>(keepOldest: false);
                     foreach (var e in _events)
                     {
                         l2.Add(e);
                     }
-                    return l2;
+                    return FilterSupersededAndUpdateToLatestEntity(l2);
                 default:
                     throw new ArgumentOutOfRangeException("filter", filter, null);
             }
         }
+        
+        private class EventDefinitionTypeData
+        {
+            public IEventDefinition EventDefinition { get; set; }
+            public Type EventArgType { get; set; }
+            public SupersedeEventAttribute[] SupersedeAttributes { get; set; }
+        }
+        
+        /// <summary>
+        /// This will iterate over the events (latest first) and filter out any events or entities in event args that are included 
+        /// in more recent events that Supersede previous ones. For example, If an Entity has been Saved and then Deleted, we don't want
+        /// to raise the Saved event (well actually we just don't want to include it in the args for that saved event)
+        /// </summary>
+        /// <param name="events"></param>
+        /// <returns></returns>
+        private static IEnumerable<IEventDefinition> FilterSupersededAndUpdateToLatestEntity(IReadOnlyList<IEventDefinition> events)
+        {
+            //used to keep the 'latest' entity and associated event definition data
+            var allEntities = new List<Tuple<IEntity, EventDefinitionTypeData>>();
+
+            //tracks all CancellableObjectEventArgs instances in the events which is the only type of args we can work with
+            var cancelableArgs = new List<CancellableObjectEventArgs>();
+
+            var result = new List<IEventDefinition>();
+
+            //This will eagerly load all of the event arg types and their attributes so we don't have to continuously look this data up
+            var allArgTypesWithAttributes = events.Select(x => x.Args.GetType())
+                .Distinct()
+                .ToDictionary(x => x, x => x.GetCustomAttributes<SupersedeEventAttribute>(false).ToArray());
+               
+            //Iterate all events and collect the actual entities in them and relates them to their corresponding EventDefinitionTypeData
+            //we'll process the list in reverse because events are added in the order they are raised and we want to filter out
+            //any entities from event args that are not longer relevant 
+            //(i.e. if an item is Deleted after it's Saved, we won't include the item in the Saved args)
+            for (var index = events.Count - 1; index >= 0; index--)
+            {
+                var eventDefinition = events[index];
+
+                var argType = eventDefinition.Args.GetType();
+                var attributes = allArgTypesWithAttributes[eventDefinition.Args.GetType()];
+
+                var meta = new EventDefinitionTypeData
+                {
+                    EventDefinition = eventDefinition,
+                    EventArgType = argType,
+                    SupersedeAttributes = attributes
+                };
+
+                var args = eventDefinition.Args as CancellableObjectEventArgs;
+                if (args != null)
+                {
+                    var list = TypeHelper.CreateGenericEnumerableFromObject(args.EventObject);
+
+                    if (list == null)
+                    {
+                        //extract the event object
+                        var obj = args.EventObject as IEntity;
+                        if (obj != null)
+                        {
+                            //Now check if this entity already exists in other event args that supersede this current event arg type
+                            if (IsFiltered(obj, meta, allEntities) == false)
+                            {
+                                //if it's not filtered we can adde these args to the response
+                                cancelableArgs.Add(args);
+                                result.Add(eventDefinition);
+                                //track the entity
+                                allEntities.Add(Tuple.Create(obj, meta));
+                            }
+                        }
+                        else
+                        {
+                            //Can't retrieve the entity so cant' filter or inspect, just add to the output
+                            result.Add(eventDefinition);                            
+                        }
+                    }
+                    else
+                    {
+                        var toRemove = new List<IEntity>();
+                        foreach (var entity in list)
+                        {
+                            //extract the event object
+                            var obj = entity as IEntity;
+                            if (obj != null)
+                            {
+                                //Now check if this entity already exists in other event args that supersede this current event arg type
+                                if (IsFiltered(obj, meta, allEntities))
+                                {
+                                    //track it to be removed
+                                    toRemove.Add(obj);
+                                }
+                                else
+                                {
+                                    //track the entity, it's not filtered
+                                    allEntities.Add(Tuple.Create(obj, meta));
+                                }
+                            }
+                            else
+                            {
+                                //we don't need to do anything here, we can't cast to IEntity so we cannot filter, so it will just remain in the list
+                            }
+                        }
+
+                        //remove anything that has been filtered
+                        foreach (var entity in toRemove)
+                        {
+                            list.Remove(entity);
+                        }
+
+                        //track the event and include in the response if there's still entities remaining in the list
+                        if (list.Count > 0)
+                        {
+                            if (toRemove.Count > 0)
+                            {
+                                //re-assign if the items have changed
+                                args.EventObject = list;
+                            }
+                            cancelableArgs.Add(args);
+                            result.Add(eventDefinition);
+                        }
+                    }
+                }
+                else
+                {
+                    //it's not a cancelable event arg so we just include it in the result
+                    result.Add(eventDefinition);
+                }
+            }
+
+            //Now we'll deal with ensuring that only the latest(non stale) entities are used throughout all event args
+            UpdateToLatestEntities(allEntities, cancelableArgs);
+
+            //we need to reverse the result since we've been adding by latest added events first!
+            result.Reverse();
+
+            return result;
+        }
+
+        private static void UpdateToLatestEntities(IEnumerable<Tuple<IEntity, EventDefinitionTypeData>> allEntities, IEnumerable<CancellableObjectEventArgs> cancelableArgs)
+        {
+            //Now we'll deal with ensuring that only the latest(non stale) entities are used throughout all event args
+
+            var latestEntities = new OrderedHashSet<IEntity>(keepOldest: true);
+            foreach (var entity in allEntities.OrderByDescending(entity => entity.Item1.UpdateDate))
+            {
+                latestEntities.Add(entity.Item1);
+            }
+
+            foreach (var args in cancelableArgs)
+            {
+                var list = TypeHelper.CreateGenericEnumerableFromObject(args.EventObject);
+                if (list == null)
+                {
+                    //try to find the args entity in the latest entity - based on the equality operators, this will 
+                    //match by Id since that is the default equality checker for IEntity. If one is found, than it is 
+                    //the most recent entity instance so update the args with that instance so we don't emit a stale instance.
+                    var foundEntity = latestEntities.FirstOrDefault(x => Equals(x, args.EventObject));
+                    if (foundEntity != null)
+                    {
+                        args.EventObject = foundEntity;
+                    }
+                }
+                else
+                {
+                    var updated = false;
+
+                    for (int i = 0; i < list.Count; i++)
+                    {
+                        //try to find the args entity in the latest entity - based on the equality operators, this will 
+                        //match by Id since that is the default equality checker for IEntity. If one is found, than it is 
+                        //the most recent entity instance so update the args with that instance so we don't emit a stale instance.
+                        var foundEntity = latestEntities.FirstOrDefault(x => Equals(x, list[i]));
+                        if (foundEntity != null)
+                        {
+                            list[i] = foundEntity;
+                            updated = true;
+                        }
+                    }
+
+                    if (updated)
+                    {
+                        args.EventObject = list;
+                    }
+                }
+            }
+        }
+
+        /// <summary>
+        /// This will check against all of the processed entity/events (allEntities) to see if this entity already exists in 
+        /// event args that supersede the event args being passed in and if so returns true.
+        /// </summary>
+        /// <param name="entity"></param>
+        /// <param name="eventDef"></param>
+        /// <param name="allEntities"></param>
+        /// <returns></returns>
+        private static bool IsFiltered(
+            IEntity entity,
+            EventDefinitionTypeData eventDef,
+            List<Tuple<IEntity, EventDefinitionTypeData>> allEntities)
+        {
+            var argType = eventDef.EventDefinition.Args.GetType();
+
+            //check if the entity is found in any processed event data that could possible supersede this one
+            var foundByEntity = allEntities
+                .Where(x => x.Item2.SupersedeAttributes.Length > 0
+                            //if it's the same arg type than it cannot supersede                
+                            && x.Item2.EventArgType != argType
+                            && Equals(x.Item1, entity))
+                .ToArray();
+
+            //no args have been processed with this entity so it should not be filtered
+            if (foundByEntity.Length == 0)
+                return false;
+
+            if (argType.IsGenericType)
+            {
+                var supercededBy = foundByEntity
+                    .FirstOrDefault(x =>
+                        x.Item2.SupersedeAttributes.Any(y =>
+                            //if the attribute type is a generic type def then compare with the generic type def of the event arg
+                                (y.SupersededEventArgsType.IsGenericTypeDefinition && y.SupersededEventArgsType == argType.GetGenericTypeDefinition())
+                                //if the attribute type is not a generic type def then compare with the normal type of the event arg
+                                || (y.SupersededEventArgsType.IsGenericTypeDefinition == false && y.SupersededEventArgsType == argType)));
+                return supercededBy != null;
+            }
+            else
+            {
+                var supercededBy = foundByEntity
+                    .FirstOrDefault(x =>
+                        x.Item2.SupersedeAttributes.Any(y =>
+                            //since the event arg type is not a generic type, then we just compare type 1:1
+                                y.SupersededEventArgsType == argType));
+                return supercededBy != null;
+            }
+        }
 
         public void ScopeExit(bool completed)
         {

src/Umbraco.Core/Events/SupersedeEventAttribute.cs

@@ -0,0 +1,20 @@
+using System;
+
+namespace Umbraco.Core.Events
+{
+    /// <summary>
+    /// This is used to know if the event arg attributed should supersede another event arg type when 
+    /// tracking events for the same entity. If one event args supercedes another then the event args that have been superseded
+    /// will mean that the event will not be dispatched or the args will be filtered to exclude the entity.
+    /// </summary>
+    [AttributeUsage(AttributeTargets.Class, AllowMultiple = true)]
+    internal class SupersedeEventAttribute : Attribute
+    {
+        public Type SupersededEventArgsType { get; private set; }
+
+        public SupersedeEventAttribute(Type supersededEventArgsType)
+        {
+            SupersededEventArgsType = supersededEventArgsType;
+        }
+    }
+}

src/Umbraco.Core/Exceptions/ConnectionException.cs

@@ -0,0 +1,12 @@
+using System;
+
+namespace Umbraco.Core.Exceptions
+{
+    internal class ConnectionException : Exception
+    {
+        public ConnectionException(string message, Exception innerException) : base(message, innerException)
+        {
+            
+        }
+    }
+}

src/Umbraco.Core/Exceptions/DataOperationException.cs

@@ -7,7 +7,7 @@ namespace Umbraco.Core.Exceptions
         public T Operation { get; private set; }
 
         public DataOperationException(T operation, string message)
-            :base(message)
+            : base(message)
         {
             Operation = operation;
         }

src/Umbraco.Core/HashCodeCombiner.cs

@@ -1,5 +1,4 @@
 using System;
-using System.Collections.Generic;
 using System.Globalization;
 using System.IO;
 using System.Linq;
@@ -7,32 +6,32 @@ using System.Text;
 
 namespace Umbraco.Core
 {
-	/// <summary>
-	/// Used to create a hash code from multiple objects.
-	/// </summary>
-	/// <remarks>
-	/// .Net has a class the same as this: System.Web.Util.HashCodeCombiner and of course it works for all sorts of things
-	/// which we've not included here as we just need a quick easy class for this in order to create a unique
-	/// hash of directories/files to see if they have changed.
-	/// </remarks>
-	internal class HashCodeCombiner
-	{
-		private long _combinedHash = 5381L;
+    /// <summary>
+    /// Used to create a hash code from multiple objects.
+    /// </summary>
+    /// <remarks>
+    /// .Net has a class the same as this: System.Web.Util.HashCodeCombiner and of course it works for all sorts of things
+    /// which we've not included here as we just need a quick easy class for this in order to create a unique
+    /// hash of directories/files to see if they have changed.
+    /// </remarks>
+    internal class HashCodeCombiner
+    {
+        private long _combinedHash = 5381L;
 
-		internal void AddInt(int i)
-		{
-			_combinedHash = ((_combinedHash << 5) + _combinedHash) ^ i;
-		}
+        internal void AddInt(int i)
+        {
+            _combinedHash = ((_combinedHash << 5) + _combinedHash) ^ i;
+        }
 
-		internal void AddObject(object o)
-		{
-			AddInt(o.GetHashCode());
-		}
+        internal void AddObject(object o)
+        {
+            AddInt(o.GetHashCode());
+        }
 
-		internal void AddDateTime(DateTime d)
-		{
-			AddInt(d.GetHashCode());
-		}
+        internal void AddDateTime(DateTime d)
+        {
+            AddInt(d.GetHashCode());
+        }
 
         internal void AddString(string s)
         {
@@ -40,61 +39,61 @@ namespace Umbraco.Core
                 AddInt((StringComparer.InvariantCulture).GetHashCode(s));
         }
 
-		internal void AddCaseInsensitiveString(string s)
-		{
-			if (s != null)
-				AddInt((StringComparer.InvariantCultureIgnoreCase).GetHashCode(s));
-		}
+        internal void AddCaseInsensitiveString(string s)
+        {
+            if (s != null)
+                AddInt((StringComparer.InvariantCultureIgnoreCase).GetHashCode(s));
+        }
 
-		internal void AddFileSystemItem(FileSystemInfo f)
-		{
-			//if it doesn't exist, don't proceed.
-			if (!f.Exists)
-				return;
+        internal void AddFileSystemItem(FileSystemInfo f)
+        {
+            //if it doesn't exist, don't proceed.
+            if (!f.Exists)
+                return;
 
-			AddCaseInsensitiveString(f.FullName);
-			AddDateTime(f.CreationTimeUtc);
-			AddDateTime(f.LastWriteTimeUtc);
-			
-			//check if it is a file or folder 
-			var fileInfo = f as FileInfo;
-			if (fileInfo != null)
-			{
-				AddInt(fileInfo.Length.GetHashCode());
-			}
-			
-			var dirInfo = f as DirectoryInfo;
-			if (dirInfo != null)
-			{
-				foreach (var d in dirInfo.GetFiles())
-				{
-					AddFile(d);
-				}
-				foreach (var s in dirInfo.GetDirectories())
-				{
-					AddFolder(s);
-				}
-			}
-		}
+            AddCaseInsensitiveString(f.FullName);
+            AddDateTime(f.CreationTimeUtc);
+            AddDateTime(f.LastWriteTimeUtc);
 
-		internal void AddFile(FileInfo f)
-		{
-			AddFileSystemItem(f);			
-		}
+            //check if it is a file or folder 
+            var fileInfo = f as FileInfo;
+            if (fileInfo != null)
+            {
+                AddInt(fileInfo.Length.GetHashCode());
+            }
 
-		internal void AddFolder(DirectoryInfo d)
-		{
-			AddFileSystemItem(d);			
-		}
+            var dirInfo = f as DirectoryInfo;
+            if (dirInfo != null)
+            {
+                foreach (var d in dirInfo.GetFiles())
+                {
+                    AddFile(d);
+                }
+                foreach (var s in dirInfo.GetDirectories())
+                {
+                    AddFolder(s);
+                }
+            }
+        }
 
-		/// <summary>
-		/// Returns the hex code of the combined hash code
-		/// </summary>
-		/// <returns></returns>
-		internal string GetCombinedHashCode()
-		{
-			return _combinedHash.ToString("x", CultureInfo.InvariantCulture);
-		}
+        internal void AddFile(FileInfo f)
+        {
+            AddFileSystemItem(f);
+        }
 
-	}
+        internal void AddFolder(DirectoryInfo d)
+        {
+            AddFileSystemItem(d);
+        }
+
+        /// <summary>
+        /// Returns the hex code of the combined hash code
+        /// </summary>
+        /// <returns></returns>
+        internal string GetCombinedHashCode()
+        {
+            return _combinedHash.ToString("x", CultureInfo.InvariantCulture);
+        }
+
+    }
 }

src/Umbraco.Core/HashCodeHelper.cs

@@ -0,0 +1,104 @@
+using System.Collections.Generic;
+
+namespace Umbraco.Core
+{
+    /// <summary>
+    /// Borrowed from http://stackoverflow.com/a/2575444/694494
+    /// </summary>
+    internal static class HashCodeHelper
+    {
+        public static int GetHashCode<T1, T2>(T1 arg1, T2 arg2)
+        {
+            unchecked
+            {
+                return 31 * arg1.GetHashCode() + arg2.GetHashCode();
+            }
+        }
+
+        public static int GetHashCode<T1, T2, T3>(T1 arg1, T2 arg2, T3 arg3)
+        {
+            unchecked
+            {
+                int hash = arg1.GetHashCode();
+                hash = 31 * hash + arg2.GetHashCode();
+                return 31 * hash + arg3.GetHashCode();
+            }
+        }
+
+        public static int GetHashCode<T1, T2, T3, T4>(T1 arg1, T2 arg2, T3 arg3,
+            T4 arg4)
+        {
+            unchecked
+            {
+                int hash = arg1.GetHashCode();
+                hash = 31 * hash + arg2.GetHashCode();
+                hash = 31 * hash + arg3.GetHashCode();
+                return 31 * hash + arg4.GetHashCode();
+            }
+        }
+
+        public static int GetHashCode<T>(T[] list)
+        {
+            unchecked
+            {
+                int hash = 0;
+                foreach (var item in list)
+                {
+                    if (item == null) continue;
+                    hash = 31 * hash + item.GetHashCode();
+                }
+                return hash;
+            }
+        }
+
+        public static int GetHashCode<T>(IEnumerable<T> list)
+        {
+            unchecked
+            {
+                int hash = 0;
+                foreach (var item in list)
+                {
+                    if (item == null) continue;
+                    hash = 31 * hash + item.GetHashCode();
+                }
+                return hash;
+            }
+        }
+
+        /// <summary>
+        /// Gets a hashcode for a collection for that the order of items 
+        /// does not matter.
+        /// So {1, 2, 3} and {3, 2, 1} will get same hash code.
+        /// </summary>
+        public static int GetHashCodeForOrderNoMatterCollection<T>(
+            IEnumerable<T> list)
+        {
+            unchecked
+            {
+                int hash = 0;
+                int count = 0;
+                foreach (var item in list)
+                {
+                    if (item == null) continue;
+                    hash += item.GetHashCode();
+                    count++;
+                }
+                return 31 * hash + count.GetHashCode();
+            }
+        }
+
+        /// <summary>
+        /// Alternative way to get a hashcode is to use a fluent 
+        /// interface like this:<br />
+        /// return 0.CombineHashCode(field1).CombineHashCode(field2).
+        ///     CombineHashCode(field3);
+        /// </summary>
+        public static int CombineHashCode<T>(this int hashCode, T arg)
+        {
+            unchecked
+            {
+                return 31 * hashCode + arg.GetHashCode();
+            }
+        }
+    }
+}

src/Umbraco.Core/IO/IFileSystem.cs

@@ -4,38 +4,144 @@ using System.IO;
 
 namespace Umbraco.Core.IO
 {
-	public interface IFileSystem
+    /// <summary>
+    /// Provides methods allowing the manipulation of files within an Umbraco application.
+    /// </summary>
+    public interface IFileSystem
     {
+        /// <summary>
+        /// Gets all directories matching the given path.
+        /// </summary>
+        /// <param name="path">The path to the directories.</param>
+        /// <returns>
+        /// The <see cref="IEnumerable{String}"/> representing the matched directories.
+        /// </returns>
         IEnumerable<string> GetDirectories(string path);
 
+        /// <summary>
+        /// Deletes the specified directory.
+        /// </summary>
+        /// <param name="path">The name of the directory to remove.</param>
         void DeleteDirectory(string path);
 
+        /// <summary>
+        /// Deletes the specified directory and, if indicated, any subdirectories and files in the directory.
+        /// </summary>
+        /// <remarks>Azure blob storage has no real concept of directories so deletion is always recursive.</remarks>
+        /// <param name="path">The name of the directory to remove.</param>
+        /// <param name="recursive">Whether to remove directories, subdirectories, and files in path.</param>
         void DeleteDirectory(string path, bool recursive);
 
+        /// <summary>
+        /// Determines whether the specified directory exists.
+        /// </summary>
+        /// <param name="path">The directory to check.</param>
+        /// <returns>
+        /// <c>True</c> if the directory exists and the user has permission to view it; otherwise <c>false</c>.
+        /// </returns>
         bool DirectoryExists(string path);
 
+        /// <summary>
+        /// Adds a file to the file system.
+        /// </summary>
+        /// <param name="path">The path to the given file.</param>
+        /// <param name="stream">The <see cref="Stream"/> containing the file contents.</param>
         void AddFile(string path, Stream stream);
 
+        /// <summary>
+        /// Adds a file to the file system.
+        /// </summary>
+        /// <param name="path">The path to the given file.</param>
+        /// <param name="stream">The <see cref="Stream"/> containing the file contents.</param>
+        /// <param name="overrideIfExists">Whether to override the file if it already exists.</param>
         void AddFile(string path, Stream stream, bool overrideIfExists);
 
+        /// <summary>
+        /// Gets all files matching the given path.
+        /// </summary>
+        /// <param name="path">The path to the files.</param>
+        /// <returns>
+        /// The <see cref="IEnumerable{String}"/> representing the matched files.
+        /// </returns>
         IEnumerable<string> GetFiles(string path);
 
+        /// <summary>
+        /// Gets all files matching the given path and filter.
+        /// </summary>
+        /// <param name="path">The path to the files.</param>
+        /// <param name="filter">A filter that allows the querying of file extension. <example>*.jpg</example></param>
+        /// <returns>
+        /// The <see cref="IEnumerable{String}"/> representing the matched files.
+        /// </returns>
         IEnumerable<string> GetFiles(string path, string filter);
 
+        /// <summary>
+        /// Gets a <see cref="Stream"/> representing the file at the gieven path.
+        /// </summary>
+        /// <param name="path">The path to the file.</param>
+        /// <returns>
+        /// <see cref="Stream"/>.
+        /// </returns>
         Stream OpenFile(string path);
 
+        /// <summary>
+        /// Deletes the specified file.
+        /// </summary>
+        /// <param name="path">The name of the file to remove.</param>
         void DeleteFile(string path);
 
+        /// <summary>
+        /// Determines whether the specified file exists.
+        /// </summary>
+        /// <param name="path">The file to check.</param>
+        /// <returns>
+        /// <c>True</c> if the file exists and the user has permission to view it; otherwise <c>false</c>.
+        /// </returns>
         bool FileExists(string path);
 
+        /// <summary>
+        /// Returns the application relative path to the file.
+        /// </summary>
+        /// <param name="fullPathOrUrl">The full path or url.</param>
+        /// <returns>
+        /// The <see cref="string"/> representing the relative path.
+        /// </returns>
         string GetRelativePath(string fullPathOrUrl);
 
+        /// <summary>
+        /// Gets the full qualified path to the file.
+        /// </summary>
+        /// <param name="path">The file to return the full path for.</param>
+        /// <returns>
+        /// The <see cref="string"/> representing the full path.
+        /// </returns>
         string GetFullPath(string path);
 
+        /// <summary>
+        /// Returns the application relative url to the file.
+        /// </summary>
+        /// <param name="path">The path to return the url for.</param>
+        /// <returns>
+        /// <see cref="string"/> representing the relative url.
+        /// </returns>
         string GetUrl(string path);
 
+        /// <summary>
+        /// Gets the last modified date/time of the file, expressed as a UTC value.
+        /// </summary>
+        /// <param name="path">The path to the file.</param>
+        /// <returns>
+        /// <see cref="DateTimeOffset"/>.
+        /// </returns>
         DateTimeOffset GetLastModified(string path);
 
+        /// <summary>
+        /// Gets the created date/time of the file, expressed as a UTC value.
+        /// </summary>
+        /// <param name="path">The path to the file.</param>
+        /// <returns>
+        /// <see cref="DateTimeOffset"/>.
+        /// </returns>
         DateTimeOffset GetCreated(string path);
     }
 

src/Umbraco.Core/IO/PhysicalFileSystem.cs

@@ -158,7 +158,7 @@ namespace Umbraco.Core.IO
             // if can seek, be safe and go back to start, else...
             // hope that the stream hasn't been read already
             if (stream.CanSeek)
-                stream.Seek(0, 0);
+                stream.Seek(0, SeekOrigin.Begin);
 
             using (var destination = (Stream) File.Create(fullPath))
                 stream.CopyTo(destination);

src/Umbraco.Core/IO/ShadowWrapper.cs

@@ -52,9 +52,20 @@ namespace Umbraco.Core.IO
                 try
                 {
                     Directory.Delete(dir, true);
-                    dir = dir.Substring(0, dir.Length - _shadowPath.Length - 1);
-                    if (Directory.EnumerateFileSystemEntries(dir).Any() == false)
-                        Directory.Delete(dir, true);
+
+                    // shadowPath make be path/to/dir, remove each
+                    dir = dir.Replace("/", "\\");
+                    var min = IOHelper.MapPath("~/App_Data/TEMP/ShadowFs").Length;
+                    var pos = dir.LastIndexOf("\\", StringComparison.OrdinalIgnoreCase);
+                    while (pos > min)
+                    {
+                        dir = dir.Substring(0, pos);
+                        if (Directory.EnumerateFileSystemEntries(dir).Any() == false)
+                            Directory.Delete(dir, true);
+                        else
+                            break;
+                        pos = dir.LastIndexOf("\\", StringComparison.OrdinalIgnoreCase);
+                    }
                 }
                 catch
                 {

src/Umbraco.Core/Logging/AsynchronousRollingFileAppender.cs

@@ -16,7 +16,7 @@ namespace Umbraco.Core.Logging
     /// This is an old/deprecated logger and has been superceded by ParallelForwardingAppender which is included in Umbraco and 
     /// also by AsyncForwardingAppender in the Log4Net.Async library.
 	/// </summary>
-	[Obsolete("This is superceded by the ParallelForwardingAppender, this will be removed in v8")]
+	[Obsolete("This is superceded by the ParallelForwardingAppender, this will be removed in v8, do not use this")]
     [EditorBrowsable(EditorBrowsableState.Never)]
 	public class AsynchronousRollingFileAppender : RollingFileAppender
 	{

src/Umbraco.Core/Logging/ParallelForwardingAppender.cs

@@ -13,301 +13,8 @@ namespace Umbraco.Core.Logging
     /// <remarks>
     /// Borrowed from https://github.com/cjbhaines/Log4Net.Async - will reference Nuget packages directly in v8
     /// </remarks>
-    public class ParallelForwardingAppender : AsyncForwardingAppenderBase, IDisposable
+    [Obsolete("Use the Log4Net.Async.ParallelForwardingAppender instead this will be removed in future versions")]
+    public class ParallelForwardingAppender : Log4Net.Async.ParallelForwardingAppender
     {
-        #region Private Members
-
-        private const int DefaultBufferSize = 1000;
-        private BlockingCollection<LoggingEventContext> _loggingEvents;
-        private CancellationTokenSource _loggingCancelationTokenSource;
-        private CancellationToken _loggingCancelationToken;
-        private Task _loggingTask;
-        private Double _shutdownFlushTimeout = 2;
-        private TimeSpan _shutdownFlushTimespan = TimeSpan.FromSeconds(2);
-        private static readonly Type ThisType = typeof(ParallelForwardingAppender);
-        private volatile bool shutDownRequested;
-        private int? bufferSize = DefaultBufferSize;
-
-        #endregion Private Members
-
-        #region Properties
-
-        /// <summary>
-        /// Gets or sets the number of LoggingEvents that will be buffered.  Set to null for unlimited.
-        /// </summary>
-        public override int? BufferSize
-        {
-            get { return bufferSize; }
-            set { bufferSize = value; }
-        }
-
-        public int BufferEntryCount
-        {
-            get
-            {
-                if (_loggingEvents == null) return 0;
-                return _loggingEvents.Count;
-            }
-        }
-
-        /// <summary>
-        /// Gets or sets the time period in which the system will wait for appenders to flush before canceling the background task.
-        /// </summary>
-        public Double ShutdownFlushTimeout
-        {
-            get
-            {
-                return _shutdownFlushTimeout;
-            }
-            set
-            {
-                _shutdownFlushTimeout = value;
-            }
-        }
-
-        protected override string InternalLoggerName
-        {
-            get
-            {
-                {
-                    return "ParallelForwardingAppender";
-                }
-            }
-        }
-
-        #endregion Properties
-
-        #region Startup
-
-        public override void ActivateOptions()
-        {
-            base.ActivateOptions();
-            _shutdownFlushTimespan = TimeSpan.FromSeconds(_shutdownFlushTimeout);
-            StartForwarding();
-        }
-
-        private void StartForwarding()
-        {
-            if (shutDownRequested)
-            {
-                return;
-            }
-            //Create a collection which will block the thread and wait for new entries
-            //if the collection is empty
-            if (BufferSize.HasValue && BufferSize > 0)
-            {
-                _loggingEvents = new BlockingCollection<LoggingEventContext>(BufferSize.Value);
-            }
-            else
-            {
-                //No limit on the number of events.
-                _loggingEvents = new BlockingCollection<LoggingEventContext>();
-            }
-            //The cancellation token is used to cancel a running task gracefully.
-            _loggingCancelationTokenSource = new CancellationTokenSource();
-            _loggingCancelationToken = _loggingCancelationTokenSource.Token;
-            _loggingTask = new Task(SubscriberLoop, _loggingCancelationToken);
-            _loggingTask.Start();
-        }
-
-        #endregion Startup
-
-        #region Shutdown
-
-        private void CompleteSubscriberTask()
-        {
-            shutDownRequested = true;
-            if (_loggingEvents == null || _loggingEvents.IsAddingCompleted)
-            {
-                return;
-            }
-            //Don't allow more entries to be added.
-            _loggingEvents.CompleteAdding();
-            //Allow some time to flush
-            Thread.Sleep(_shutdownFlushTimespan);
-            if (!_loggingTask.IsCompleted && !_loggingCancelationToken.IsCancellationRequested)
-            {
-                _loggingCancelationTokenSource.Cancel();
-                //Wait here so that the error logging messages do not get into a random order.
-                //Don't pass the cancellation token because we are not interested
-                //in catching the OperationCanceledException that results.
-                _loggingTask.Wait();
-            }
-            if (!_loggingEvents.IsCompleted)
-            {
-                ForwardInternalError("The buffer was not able to be flushed before timeout occurred.", null, ThisType);
-            }
-        }
-
-        protected override void OnClose()
-        {
-            CompleteSubscriberTask();
-            base.OnClose();
-        }
-
-        #endregion Shutdown
-
-        #region Appending
-
-        protected override void Append(LoggingEvent loggingEvent)
-        {
-            if (_loggingEvents == null || _loggingEvents.IsAddingCompleted || loggingEvent == null)
-            {
-                return;
-            }
-
-            loggingEvent.Fix = Fix;
-            //In the case where blocking on a full collection, and the task is subsequently completed, the cancellation token
-            //will prevent the entry from attempting to add to the completed collection which would result in an exception.
-            _loggingEvents.Add(new LoggingEventContext(loggingEvent, HttpContext), _loggingCancelationToken);
-        }
-
-        protected override void Append(LoggingEvent[] loggingEvents)
-        {
-            if (_loggingEvents == null || _loggingEvents.IsAddingCompleted || loggingEvents == null)
-            {
-                return;
-            }
-
-            foreach (var loggingEvent in loggingEvents)
-            {
-                Append(loggingEvent);
-            }
-        }
-
-        #endregion Appending
-
-        #region Forwarding
-
-        /// <summary>
-        /// Iterates over a BlockingCollection containing LoggingEvents.
-        /// </summary>
-        private void SubscriberLoop()
-        {
-            Thread.CurrentThread.Name = String.Format("{0} ParallelForwardingAppender Subscriber Task", Name);
-            //The task will continue in a blocking loop until
-            //the queue is marked as adding completed, or the task is canceled.
-            try
-            {
-                //This call blocks until an item is available or until adding is completed
-                foreach (var entry in _loggingEvents.GetConsumingEnumerable(_loggingCancelationToken))
-                {
-                    HttpContext = entry.HttpContext;
-                    ForwardLoggingEvent(entry.LoggingEvent, ThisType);
-                }
-            }
-            catch (OperationCanceledException ex)
-            {
-                //The thread was canceled before all entries could be forwarded and the collection completed.
-                ForwardInternalError("Subscriber task was canceled before completion.", ex, ThisType);
-                //Cancellation is called in the CompleteSubscriberTask so don't call that again.
-            }
-            catch (ThreadAbortException ex)
-            {
-                //Thread abort may occur on domain unload.
-                ForwardInternalError("Subscriber task was aborted.", ex, ThisType);
-                //Cannot recover from a thread abort so complete the task.
-                CompleteSubscriberTask();
-                //The exception is swallowed because we don't want the client application
-                //to halt due to a logging issue.
-            }
-            catch (Exception ex)
-            {
-                //On exception, try to log the exception
-                ForwardInternalError("Subscriber task error in forwarding loop.", ex, ThisType);
-                //Any error in the loop is going to be some sort of extenuating circumstance from which we
-                //probably cannot recover anyway.   Complete subscribing.
-                CompleteSubscriberTask();
-            }
-        }
-
-        #endregion Forwarding
-
-        #region IDisposable Implementation
-
-        private bool _disposed = false;
-
-        //Implement IDisposable.
-        public void Dispose()
-        {
-            Dispose(true);
-            GC.SuppressFinalize(this);
-        }
-
-        protected virtual void Dispose(bool disposing)
-        {
-            if (!_disposed)
-            {
-                if (disposing)
-                {
-                    if (_loggingTask != null)
-                    {
-                        if (!(_loggingTask.IsCanceled || _loggingTask.IsCompleted || _loggingTask.IsFaulted))
-                        {
-                            try
-                            {
-                                CompleteSubscriberTask();
-                            }
-                            catch (Exception ex)
-                            {
-                                LogLog.Error(ThisType, "Exception Completing Subscriber Task in Dispose Method", ex);
-                            }
-                        }
-                        try
-                        {
-                            _loggingTask.Dispose();
-                        }
-                        catch (Exception ex)
-                        {
-                            LogLog.Error(ThisType, "Exception Disposing Logging Task", ex);
-                        }
-                        finally
-                        {
-                            _loggingTask = null;
-                        }
-                    }
-                    if (_loggingEvents != null)
-                    {
-                        try
-                        {
-                            _loggingEvents.Dispose();
-                        }
-                        catch (Exception ex)
-                        {
-                            LogLog.Error(ThisType, "Exception Disposing BlockingCollection", ex);
-                        }
-                        finally
-                        {
-                            _loggingEvents = null;
-                        }
-                    }
-                    if (_loggingCancelationTokenSource != null)
-                    {
-                        try
-                        {
-                            _loggingCancelationTokenSource.Dispose();
-                        }
-                        catch (Exception ex)
-                        {
-                            LogLog.Error(ThisType, "Exception Disposing CancellationTokenSource", ex);
-                        }
-                        finally
-                        {
-                            _loggingCancelationTokenSource = null;
-                        }
-                    }
-                }
-                _disposed = true;
-            }
-        }
-
-        // Use C# destructor syntax for finalization code.
-        ~ParallelForwardingAppender()
-        {
-            // Simply call Dispose(false).
-            Dispose(false);
-        }
-
-        #endregion IDisposable Implementation
     }
 }

src/Umbraco.Core/Models/ContentXmlEntity.cs

@@ -42,6 +42,7 @@ namespace Umbraco.Core.Models
         public Guid Key { get; set; }
         public DateTime CreateDate { get; set; }
         public DateTime UpdateDate { get; set; }
+        public DateTime? DeletedDate { get; set; }
 
         /// <summary>
         /// Special case, always return false, this will cause the repositories managing 
@@ -60,5 +61,7 @@ namespace Umbraco.Core.Models
             DeepCloneHelper.DeepCloneRefProperties(this, clone);
             return clone;
         }
+
+        
     }
 }

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

@@ -101,6 +101,9 @@ namespace Umbraco.Core.Models.EntityBase
             set { SetPropertyValueAndDetectChanges(value, ref _updateDate, Ps.Value.UpdateDateSelector); }           
         }
 
+        [IgnoreDataMember]
+        public DateTime? DeletedDate { get; set; }
+
         internal virtual void ResetIdentity()
         {
             _hasIdentity = false;

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

@@ -3,7 +3,7 @@
     /// <summary>
     /// Marker interface for aggregate roots
     /// </summary>
-    public interface IAggregateRoot : IEntity
+    public interface IAggregateRoot : IDeletableEntity
     {
          
     }

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

@@ -0,0 +1,11 @@
+using System;
+using System.Runtime.Serialization;
+
+namespace Umbraco.Core.Models.EntityBase
+{
+    public interface IDeletableEntity : IEntity
+    {
+        [DataMember]
+        DateTime? DeletedDate { get; set; }
+    }
+}

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

@@ -20,7 +20,7 @@ namespace Umbraco.Core.Models.EntityBase
         /// <summary>
         /// Guid based Id
         /// </summary>
-        /// <remarks>The key is currectly used to store the Unique Id from the 
+        /// <remarks>The key is currectly used to store the Unique Id from the
         /// umbracoNode table, which many of the entities are based on.</remarks>
         [DataMember]
         Guid Key { get; set; }

src/Umbraco.Core/OrderedHashSet.cs

@@ -11,7 +11,7 @@ namespace Umbraco.Core
     {
         private readonly bool _keepOldest;
 
-        public OrderedHashSet(bool keepOldest = true)
+        public OrderedHashSet(bool keepOldest = true) 
         {
             _keepOldest = keepOldest;
         }

src/Umbraco.Core/Persistence/Migrations/Syntax/Alter/AlterSyntaxBuilder.cs

@@ -1,4 +1,5 @@
-using Umbraco.Core.Persistence.Migrations.Syntax.Alter.Column;
+using System;
+using Umbraco.Core.Persistence.Migrations.Syntax.Alter.Column;
 using Umbraco.Core.Persistence.Migrations.Syntax.Alter.Expressions;
 using Umbraco.Core.Persistence.Migrations.Syntax.Alter.Table;
 using Umbraco.Core.Persistence.SqlSyntax;
@@ -25,6 +26,15 @@ namespace Umbraco.Core.Persistence.Migrations.Syntax.Alter
             return new AlterTableBuilder(_context, _databaseProviders, expression);
         }
 
+        /// <summary>
+        /// The problem with this is that only under particular circumstances is the expression added to the context
+        /// so you wouldn't actually know if you are using it correctly or not and chances are you are not and therefore
+        /// the statement won't even execute whereas using the IAlterTableSyntax to modify a column is guaranteed to add
+        /// the expression to the context.
+        /// </summary>
+        /// <param name="columnName"></param>
+        /// <returns></returns>
+        [Obsolete("Use the IAlterTableSyntax to modify a column instead, this will be removed in future versions")]
         public IAlterColumnSyntax Column(string columnName)
         {
             var expression = new AlterColumnExpression(_context.CurrentDatabaseProvider, _databaseProviders, _sqlSyntax) {Column = {Name = columnName}};

src/Umbraco.Core/Persistence/Migrations/Syntax/Alter/IAlterSyntaxBuilder.cs

@@ -1,11 +1,22 @@
-using Umbraco.Core.Persistence.Migrations.Syntax.Alter.Column;
+using System;
+using Umbraco.Core.Persistence.Migrations.Syntax.Alter.Column;
 using Umbraco.Core.Persistence.Migrations.Syntax.Alter.Table;
 
 namespace Umbraco.Core.Persistence.Migrations.Syntax.Alter
 {
     public interface IAlterSyntaxBuilder : IFluentSyntax
     {
-        IAlterTableSyntax Table(string tableName);
+        IAlterTableSyntax Table(string tableName);
+
+        /// <summary>
+        /// The problem with this is that only under particular circumstances is the expression added to the context
+        /// so you wouldn't actually know if you are using it correctly or not and chances are you are not and therefore
+        /// the statement won't even execute whereas using the IAlterTableSyntax to modify a column is guaranteed to add
+        /// the expression to the context.
+        /// </summary>
+        /// <param name="columnName"></param>
+        /// <returns></returns>
+        [Obsolete("Use the IAlterTableSyntax to modify a column instead, this will be removed in future versions")]
         IAlterColumnSyntax Column(string columnName);
     }
 }

src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSevenSixZero/AddIndexToCmsMemberLoginName.cs

@@ -4,7 +4,7 @@ using Umbraco.Core.Persistence.SqlSyntax;
 
 namespace Umbraco.Core.Persistence.Migrations.Upgrades.TargetVersionSevenSixZero
 {
-    [Migration("7.6.0", 0, Constants.System.UmbracoMigrationName)]
+    [Migration("7.6.0", 3, Constants.System.UmbracoMigrationName)]
     public class AddIndexToCmsMemberLoginName : MigrationBase
     {
         public AddIndexToCmsMemberLoginName(ISqlSyntaxProvider sqlSyntax, ILogger logger)
@@ -12,18 +12,43 @@ namespace Umbraco.Core.Persistence.Migrations.Upgrades.TargetVersionSevenSixZero
         { }
 
         public override void Up()
-        {
-            var dbIndexes = SqlSyntax.GetDefinedIndexesDefinitions(Context.Database);
-
-            //make sure it doesn't already exist
-            if (dbIndexes.Any(x => x.IndexName.InvariantEquals("IX_cmsMember_LoginName")) == false)
+        {   
+            Execute.Code(database =>
             {
-                Create.Index("IX_cmsMember_LoginName").OnTable("cmsMember")
-                    .OnColumn("LoginName")
-                    .Ascending()
-                    .WithOptions()
-                    .NonClustered();
-            }
+                //Now we need to check if we can actually d6 this because we won't be able to if there's data in there that is too long
+                //http://issues.umbraco.org/issue/U4-9758
+
+                var colLen = (SqlSyntax is MySqlSyntaxProvider)
+                    ? database.ExecuteScalar<int?>("select max(LENGTH(LoginName)) from cmsMember")
+                    : database.ExecuteScalar<int?>("select max(datalength(LoginName)) from cmsMember");
+
+                if (colLen < 900 == false && colLen != null)
+                {
+                    return null;
+                }
+
+                var dbIndexes = SqlSyntax.GetDefinedIndexesDefinitions(Context.Database);
+
+                //make sure it doesn't already exist
+                if (dbIndexes.Any(x => x.IndexName.InvariantEquals("IX_cmsMember_LoginName")) == false)
+                {
+                    var localContext = new LocalMigrationContext(Context.CurrentDatabaseProvider, database, SqlSyntax, Logger);
+
+                    //we can apply the index
+                    localContext.Create.Index("IX_cmsMember_LoginName").OnTable("cmsMember")
+                        .OnColumn("LoginName")
+                        .Ascending()
+                        .WithOptions()
+                        .NonClustered();
+
+                    return localContext.GetSql();
+                }
+
+                return null;
+
+            });
+
+            
         }
 
         public override void Down()

src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSevenSixZero/AddLockObjects.cs

@@ -1,11 +1,10 @@
-using Umbraco.Core.Configuration;
-using Umbraco.Core.Logging;
+using Umbraco.Core.Logging;
 using Umbraco.Core.Models.Rdbms;
 using Umbraco.Core.Persistence.SqlSyntax;
 
-namespace Umbraco.Core.Persistence.Migrations.Upgrades.TargetVersionSevenFiveFive
+namespace Umbraco.Core.Persistence.Migrations.Upgrades.TargetVersionSevenSixZero
 {
-    [Migration("7.5.5", 101, Constants.System.UmbracoMigrationName)]
+    [Migration("7.6.0", 101, Constants.System.UmbracoMigrationName)]
     public class AddLockObjects : MigrationBase
     {
         public AddLockObjects(ISqlSyntaxProvider sqlSyntax, ILogger logger)

src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSevenSixZero/AddLockTable.cs

@@ -1,11 +1,10 @@
 using System.Linq;
-using Umbraco.Core.Configuration;
 using Umbraco.Core.Logging;
 using Umbraco.Core.Persistence.SqlSyntax;
 
-namespace Umbraco.Core.Persistence.Migrations.Upgrades.TargetVersionSevenFiveFive
+namespace Umbraco.Core.Persistence.Migrations.Upgrades.TargetVersionSevenSixZero
 {
-    [Migration("7.5.5", 100, Constants.System.UmbracoMigrationName)]
+    [Migration("7.6.0", 100, Constants.System.UmbracoMigrationName)]
     public class AddLockTable : MigrationBase
     {
         public AddLockTable(ISqlSyntaxProvider sqlSyntax, ILogger logger)

src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSevenSixZero/NormalizeTemplateGuids.cs

@@ -0,0 +1,50 @@
+using System;
+using System.Linq;
+using Umbraco.Core.Logging;
+using Umbraco.Core.Persistence.SqlSyntax;
+
+namespace Umbraco.Core.Persistence.Migrations.Upgrades.TargetVersionSevenSixZero
+{
+    [Migration("7.6.0", 0, Constants.System.UmbracoMigrationName)]
+    public class NormalizeTemplateGuids : MigrationBase
+    {
+        public NormalizeTemplateGuids(ISqlSyntaxProvider sqlSyntax, ILogger logger)
+            : base(sqlSyntax, logger)
+        { }
+
+        public override void Up()
+        {
+            Execute.Code(UpdateTemplateGuids);
+        }
+
+        private static string UpdateTemplateGuids(Database database)
+        {
+            // we need this migration because ppl running pre-7.6 on Cloud and Courier have templates in different
+            // environments having different GUIDs (Courier does not sync template GUIDs) and we need to normalize
+            // these GUIDs so templates with the same alias on different environments have the same GUID.
+            // however, if already running a prerelease version of 7.6, we do NOT want to normalize the GUIDs as quite
+            // probably, we are already running Deploy and the GUIDs are OK. assuming noone is running a prerelease
+            // of 7.6 on Courier.
+            // so... testing if we already have a 7.6.0 version installed. not pretty but...?
+            //
+            var version = database.FirstOrDefault<string>("SELECT version FROM umbracoMigration WHERE name=@name ORDER BY version DESC", new { name = Constants.System.UmbracoMigrationName });
+            if (version != null && version.StartsWith("7.6.0")) return string.Empty;
+
+            var updates = database.Query<dynamic>(@"SELECT umbracoNode.id, cmsTemplate.alias FROM umbracoNode 
+JOIN cmsTemplate ON umbracoNode.id=cmsTemplate.nodeId
+WHERE nodeObjectType = @guid", new { guid = Constants.ObjectTypes.TemplateTypeGuid})
+                .Select(template => Tuple.Create((int) template.id, ("template____" + (string) template.alias).ToGuid()))
+                .ToList();
+
+            foreach (var update in updates)
+                database.Execute("UPDATE umbracoNode set uniqueId=@guid WHERE id=@id", new { guid = update.Item2, id = update.Item1 });
+
+            return string.Empty;
+        }
+
+        public override void Down()
+        {
+            throw new NotImplementedException();
+        }
+    }
+}

src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSevenSixZero/ReduceLoginNameColumnsSize.cs

@@ -0,0 +1,52 @@
+using System.Linq;
+using Umbraco.Core.Logging;
+using Umbraco.Core.Persistence.SqlSyntax;
+
+namespace Umbraco.Core.Persistence.Migrations.Upgrades.TargetVersionSevenSixZero
+{
+    [Migration("7.6.0", 2, Constants.System.UmbracoMigrationName)]
+    public class ReduceLoginNameColumnsSize : MigrationBase
+    {
+        public ReduceLoginNameColumnsSize(ISqlSyntaxProvider sqlSyntax, ILogger logger)
+            : base(sqlSyntax, logger)
+        { }
+
+        public override void Up()
+        {
+            //Now we need to check if we can actually d6 this because we won't be able to if there's data in there that is too long
+            //http://issues.umbraco.org/issue/U4-9758
+
+            Execute.Code(database =>
+            {
+                var dbIndexes = SqlSyntax.GetDefinedIndexesDefinitions(database);
+
+                var colLen = (SqlSyntax is MySqlSyntaxProvider)
+                    ? database.ExecuteScalar<int?>("select max(LENGTH(LoginName)) from cmsMember")
+                    : database.ExecuteScalar<int?>("select max(datalength(LoginName)) from cmsMember");
+
+                if (colLen < 900 == false) return null;
+                
+                var localContext = new LocalMigrationContext(Context.CurrentDatabaseProvider, database, SqlSyntax, Logger);
+
+                //if it exists we need to drop it first
+                if (dbIndexes.Any(x => x.IndexName.InvariantEquals("IX_cmsMember_LoginName")))
+                {
+                    localContext.Delete.Index("IX_cmsMember_LoginName").OnTable("cmsMember");
+                }
+
+                //we can apply the col length change
+                localContext.Alter.Table("cmsMember")
+                    .AlterColumn("LoginName")
+                    .AsString(225)
+                    .NotNullable();
+
+                return localContext.GetSql();
+            });
+        }
+
+        public override void Down()
+        {
+            
+        }
+    }
+}

src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSevenThreeZero/UpdateUniqueIdToHaveCorrectIndexType.cs

@@ -29,7 +29,7 @@ namespace Umbraco.Core.Persistence.Migrations.Upgrades.TargetVersionSevenThreeZe
                 }).ToArray();
 
             //must be non-nullable
-            Alter.Column("uniqueID").OnTable("umbracoNode").AsGuid().NotNullable();
+            Alter.Table("umbracoNode").AlterColumn("uniqueID").AsGuid().NotNullable();
 
             //make sure it already exists
             if (dbIndexes.Any(x => x.IndexName.InvariantEquals("IX_umbracoNodeUniqueID")))

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

@@ -70,6 +70,8 @@ namespace Umbraco.Core.Persistence.Repositories
         {
             //Remove 'published' xml from the cmsContentXml table for the unpublished content
             Database.Delete<ContentXmlDto>("WHERE nodeId = @Id", new { Id = entity.Id });
+
+            entity.DeletedDate = DateTime.Now;
         }
 
         protected override void PersistNewItem(ContentXmlEntity<TContent> entity)

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

@@ -270,6 +270,8 @@ AND umbracoNode.id <> @id",
 
             //Delete (base) node data
             Database.Delete<NodeDto>("WHERE uniqueID = @Id", new { Id = entity.Key });
+
+            entity.DeletedDate = DateTime.Now;
         }
 
         #endregion
@@ -539,6 +541,8 @@ AND umbracoNode.id <> @id",
                 Database.Execute(
                     "DELETE FROM cmsDataTypePreValues WHERE id=@Id",
                     new { Id = entity.Id });
+
+                entity.DeletedDate = DateTime.Now;
             }
 
             protected override void PersistNewItem(PreValueEntity entity)

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

@@ -195,6 +195,8 @@ namespace Umbraco.Core.Persistence.Repositories
             //Clear the cache entries that exist by uniqueid/item key
             IsolatedCache.ClearCacheItem(GetCacheIdKey<IDictionaryItem>(entity.ItemKey));
             IsolatedCache.ClearCacheItem(GetCacheIdKey<IDictionaryItem>(entity.Key));
+
+            entity.DeletedDate = DateTime.Now;
         }
 
         private void RecursiveDelete(Guid parentId)

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

@@ -167,6 +167,8 @@ namespace Umbraco.Core.Persistence.Repositories
 
             // delete
             Database.Delete(nodeDto);
+
+            entity.DeletedDate = DateTime.Now;
         }
 
         protected override void PersistNewItem(EntityContainer entity)

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

@@ -74,6 +74,7 @@ namespace Umbraco.Core.Persistence.Repositories
             {
                 Database.Execute(delete, new { Id = GetEntityId(entity) });
             }
+            entity.DeletedDate = DateTime.Now;
         }
     }
 }

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

@@ -132,6 +132,11 @@ namespace Umbraco.Core.Persistence.Repositories
 
             Database.Update(dto);
 
+            foreach (var removedRule in entity.RemovedRules)
+            {
+                Database.Delete<AccessRuleDto>("WHERE id=@Id", new { Id = removedRule });
+            }
+
             foreach (var rule in entity.Rules)
             {
                 if (rule.HasIdentity)
@@ -157,10 +162,6 @@ namespace Umbraco.Core.Persistence.Repositories
                     rule.Id = rule.Key.GetHashCode();
                 }
             }
-            foreach (var removedRule in entity.RemovedRules)
-            {
-                Database.Delete<AccessRuleDto>("WHERE id=@Id", new {Id = removedRule});
-            }
 
             entity.ClearRemovedRules();
 

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

@@ -311,6 +311,8 @@ namespace Umbraco.Core.Persistence.Repositories
                 var masterpageName = string.Concat(entity.Alias, ".master");
                 _masterpagesFileSystem.DeleteFile(masterpageName);
             }
+
+            entity.DeletedDate = DateTime.Now;
         }
 
         #endregion

src/Umbraco.Core/Persistence/UnitOfWork/IScopeUnitOfWork.cs

@@ -8,5 +8,6 @@ namespace Umbraco.Core.Persistence.UnitOfWork
         IScope Scope { get; }
         EventMessages Messages { get; }
         IEventDispatcher Events { get; }
+        void Flush();
     }
 }

src/Umbraco.Core/Persistence/UnitOfWork/ScopeUnitOfWork.cs

@@ -160,7 +160,33 @@ namespace Umbraco.Core.Persistence.UnitOfWork
             _key = Guid.NewGuid();
         }
 
-		public object Key
+        public void Flush()
+        {
+            if (_readOnly)
+                throw new NotSupportedException("This unit of work is read-only.");
+
+            while (_operations.Count > 0)
+            {
+                var operation = _operations.Dequeue();
+                switch (operation.Type)
+                {
+                    case TransactionType.Insert:
+                        operation.Repository.PersistNewItem(operation.Entity);
+                        break;
+                    case TransactionType.Delete:
+                        operation.Repository.PersistDeletedItem(operation.Entity);
+                        break;
+                    case TransactionType.Update:
+                        operation.Repository.PersistUpdatedItem(operation.Entity);
+                        break;
+                }
+            }
+
+            _operations.Clear();
+            _key = Guid.NewGuid();
+        }
+
+        public object Key
 		{
 			get { return _key; }
 		}

src/Umbraco.Core/PropertyEditors/ParameterEditorResolver.cs

@@ -14,13 +14,13 @@ namespace Umbraco.Core.PropertyEditors
     /// </summary>
     /// <remarks>
     /// This resolver will contain any parameter editors defined in manifests as well as any property editors defined in manifests
-    /// that have the IsParameterEditorFlag = true and any PropertyEditors found in c# that have this flag as well. 
+    /// that have the IsParameterEditorFlag = true and any PropertyEditors found in c# that have this flag as well.
     /// </remarks>
     internal class ParameterEditorResolver : LazyManyObjectsResolverBase<ParameterEditorResolver, IParameterEditor>
     {
         private readonly ManifestBuilder _builder;
         private readonly IContentSection _contentSection;
-        
+
         public ParameterEditorResolver(IServiceProvider serviceProvider, ILogger logger, Func<IEnumerable<Type>> typeListProducerList, ManifestBuilder builder)
             : base(serviceProvider, logger, typeListProducerList, ObjectLifetimeScope.Application)
         {
@@ -33,47 +33,51 @@ namespace Umbraco.Core.PropertyEditors
         /// </summary>
         public IEnumerable<IParameterEditor> ParameterEditors
         {
-            get
+            get { return GetParameterEditors(); }
+        }
+
+        public IEnumerable<IParameterEditor> GetParameterEditors(bool includeDeprecated = false)
+        {
+            // all property editors and parameter editors
+            // except property editors where !IsParameterEditor
+            var values = Values
+                .Where(x => x is PropertyEditor == false || ((PropertyEditor) x).IsParameterEditor);
+
+            // union all manifest parameter editors
+            values = values
+                .Union(_builder.ParameterEditors);
+
+            // union all manifest property editors where IsParameterEditor
+            values = values
+                .Union(_builder.PropertyEditors.Where(x => x.IsParameterEditor));
+
+            if (includeDeprecated == false && _contentSection.ShowDeprecatedPropertyEditors == false)
             {
-                // all property editors and parameter editors
-                // except property editors where !IsParameterEditor
-                var values = Values
-                    .Where(x => x is PropertyEditor == false || ((PropertyEditor) x).IsParameterEditor);
-
-                // union all manifest parameter editors
+                // except deprecated property editors
                 values = values
-                    .Union(_builder.ParameterEditors);
-
-                // union all manifest property editors where IsParameterEditor
-                values = values
-                    .Union(_builder.PropertyEditors.Where(x => x.IsParameterEditor));
-
-                if (_contentSection.ShowDeprecatedPropertyEditors == false)
-                {
-                    // except deprecated property editors
-                    values = values
-                        .Where(x => x is PropertyEditor == false || ((PropertyEditor) x).IsDeprecated == false);
-                }
-
-                return values;
+                    .Where(x => x is PropertyEditor == false || ((PropertyEditor) x).IsDeprecated == false);
             }
+
+            return values;
         }
 
         /// <summary>
         /// Returns a property editor by alias
         /// </summary>
         /// <param name="alias"></param>
+        /// <param name="includeDeprecated"></param>
         /// <returns></returns>
-        public IParameterEditor GetByAlias(string alias)
+        public IParameterEditor GetByAlias(string alias, bool includeDeprecated = false)
         {
-            var found = ParameterEditors.SingleOrDefault(x => x.Alias == alias);
+            var paramEditors = GetParameterEditors(includeDeprecated).ToArray();
+            var found = paramEditors.SingleOrDefault(x => x.Alias == alias);
             if (found != null) return found;
-            
+
             //couldn't find one, so try the map
             var mapped = LegacyParameterEditorAliasConverter.GetNewAliasFromLegacyAlias(alias);
-            return mapped == null 
-                ? null 
-                : ParameterEditors.SingleOrDefault(x => x.Alias == mapped);
+            return mapped == null
+                ? null
+                : paramEditors.SingleOrDefault(x => x.Alias == mapped);
         }
     }
 }

src/Umbraco.Core/Publishing/ScheduledPublisher.cs

@@ -1,4 +1,5 @@
 using System;
+using System.Linq;
 using Umbraco.Core.Logging;
 using Umbraco.Core.Models;
 using Umbraco.Core.Services;
@@ -26,12 +27,16 @@ namespace Umbraco.Core.Publishing
         public int CheckPendingAndProcess()
         {
             var counter = 0;
-            foreach (var d in _contentService.GetContentForRelease())
+            var contentForRelease = _contentService.GetContentForRelease().ToArray();
+            if (contentForRelease.Length > 0)
+                LogHelper.Debug<ScheduledPublisher>(string.Format("There's {0} item(s) of content to be published", contentForRelease.Length));
+            foreach (var d in contentForRelease)
             {
                 try
                 {
                     d.ReleaseDate = null;
                     var result = _contentService.SaveAndPublishWithStatus(d, (int)d.GetWriterProfile().Id);
+                    LogHelper.Debug<ContentService>(string.Format("Result of publish attempt: {0}", result.Result.StatusType));
                     if (result.Success == false)
                     {
                         if (result.Exception != null)
@@ -54,7 +59,11 @@ namespace Umbraco.Core.Publishing
                     throw;
                 }
             }
-            foreach (var d in _contentService.GetContentForExpiration())
+
+            var contentForExpiration = _contentService.GetContentForExpiration().ToArray();
+            if (contentForExpiration.Length > 0)
+                LogHelper.Debug<ScheduledPublisher>(string.Format("There's {0} item(s) of content to be unpublished", contentForExpiration.Length));
+            foreach (var d in contentForExpiration)
             {
                 try
                 {

src/Umbraco.Core/Scoping/Scope.cs

@@ -465,6 +465,7 @@ namespace Umbraco.Core.Scoping
                     }
                     finally
                     {
+                        // removes the ambient context (ambient scope already gone)
                         _scopeProvider.SetAmbient(null);
                     }
                 }

src/Umbraco.Core/Scoping/ScopeContext.cs

@@ -1,16 +1,23 @@
 using System;
 using System.Collections.Generic;
+using System.Linq;
 
 namespace Umbraco.Core.Scoping
 {
     public class ScopeContext : IInstanceIdentifiable
     {
         private Dictionary<string, IEnlistedObject> _enlisted;
+        private bool _exiting;
 
         public void ScopeExit(bool completed)
         {
+            if (_enlisted == null)
+                return;
+
+            _exiting = true;
+
             List<Exception> exceptions = null;
-            foreach (var enlisted in Enlisted.Values)
+            foreach (var enlisted in _enlisted.Values.OrderBy(x => x.Priority))
             {
                 try
                 {
@@ -23,6 +30,7 @@ namespace Umbraco.Core.Scoping
                     exceptions.Add(e);
                 }
             }
+
             if (exceptions != null)
                 throw new AggregateException("Exceptions were thrown by listed actions.", exceptions);
         }
@@ -42,73 +50,71 @@ namespace Umbraco.Core.Scoping
         private interface IEnlistedObject
         {
             void Execute(bool completed);
+            int Priority { get; }
         }
 
         private class EnlistedObject<T> : IEnlistedObject
         {
             private readonly Action<bool, T> _action;
 
-            public EnlistedObject(T item)
-            {
-                Item = item;
-            }
-
-            public EnlistedObject(T item, Action<bool, T> action)
+            public EnlistedObject(T item, Action<bool, T> action, int priority)
             {
                 Item = item;
+                Priority = priority;
                 _action = action;
             }
 
             public T Item { get; private set; }
 
+            public int Priority { get; private set; }
+
             public void Execute(bool completed)
             {
                 _action(completed, Item);
             }
         }
 
-        /// <inheritdoc />
+        // todo: replace with optional parameters when we can break things
         public T Enlist<T>(string key, Func<T> creator)
         {
-            IEnlistedObject enlisted;
-            if (Enlisted.TryGetValue(key, out enlisted))
-            {
-                var enlistedAs = enlisted as EnlistedObject<T>;
-                if (enlistedAs == null) throw new Exception("An item with a different type has already been enlisted with the same key.");
-                return enlistedAs.Item;
-            }
-            var enlistedOfT = new EnlistedObject<T>(creator());
-            Enlisted[key] = enlistedOfT;
-            return enlistedOfT.Item;
+            return Enlist(key, creator, null, 100);
         }
 
-        /// <inheritdoc />
+        // todo: replace with optional parameters when we can break things
         public T Enlist<T>(string key, Func<T> creator, Action<bool, T> action)
         {
-            IEnlistedObject enlisted;
-            if (Enlisted.TryGetValue(key, out enlisted))
-            {
-                var enlistedAs = enlisted as EnlistedObject<T>;
-                if (enlistedAs == null) throw new Exception("An item with a different type has already been enlisted with the same key.");
-                return enlistedAs.Item;
-            }
-            var enlistedOfT = new EnlistedObject<T>(creator(), action);
-            Enlisted[key] = enlistedOfT;
-            return enlistedOfT.Item;
+            return Enlist(key, creator, action, 100);
         }
 
-        /// <inheritdoc />
+        // todo: replace with optional parameters when we can break things
         public void Enlist(string key, Action<bool> action)
         {
+            Enlist<object>(key, null, (completed, item) => action(completed), 100);
+        }
+
+        public void Enlist(string key, Action<bool> action, int priority)
+        {
+            Enlist<object>(key, null, (completed, item) => action(completed), priority);
+        }
+
+        public T Enlist<T>(string key, Func<T> creator, Action<bool, T> action, int priority)
+        {
+            if (_exiting)
+                throw new InvalidOperationException("Cannot enlist now, context is exiting.");
+
+            var enlistedObjects = _enlisted ?? (_enlisted = new Dictionary<string, IEnlistedObject>());
+
             IEnlistedObject enlisted;
-            if (Enlisted.TryGetValue(key, out enlisted))
+            if (enlistedObjects.TryGetValue(key, out enlisted))
             {
-                var enlistedAs = enlisted as EnlistedObject<object>;
-                if (enlistedAs == null) throw new Exception("An item with a different type has already been enlisted with the same key.");
-                return;
+                var enlistedAs = enlisted as EnlistedObject<T>;
+                if (enlistedAs == null) throw new InvalidOperationException("An item with the key already exists, but with a different type.");
+                if (enlistedAs.Priority != priority) throw new InvalidOperationException("An item with the key already exits, but with a different priority.");
+                return enlistedAs.Item;
             }
-            var enlistedOfT = new EnlistedObject<object>(null, (completed, item) => action(completed));
+            var enlistedOfT = new EnlistedObject<T>(creator == null ? default(T) : creator(), action, priority);
             Enlisted[key] = enlistedOfT;
+            return enlistedOfT.Item;
         }
     }
 }

src/Umbraco.Core/Security/AuthenticationExtensions.cs

@@ -80,7 +80,41 @@ namespace Umbraco.Core.Security
 
             return false;
         }
+
+        /// <summary>
+        /// This will return the current back office identity if the IPrincipal is the correct type
+        /// </summary>
+        /// <param name="user"></param>
+        /// <returns></returns>
+        internal static UmbracoBackOfficeIdentity GetUmbracoIdentity(this IPrincipal user)
+        {
+            //If it's already a UmbracoBackOfficeIdentity
+            var backOfficeIdentity = user.Identity as UmbracoBackOfficeIdentity;
+            if (backOfficeIdentity != null) return backOfficeIdentity;
 
+            //Check if there's more than one identity assigned and see if it's a UmbracoBackOfficeIdentity and use that
+            var claimsPrincipal = user as ClaimsPrincipal;
+            if (claimsPrincipal != null)
+            {
+                backOfficeIdentity = claimsPrincipal.Identities.OfType<UmbracoBackOfficeIdentity>().FirstOrDefault();
+                if (backOfficeIdentity != null) return backOfficeIdentity;
+            }
+
+            //Otherwise convert to a UmbracoBackOfficeIdentity if it's auth'd and has the back office session            
+            var claimsIdentity = user.Identity as ClaimsIdentity;
+            if (claimsIdentity != null && claimsIdentity.IsAuthenticated && claimsIdentity.HasClaim(x => x.Type == Constants.Security.SessionIdClaimType))
+            {
+                try
+                {
+                    return UmbracoBackOfficeIdentity.FromClaimsIdentity(claimsIdentity);
+                }
+                catch (InvalidOperationException)
+                {                    
+                }
+            }
+
+            return null;
+        }
 
         /// <summary>
         /// This will return the current back office identity. 
@@ -100,31 +134,8 @@ namespace Umbraco.Core.Security
             if (http.User == null) return null; //there's no user at all so no identity
 
             //If it's already a UmbracoBackOfficeIdentity
-            var backOfficeIdentity = http.User.Identity as UmbracoBackOfficeIdentity;
-            if (backOfficeIdentity != null) return backOfficeIdentity;
-
-            //Check if there's more than one identity assigned and see if it's a UmbracoBackOfficeIdentity and use that
-            var claimsPrincipal = http.User as ClaimsPrincipal;
-            if (claimsPrincipal != null)
-            {
-                backOfficeIdentity = claimsPrincipal.Identities.OfType<UmbracoBackOfficeIdentity>().FirstOrDefault();
-                if (backOfficeIdentity != null) return backOfficeIdentity;
-            }
-
-            //Otherwise convert to a UmbracoBackOfficeIdentity if it's auth'd and has the back office session            
-            var claimsIdentity = http.User.Identity as ClaimsIdentity;
-            if (claimsIdentity != null && claimsIdentity.IsAuthenticated && claimsIdentity.HasClaim(x => x.Type == Constants.Security.SessionIdClaimType))
-            {                 
-                try
-                {
-                    return UmbracoBackOfficeIdentity.FromClaimsIdentity(claimsIdentity);
-                }
-                catch (InvalidOperationException ex)
-                {
-                    //This will occur if the required claim types are missing which would mean something strange is going on
-                    LogHelper.Error(typeof(AuthenticationExtensions), "The current identity cannot be converted to " + typeof(UmbracoBackOfficeIdentity), ex);
-                }
-            }
+            var backOfficeIdentity = GetUmbracoIdentity(http.User);
+            if (backOfficeIdentity != null) return backOfficeIdentity;            
 
             if (authenticateRequestIfNotFound == false) return null;
 

src/Umbraco.Core/Security/BackOfficeSignInManager.cs

@@ -191,6 +191,7 @@ namespace Umbraco.Core.Security
 
             //track the last login date
             user.LastLoginDateUtc = DateTime.UtcNow;
+            user.AccessFailedCount = 0;
             await UserManager.UpdateAsync(user);
 
             _logger.WriteCore(TraceEventType.Information, 0,
@@ -231,4 +232,4 @@ namespace Umbraco.Core.Security
             return null;
         }
     }
-}
+}

src/Umbraco.Core/Security/MembershipProviderBase.cs

@@ -9,6 +9,7 @@ using System.Web.Configuration;
 using System.Web.Hosting;
 using System.Web.Security;
 using Umbraco.Core.Logging;
+using Umbraco.Core.Models;
 
 namespace Umbraco.Core.Security
 {
@@ -520,7 +521,11 @@ namespace Umbraco.Core.Security
 
         public override string ResetPassword(string username, string answer)
         {
-            if (EnablePasswordReset == false)
+            var userService = ApplicationContext.Current == null ? null : ApplicationContext.Current.Services.UserService;
+
+            var canReset = this.CanResetPassword(userService);                
+
+            if (canReset == false)
             {
                 throw new NotSupportedException("Password reset is not supported");
             }

src/Umbraco.Core/Security/MembershipProviderExtensions.cs

@@ -9,12 +9,45 @@ using System.Web;
 using System.Web.Hosting;
 using System.Web.Security;
 using Umbraco.Core.Configuration;
+using Umbraco.Core.Models;
 using Umbraco.Core.Security;
+using Umbraco.Core.Services;
 
 namespace Umbraco.Core.Security
 {
     public static class MembershipProviderExtensions
     {
+        /// <summary>
+        /// Extension method to check if a password can be reset based on a given provider and the current request (logged in user)
+        /// </summary>
+        /// <param name="provider"></param>
+        /// <param name="userService"></param>
+        /// <returns></returns>
+        internal static bool CanResetPassword(this MembershipProvider provider, IUserService userService)
+        {
+            if (provider == null) throw new ArgumentNullException("provider");
+            
+            var canReset = provider.EnablePasswordReset;
+
+            if (userService == null) return canReset;
+
+            //we need to check for the special case in which a user is an admin - in which acse they can reset the password even if EnablePasswordReset == false
+            if (provider.EnablePasswordReset == false)
+            {
+                var identity = Thread.CurrentPrincipal.GetUmbracoIdentity();
+                if (identity != null)
+                {
+                    var user = userService.GetByUsername(identity.Username);
+                    var userIsAdmin = user.IsAdmin();
+                    if (userIsAdmin)
+                    {
+                        canReset = true;
+                    }
+                }
+            }
+            return canReset;
+        }
+
         internal static MembershipUserCollection FindUsersByName(this MembershipProvider provider, string usernameToMatch)
         {
             int totalRecords = 0;

src/Umbraco.Core/Services/ContentService.cs

@@ -1124,7 +1124,9 @@ namespace Umbraco.Core.Services
         /// <returns>True if unpublishing succeeded, otherwise False</returns>
         public bool UnPublish(IContent content, int userId = 0)
         {
-            return ((IContentServiceOperations)this).UnPublish(content, userId).Success;
+            var attempt = ((IContentServiceOperations)this).UnPublish(content, userId);
+            LogHelper.Debug<ContentService>(string.Format("Result of unpublish attempt: {0}", attempt.Result.StatusType));
+            return attempt.Success;
         }
 
         /// <summary>

src/Umbraco.Core/Services/EntityService.cs

@@ -1,6 +1,5 @@
 using System;
 using System.Collections.Generic;
-using System.Linq;
 using Umbraco.Core.Cache;
 using Umbraco.Core.CodeAnnotations;
 using Umbraco.Core.Events;
@@ -81,28 +80,16 @@ namespace Umbraco.Core.Services
             {
                 using (var uow = UowProvider.GetUnitOfWork(readOnly:true))
                 {
-                    switch (umbracoObjectType)
-                    {
-                        case UmbracoObjectTypes.Document:
-                        case UmbracoObjectTypes.MemberType:
-                        case UmbracoObjectTypes.Media:
-                        case UmbracoObjectTypes.Template:
-                        case UmbracoObjectTypes.MediaType:
-                        case UmbracoObjectTypes.DocumentType:
-                        case UmbracoObjectTypes.Member:
-                        case UmbracoObjectTypes.DataType:
-                        case UmbracoObjectTypes.DocumentTypeContainer:
-                            return uow.Database.ExecuteScalar<int?>(new Sql().Select("id").From<NodeDto>().Where<NodeDto>(dto => dto.UniqueId == key));
-                        case UmbracoObjectTypes.RecycleBin:
-                        case UmbracoObjectTypes.Stylesheet:
-                        case UmbracoObjectTypes.MemberGroup:
-                        case UmbracoObjectTypes.ContentItem:
-                        case UmbracoObjectTypes.ContentItemType:
-                        case UmbracoObjectTypes.ROOT:
-                        case UmbracoObjectTypes.Unknown:
-                        default:
-                            throw new NotSupportedException();
-                    }
+                    var nodeObjectType = GetNodeObjectTypeGuid(umbracoObjectType);
+
+                    var sql = new Sql()
+                        .Select("id")
+                        .From<NodeDto>()
+                        .Where<NodeDto>(
+                            dto =>
+                                dto.UniqueId == key &&
+                                dto.NodeObjectType == nodeObjectType);
+                    return uow.Database.ExecuteScalar<int?>(sql);
                 }                
             });
             return result.HasValue ? Attempt.Succeed(result.Value) : Attempt<int>.Fail();
@@ -120,32 +107,30 @@ namespace Umbraco.Core.Services
             {
                 using (var uow = UowProvider.GetUnitOfWork(readOnly:true))
                 {
-                    switch (umbracoObjectType)
-                    {
-                        case UmbracoObjectTypes.Document:
-                        case UmbracoObjectTypes.MemberType:
-                        case UmbracoObjectTypes.Media:
-                        case UmbracoObjectTypes.Template:
-                        case UmbracoObjectTypes.MediaType:
-                        case UmbracoObjectTypes.DocumentType:
-                        case UmbracoObjectTypes.Member:
-                        case UmbracoObjectTypes.DataType:
-                            return uow.Database.ExecuteScalar<Guid?>(new Sql().Select("uniqueID").From<NodeDto>().Where<NodeDto>(dto => dto.NodeId == id));
-                        case UmbracoObjectTypes.RecycleBin:
-                        case UmbracoObjectTypes.Stylesheet:
-                        case UmbracoObjectTypes.MemberGroup:
-                        case UmbracoObjectTypes.ContentItem:
-                        case UmbracoObjectTypes.ContentItemType:
-                        case UmbracoObjectTypes.ROOT:
-                        case UmbracoObjectTypes.Unknown:
-                        default:
-                            throw new NotSupportedException("Unsupported object type (" + umbracoObjectType + ").");
-                    }
+                    var nodeObjectType = GetNodeObjectTypeGuid(umbracoObjectType);
+
+                    var sql = new Sql()
+                        .Select("uniqueID")
+                        .From<NodeDto>()
+                        .Where<NodeDto>(
+                            dto =>
+                                dto.NodeId == id &&
+                                dto.NodeObjectType == nodeObjectType);
+                    return uow.Database.ExecuteScalar<Guid?>(sql);
                 }
             });
             return result.HasValue ? Attempt.Succeed(result.Value) : Attempt<Guid>.Fail();
         }
 
+        private static Guid GetNodeObjectTypeGuid(UmbracoObjectTypes umbracoObjectType)
+        {
+            var guid = umbracoObjectType.GetGuid();
+            if (guid == Guid.Empty)
+                throw new NotSupportedException("Unsupported object type (" + umbracoObjectType + ").");
+
+            return guid;            
+        }
+
         public IUmbracoEntity GetByKey(Guid key, bool loadBaseType = true)
         {
             if (loadBaseType)

src/Umbraco.Core/Services/IPackagingService.cs

@@ -1,4 +1,5 @@
-using System.Collections.Generic;
+using System;
+using System.Collections.Generic;
 using System.Xml.Linq;
 using Umbraco.Core.Models;
 
@@ -6,6 +7,15 @@ namespace Umbraco.Core.Services
 {
     public interface IPackagingService : IService
     {
+        /// <summary>
+        /// This will fetch an Umbraco package file from the package repository and return the relative file path to the downloaded package file
+        /// </summary>
+        /// <param name="packageId"></param>
+        /// <param name="umbracoVersion"></param>
+        /// <param name="userId">The current user id performing the operation</param>
+        /// <returns></returns>
+        string FetchPackageFile(Guid packageId, Version umbracoVersion, int userId);
+
         /// <summary>
         /// Imports and saves package xml as <see cref="IContent"/>
         /// </summary>

src/Umbraco.Core/Services/PackagingService.cs

@@ -1,15 +1,20 @@
 using System;
 using System.Collections.Generic;
 using System.Globalization;
+using System.IO;
 using System.Linq;
+using System.Net.Http;
 using System.Text.RegularExpressions;
 using System.Web;
 using System.Web.UI.WebControls;
 using System.Xml.Linq;
 using System.Xml.XPath;
 using Newtonsoft.Json;
+using Umbraco.Core.Auditing;
 using Umbraco.Core.Configuration;
+using Umbraco.Core.Configuration.UmbracoSettings;
 using Umbraco.Core.Events;
+using Umbraco.Core.Exceptions;
 using Umbraco.Core.IO;
 using Umbraco.Core.Logging;
 using Umbraco.Core.Models;
@@ -75,6 +80,61 @@ namespace Umbraco.Core.Services
             _importedContentTypes = new Dictionary<string, IContentType>();
         }
 
+        /// <summary>
+        /// This will fetch an Umbraco package file from the package repository and return the relative file path to the downloaded package file
+        /// </summary>
+        /// <param name="packageId"></param>
+        /// <param name="umbracoVersion"></param>
+        /// /// <param name="userId">The current user id performing the operation</param>
+        /// <returns></returns>
+        public string FetchPackageFile(Guid packageId, Version umbracoVersion, int userId)
+        {
+            var packageRepo = UmbracoConfig.For.UmbracoSettings().PackageRepositories.GetDefault();
+
+            using (var httpClient = new HttpClient())
+            using (var uow = _uowProvider.GetUnitOfWork())
+            {
+                //includeHidden = true because we don't care if it's hidden we want to get the file regardless
+                var url = string.Format("{0}/{1}?version={2}&includeHidden=true&asFile=true", packageRepo.RestApiUrl, packageId, umbracoVersion.ToString(3));
+                byte[] bytes;
+                try
+                {
+                    bytes = httpClient.GetByteArrayAsync(url).GetAwaiter().GetResult();
+                }
+                catch (HttpRequestException ex)
+                {
+                    throw new ConnectionException("An error occuring downloading the package from " + url, ex);
+                }
+
+                //successfull 
+                if (bytes.Length > 0)
+                {
+                    var packagePath = IOHelper.MapPath(SystemDirectories.Packages);
+
+                    // Check for package directory
+                    if (Directory.Exists(packagePath) == false)
+                        Directory.CreateDirectory(packagePath);
+
+                    var packageFilePath = Path.Combine(packagePath, packageId + ".umb");
+
+                    using (var fs1 = new FileStream(packageFilePath, FileMode.Create))
+                    {
+                        fs1.Write(bytes, 0, bytes.Length);
+                        return "packages\\" + packageId + ".umb";
+                    }
+                }
+
+                Audit(uow, AuditType.PackagerInstall, string.Format("Package {0} fetched from {1}", packageId, packageRepo.Id), userId, -1);
+                return null;
+            }
+        }
+
+        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));
+        }
+
         #region Content
 
         /// <summary>

src/Umbraco.Core/TypeExtensions.cs

@@ -166,8 +166,8 @@ namespace Umbraco.Core
 					return true;
 			}
 			return false;
-		}
-
+		}
+        
 		/// <summary>
 		/// Determines whether [is of generic type] [the specified type].
 		/// </summary>

src/Umbraco.Core/TypeHelper.cs

@@ -2,6 +2,7 @@ using System;
 using System.Collections;
 using System.Collections.Concurrent;
 using System.Collections.Generic;
+using System.Collections.ObjectModel;
 using System.Linq;
 using System.Reflection;
 
@@ -15,11 +16,51 @@ namespace Umbraco.Core
 	{
 	    private static readonly ConcurrentDictionary<Tuple<Type, bool, bool, bool>, PropertyInfo[]> GetPropertiesCache
             = new ConcurrentDictionary<Tuple<Type, bool, bool, bool>, PropertyInfo[]>();
-		private static readonly ConcurrentDictionary<Type, FieldInfo[]> GetFieldsCache 
+		private static readonly ConcurrentDictionary<Type, FieldInfo[]> GetFieldsCache
             = new ConcurrentDictionary<Type, FieldInfo[]>();
 
         private static readonly Assembly[] EmptyAssemblies  = new Assembly[0];
-        
+
+        /// <summary>
+        /// Based on a type we'll check if it is IEnumerable{T} (or similar) and if so we'll return a List{T}, this will also deal with array types and return List{T} for those too.
+        /// If it cannot be done, null is returned.
+        /// </summary>
+        /// <param name="obj"></param>
+        /// <returns></returns>
+	    internal static IList CreateGenericEnumerableFromObject(object obj)
+        {
+            var type = obj.GetType();
+
+            if (type.IsGenericType)
+            {
+                var genericTypeDef = type.GetGenericTypeDefinition();
+
+                if (genericTypeDef == typeof(IEnumerable<>)
+                    || genericTypeDef == typeof(ICollection<>)
+                    || genericTypeDef == typeof(Collection<>)
+                    || genericTypeDef == typeof(IList<>)
+                    || genericTypeDef == typeof(List<>)
+                    //this will occur when Linq is used and we get the odd WhereIterator or DistinctIterators since those are special iterator types
+                    || obj is IEnumerable)
+                {
+                    //if it is a IEnumerable<>, IList<T> or ICollection<> we'll use a List<>
+                    var genericType = typeof(List<>).MakeGenericType(type.GetGenericArguments());
+                    //pass in obj to fill the list
+                    return (IList)Activator.CreateInstance(genericType, obj);
+                }
+	        }
+
+	        if (type.IsArray)
+	        {
+                //if its an array, we'll use a List<>
+	            var genericType = typeof(List<>).MakeGenericType(type.GetElementType());
+                //pass in obj to fill the list
+	            return (IList)Activator.CreateInstance(genericType, obj);
+            }
+
+            return null;
+	    }
+
         /// <summary>
         /// Checks if the method is actually overriding a base method
         /// </summary>
@@ -45,8 +86,8 @@ namespace Umbraco.Core
             if (assembly.IsAppCodeAssembly() || assembly.IsGlobalAsaxAssembly())
                 return EmptyAssemblies;
 
-            
-            // find all assembly references that are referencing the current type's assembly since we 
+
+            // find all assembly references that are referencing the current type's assembly since we
             // should only be scanning those assemblies because any other assembly will definitely not
             // contain sub type's of the one we're currently looking for
             var name = assembly.GetName().Name;

src/Umbraco.Core/Umbraco.Core.csproj

@@ -53,13 +53,14 @@
       <HintPath>..\packages\SharpZipLib.0.86.0\lib\20\ICSharpCode.SharpZipLib.dll</HintPath>
       <Private>True</Private>
     </Reference>
-    <Reference Include="ImageProcessor, Version=2.5.2.0, Culture=neutral, processorArchitecture=MSIL">
-      <HintPath>..\packages\ImageProcessor.2.5.2\lib\net45\ImageProcessor.dll</HintPath>
-      <Private>True</Private>
+    <Reference Include="ImageProcessor, Version=2.5.3.0, Culture=neutral, processorArchitecture=MSIL">
+      <HintPath>..\packages\ImageProcessor.2.5.3\lib\net45\ImageProcessor.dll</HintPath>
     </Reference>
-    <Reference Include="log4net, Version=1.2.15.0, Culture=neutral, PublicKeyToken=669e0ddf0bb1aa2a, processorArchitecture=MSIL">
-      <HintPath>..\packages\log4net.2.0.5\lib\net45-full\log4net.dll</HintPath>
-      <Private>True</Private>
+    <Reference Include="log4net, Version=2.0.8.0, Culture=neutral, PublicKeyToken=669e0ddf0bb1aa2a, processorArchitecture=MSIL">
+      <HintPath>..\packages\log4net.2.0.8\lib\net45-full\log4net.dll</HintPath>
+    </Reference>
+    <Reference Include="Log4Net.Async, Version=2.0.4.0, Culture=neutral, processorArchitecture=MSIL">
+      <HintPath>..\packages\Log4Net.Async.2.0.4\lib\net40\Log4Net.Async.dll</HintPath>
     </Reference>
     <Reference Include="Microsoft.AspNet.Identity.Core, Version=2.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35, processorArchitecture=MSIL">
       <HintPath>..\packages\Microsoft.AspNet.Identity.Core.2.2.1\lib\net45\Microsoft.AspNet.Identity.Core.dll</HintPath>
@@ -89,21 +90,18 @@
       <HintPath>..\packages\MiniProfiler.2.1.0\lib\net40\MiniProfiler.dll</HintPath>
       <Private>True</Private>
     </Reference>
-    <Reference Include="MySql.Data, Version=6.9.8.0, Culture=neutral, PublicKeyToken=c5687fc88969c44d, processorArchitecture=MSIL">
-      <HintPath>..\packages\MySql.Data.6.9.8\lib\net45\MySql.Data.dll</HintPath>
-      <Private>True</Private>
+    <Reference Include="MySql.Data, Version=6.9.9.0, Culture=neutral, PublicKeyToken=c5687fc88969c44d, processorArchitecture=MSIL">
+      <HintPath>..\packages\MySql.Data.6.9.9\lib\net45\MySql.Data.dll</HintPath>
     </Reference>
-    <Reference Include="Newtonsoft.Json, Version=9.0.0.0, Culture=neutral, PublicKeyToken=30ad4fe6b2a6aeed, processorArchitecture=MSIL">
-      <HintPath>..\packages\Newtonsoft.Json.9.0.1\lib\net45\Newtonsoft.Json.dll</HintPath>
-      <Private>True</Private>
+    <Reference Include="Newtonsoft.Json, Version=10.0.0.0, Culture=neutral, PublicKeyToken=30ad4fe6b2a6aeed, processorArchitecture=MSIL">
+      <HintPath>..\packages\Newtonsoft.Json.10.0.2\lib\net45\Newtonsoft.Json.dll</HintPath>
     </Reference>
     <Reference Include="Owin, Version=1.0.0.0, Culture=neutral, PublicKeyToken=f0ebd12fd5e55cc5, processorArchitecture=MSIL">
       <HintPath>..\packages\Owin.1.0\lib\net40\Owin.dll</HintPath>
       <Private>True</Private>
     </Reference>
-    <Reference Include="Semver, Version=2.0.4.0, Culture=neutral, processorArchitecture=MSIL">
-      <HintPath>..\packages\Semver.2.0.4\lib\netstandard1.1\Semver.dll</HintPath>
-      <Private>True</Private>
+    <Reference Include="Semver, Version=1.1.2.0, Culture=neutral, processorArchitecture=MSIL">
+      <HintPath>..\packages\semver.1.1.2\lib\net45\Semver.dll</HintPath>
     </Reference>
     <Reference Include="System" />
     <Reference Include="System.ComponentModel.Composition" />
@@ -293,6 +291,7 @@
     <Compile Include="Configuration\UmbracoSettings\RazorStaticMappingElement.cs" />
     <Compile Include="Configuration\UmbracoSettings\RepositoriesCollection.cs" />
     <Compile Include="Configuration\UmbracoSettings\RepositoriesElement.cs" />
+    <Compile Include="Configuration\UmbracoSettings\RepositoryConfigExtensions.cs" />
     <Compile Include="Configuration\UmbracoSettings\RepositoryElement.cs" />
     <Compile Include="Configuration\UmbracoSettings\RequestHandlerElement.cs" />
     <Compile Include="Configuration\UmbracoSettings\ScheduledTaskElement.cs" />
@@ -339,7 +338,11 @@
     <Compile Include="Events\IDeletingMediaFilesEventArgs.cs" />
     <Compile Include="Events\ScopeEventDispatcherBase.cs" />
     <Compile Include="Events\ScopeLifespanMessagesFactory.cs" />
+    <Compile Include="Events\SupersedeEventAttribute.cs" />
+    <Compile Include="Exceptions\ConnectionException.cs" />
+    <Compile Include="HashCodeHelper.cs" />
     <Compile Include="IHttpContextAccessor.cs" />
+    <Compile Include="Models\EntityBase\IDeletableEntity.cs" />
     <Compile Include="Models\PublishedContent\PublishedContentTypeConverter.cs" />
     <Compile Include="OrderedHashSet.cs" />
     <Compile Include="Events\UninstallPackageEventArgs.cs" />
@@ -496,8 +499,8 @@
     <Compile Include="Persistence\Mappers\MigrationEntryMapper.cs" />
     <Compile Include="Persistence\Migrations\LocalMigrationContext.cs" />
     <Compile Include="Persistence\Migrations\Upgrades\TargetVersionFourOneZero\AddPreviewXmlTable.cs" />
-    <Compile Include="Persistence\Migrations\Upgrades\TargetVersionSevenFiveFive\AddLockObjects.cs" />
-    <Compile Include="Persistence\Migrations\Upgrades\TargetVersionSevenFiveFive\AddLockTable.cs" />
+    <Compile Include="Persistence\Migrations\Upgrades\TargetVersionSevenSixZero\AddLockObjects.cs" />
+    <Compile Include="Persistence\Migrations\Upgrades\TargetVersionSevenSixZero\AddLockTable.cs" />
     <Compile Include="Persistence\Migrations\Upgrades\TargetVersionSevenFiveFive\UpdateAllowedMediaTypesAtRoot.cs" />
     <Compile Include="Persistence\Migrations\Upgrades\TargetVersionSevenFiveZero\EnsureServersLockObject.cs" />
     <Compile Include="Persistence\Migrations\Upgrades\TargetVersionSevenFiveZero\AddRedirectUrlTable.cs" />
@@ -515,6 +518,8 @@
     <Compile Include="Persistence\Migrations\Upgrades\TargetVersionSevenSixZero\AddIndexToUser2NodePermission.cs" />
     <Compile Include="Persistence\Migrations\Upgrades\TargetVersionSevenSixZero\AddRelationTypeUniqueIdColumn.cs" />
     <Compile Include="Persistence\Migrations\Upgrades\TargetVersionSevenSixZero\AddMacroUniqueIdColumn.cs" />
+    <Compile Include="Persistence\Migrations\Upgrades\TargetVersionSevenSixZero\ReduceLoginNameColumnsSize.cs" />
+    <Compile Include="Persistence\Migrations\Upgrades\TargetVersionSevenSixZero\NormalizeTemplateGuids.cs" />
     <Compile Include="Persistence\Migrations\Upgrades\TargetVersionSevenSixZero\RemovePropertyDataIdIndex.cs" />
     <Compile Include="Persistence\Migrations\Upgrades\TargetVersionSevenSixZero\RemoveUmbracoDeployTables.cs" />
     <Compile Include="Persistence\Migrations\Upgrades\TargetVersionSevenThreeTwo\EnsureMigrationsTableIdentityIsCorrect.cs" />

src/Umbraco.Core/UmbracoApplicationBase.cs

@@ -49,8 +49,6 @@ namespace Umbraco.Core
                 LogHelper.Error<UmbracoApplicationBase>(msg, exception);
             };
 
-            BindingRedirects.Initialize();
-
             //boot up the application
             GetBootManager()
                 .Initialize()

src/Umbraco.Core/app.config

@@ -4,7 +4,7 @@
     <assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
       <dependentAssembly>
         <assemblyIdentity name="Newtonsoft.Json" publicKeyToken="30ad4fe6b2a6aeed" culture="neutral" />
-        <bindingRedirect oldVersion="0.0.0.0-9.0.0.0" newVersion="9.0.0.0" />
+        <bindingRedirect oldVersion="0.0.0.0-10.0.0.0" newVersion="10.0.0.0" />
       </dependentAssembly>
       <dependentAssembly>
         <assemblyIdentity name="System.Web.Mvc" publicKeyToken="31bf3856ad364e35" culture="neutral" />
@@ -30,11 +30,15 @@
         <assemblyIdentity name="Microsoft.Owin.Security.Cookies" publicKeyToken="31bf3856ad364e35" culture="neutral" />
         <bindingRedirect oldVersion="0.0.0.0-3.0.1.0" newVersion="3.0.1.0" />
       </dependentAssembly>
+      <dependentAssembly>
+        <assemblyIdentity name="log4net" publicKeyToken="669e0ddf0bb1aa2a" culture="neutral" />
+        <bindingRedirect oldVersion="0.0.0.0-2.0.8.0" newVersion="2.0.8.0" />
+      </dependentAssembly>
     </assemblyBinding>
   </runtime>
 <startup><supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.5" /></startup><system.data>
     <DbProviderFactories>
       <remove invariant="MySql.Data.MySqlClient" />
-      <add name="MySQL Data Provider" invariant="MySql.Data.MySqlClient" description=".Net Framework Data Provider for MySQL" type="MySql.Data.MySqlClient.MySqlClientFactory, MySql.Data, Version=6.9.8.0, Culture=neutral, PublicKeyToken=c5687fc88969c44d" />
+      <add name="MySQL Data Provider" invariant="MySql.Data.MySqlClient" description=".Net Framework Data Provider for MySQL" type="MySql.Data.MySqlClient.MySqlClientFactory, MySql.Data, Version=6.9.9.0, Culture=neutral, PublicKeyToken=c5687fc88969c44d" />
     </DbProviderFactories>
   </system.data></configuration>

src/Umbraco.Core/packages.config

@@ -2,8 +2,9 @@
 <packages>
   <package id="AutoMapper" version="3.3.1" targetFramework="net45" />
   <package id="HtmlAgilityPack" version="1.4.9.5" targetFramework="net45" />
-  <package id="ImageProcessor" version="2.5.2" targetFramework="net45" />
-  <package id="log4net" version="2.0.5" targetFramework="net45" />
+  <package id="ImageProcessor" version="2.5.3" targetFramework="net45" />
+  <package id="log4net" version="2.0.8" targetFramework="net45" />
+  <package id="Log4Net.Async" version="2.0.4" targetFramework="net45" />
   <package id="Microsoft.AspNet.Identity.Core" version="2.2.1" targetFramework="net45" />
   <package id="Microsoft.AspNet.Identity.Owin" version="2.2.1" targetFramework="net45" />
   <package id="Microsoft.Owin" version="3.0.1" targetFramework="net45" />
@@ -11,14 +12,10 @@
   <package id="Microsoft.Owin.Security.Cookies" version="3.0.1" targetFramework="net45" />
   <package id="Microsoft.Owin.Security.OAuth" version="3.0.1" targetFramework="net45" />
   <package id="MiniProfiler" version="2.1.0" targetFramework="net45" />
-  <package id="MySql.Data" version="6.9.8" targetFramework="net45" />
-  <package id="Newtonsoft.Json" version="9.0.1" targetFramework="net45" />
+  <package id="MySql.Data" version="6.9.9" targetFramework="net45" />
+  <package id="Newtonsoft.Json" version="10.0.2" targetFramework="net45" />
   <package id="Owin" version="1.0" targetFramework="net45" />
-  <package id="Semver" version="2.0.4" targetFramework="net45" />
+  <package id="semver" version="1.1.2" targetFramework="net45" />
   <package id="SharpZipLib" version="0.86.0" targetFramework="net45" />
   <package id="SqlServerCE" version="4.0.0.1" targetFramework="net45" />
-  <package id="System.Runtime" version="4.1.0" targetFramework="net45" />
-  <package id="System.Runtime.Extensions" version="4.1.0" targetFramework="net45" />
-  <package id="System.Runtime.InteropServices" version="4.1.0" targetFramework="net45" />
-  <package id="System.Text.RegularExpressions" version="4.1.0" targetFramework="net45" />
 </packages>

src/Umbraco.Tests.Benchmarks/App.config

@@ -45,7 +45,7 @@
       </dependentAssembly>
       <dependentAssembly>
         <assemblyIdentity name="Newtonsoft.Json" publicKeyToken="30ad4fe6b2a6aeed" culture="neutral" />
-        <bindingRedirect oldVersion="0.0.0.0-9.0.0.0" newVersion="9.0.0.0" />
+        <bindingRedirect oldVersion="0.0.0.0-10.0.0.0" newVersion="10.0.0.0" />
       </dependentAssembly>
       <dependentAssembly>
         <assemblyIdentity name="System.Collections.Immutable" publicKeyToken="b03f5f7f11d50a3a" culture="neutral" />
@@ -71,6 +71,10 @@
         <assemblyIdentity name="System.Runtime.Extensions" publicKeyToken="b03f5f7f11d50a3a" culture="neutral" />
         <bindingRedirect oldVersion="0.0.0.0-4.1.0.0" newVersion="4.1.0.0" />
       </dependentAssembly>
+      <dependentAssembly>
+        <assemblyIdentity name="log4net" publicKeyToken="669e0ddf0bb1aa2a" culture="neutral" />
+        <bindingRedirect oldVersion="0.0.0.0-2.0.8.0" newVersion="2.0.8.0" />
+      </dependentAssembly>
     </assemblyBinding>
   </runtime>
 </configuration>

src/Umbraco.Tests.Benchmarks/Umbraco.Tests.Benchmarks.csproj

@@ -69,8 +69,8 @@
       <HintPath>..\packages\Microsoft.Diagnostics.Tracing.TraceEvent.1.0.41\lib\net40\Microsoft.Diagnostics.Tracing.TraceEvent.dll</HintPath>
       <Private>True</Private>
     </Reference>
-    <Reference Include="Moq, Version=4.7.0.0, Culture=neutral, PublicKeyToken=69f491c39445e920, processorArchitecture=MSIL">
-      <HintPath>..\packages\Moq.4.7.0\lib\net45\Moq.dll</HintPath>
+    <Reference Include="Moq, Version=4.1.1309.919, Culture=neutral, PublicKeyToken=69f491c39445e920, processorArchitecture=MSIL">
+      <HintPath>..\packages\Moq.4.1.1309.0919\lib\net40\Moq.dll</HintPath>
     </Reference>
     <Reference Include="System" />
     <Reference Include="System.Collections.Immutable, Version=1.2.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a, processorArchitecture=MSIL">

src/Umbraco.Tests.Benchmarks/packages.config

@@ -10,7 +10,7 @@
   <package id="Microsoft.CodeAnalysis.CSharp" version="1.3.2" targetFramework="net45" />
   <package id="Microsoft.Diagnostics.Tracing.TraceEvent" version="1.0.41" targetFramework="net45" />
   <package id="Microsoft.SqlServer.Compact" version="4.0.8854.1" targetFramework="net45" />
-  <package id="Moq" version="4.7.0" targetFramework="net45" />
+  <package id="Moq" version="4.1.1309.0919" targetFramework="net45" />
   <package id="SqlServerCE" version="4.0.0.1" targetFramework="net45" />
   <package id="System.Collections" version="4.0.11" targetFramework="net45" />
   <package id="System.Collections.Concurrent" version="4.0.12" targetFramework="net45" />

src/Umbraco.Tests/App.config

@@ -124,7 +124,7 @@
         
         <assemblyIdentity name="Newtonsoft.Json" publicKeyToken="30ad4fe6b2a6aeed" culture="neutral" />
         
-        <bindingRedirect oldVersion="0.0.0.0-9.0.0.0" newVersion="9.0.0.0" />
+        <bindingRedirect oldVersion="0.0.0.0-10.0.0.0" newVersion="10.0.0.0" />
         
       </dependentAssembly>
       
@@ -200,6 +200,14 @@
 
       </dependentAssembly>
 
+      <dependentAssembly>
+
+        <assemblyIdentity name="log4net" publicKeyToken="669e0ddf0bb1aa2a" culture="neutral" />
+
+        <bindingRedirect oldVersion="0.0.0.0-2.0.8.0" newVersion="2.0.8.0" />
+
+      </dependentAssembly>
+
     </assemblyBinding>
 
   </runtime>

src/Umbraco.Tests/Cache/CacheRefresherEventHandlerTests.cs

@@ -7,6 +7,7 @@ using Umbraco.Core.Models.Membership;
 using Umbraco.Core.Services;
 using Umbraco.Tests.TestHelpers;
 using Umbraco.Web.Cache;
+using System.Linq;
 
 namespace Umbraco.Tests.Cache
 {
@@ -31,70 +32,70 @@ namespace Umbraco.Tests.Cache
                 new EventDefinition<ISectionService, EventArgs>(null, ServiceContext.SectionService, new EventArgs(), "Deleted"),
                 new EventDefinition<ISectionService, EventArgs>(null, ServiceContext.SectionService, new EventArgs(), "New"),
 
-                new EventDefinition<IUserService, SaveEventArgs<IUserType>>(null, ServiceContext.UserService, new SaveEventArgs<IUserType>((IUserType) null)),
-                new EventDefinition<IUserService, DeleteEventArgs<IUserType>>(null, ServiceContext.UserService, new DeleteEventArgs<IUserType>((IUserType) null)),
+                new EventDefinition<IUserService, SaveEventArgs<IUserType>>(null, ServiceContext.UserService, new SaveEventArgs<IUserType>(Enumerable.Empty<IUserType>())),
+                new EventDefinition<IUserService, DeleteEventArgs<IUserType>>(null, ServiceContext.UserService, new DeleteEventArgs<IUserType>(Enumerable.Empty<IUserType>())),
 
-                new EventDefinition<IUserService, SaveEventArgs<IUser>>(null, ServiceContext.UserService, new SaveEventArgs<IUser>((IUser) null)),
-                new EventDefinition<IUserService, DeleteEventArgs<IUser>>(null, ServiceContext.UserService, new DeleteEventArgs<IUser>((IUser) null)),
-                new EventDefinition<IUserService, DeleteEventArgs<IUser>>(null, ServiceContext.UserService, new DeleteEventArgs<IUser>((IUser) null)),
+                new EventDefinition<IUserService, SaveEventArgs<IUser>>(null, ServiceContext.UserService, new SaveEventArgs<IUser>(Enumerable.Empty<IUser>())),
+                new EventDefinition<IUserService, DeleteEventArgs<IUser>>(null, ServiceContext.UserService, new DeleteEventArgs<IUser>(Enumerable.Empty<IUser>())),
+                new EventDefinition<IUserService, DeleteEventArgs<IUser>>(null, ServiceContext.UserService, new DeleteEventArgs<IUser>(Enumerable.Empty<IUser>())),
 
-                new EventDefinition<ILocalizationService, SaveEventArgs<IDictionaryItem>>(null, ServiceContext.LocalizationService, new SaveEventArgs<IDictionaryItem>((IDictionaryItem) null)),
-                new EventDefinition<ILocalizationService, DeleteEventArgs<IDictionaryItem>>(null, ServiceContext.LocalizationService, new DeleteEventArgs<IDictionaryItem>((IDictionaryItem) null)),
+                new EventDefinition<ILocalizationService, SaveEventArgs<IDictionaryItem>>(null, ServiceContext.LocalizationService, new SaveEventArgs<IDictionaryItem>(Enumerable.Empty<IDictionaryItem>())),
+                new EventDefinition<ILocalizationService, DeleteEventArgs<IDictionaryItem>>(null, ServiceContext.LocalizationService, new DeleteEventArgs<IDictionaryItem>(Enumerable.Empty<IDictionaryItem>())),
 
-                new EventDefinition<IDataTypeService, SaveEventArgs<IDataTypeDefinition>>(null, ServiceContext.DataTypeService, new SaveEventArgs<IDataTypeDefinition>((IDataTypeDefinition) null)),
-                new EventDefinition<IDataTypeService, DeleteEventArgs<IDataTypeDefinition>>(null, ServiceContext.DataTypeService, new DeleteEventArgs<IDataTypeDefinition>((IDataTypeDefinition) null)),
+                new EventDefinition<IDataTypeService, SaveEventArgs<IDataTypeDefinition>>(null, ServiceContext.DataTypeService, new SaveEventArgs<IDataTypeDefinition>(Enumerable.Empty<IDataTypeDefinition>())),
+                new EventDefinition<IDataTypeService, DeleteEventArgs<IDataTypeDefinition>>(null, ServiceContext.DataTypeService, new DeleteEventArgs<IDataTypeDefinition>(Enumerable.Empty<IDataTypeDefinition>())),
 
-                new EventDefinition<IFileService, SaveEventArgs<Stylesheet>>(null, ServiceContext.FileService, new SaveEventArgs<Stylesheet>((Stylesheet) null)),
-                new EventDefinition<IFileService, DeleteEventArgs<Stylesheet>>(null, ServiceContext.FileService, new DeleteEventArgs<Stylesheet>((Stylesheet) null)),
+                new EventDefinition<IFileService, SaveEventArgs<Stylesheet>>(null, ServiceContext.FileService, new SaveEventArgs<Stylesheet>(Enumerable.Empty<Stylesheet>())),
+                new EventDefinition<IFileService, DeleteEventArgs<Stylesheet>>(null, ServiceContext.FileService, new DeleteEventArgs<Stylesheet>(Enumerable.Empty<Stylesheet>())),
 
-                new EventDefinition<IDomainService, SaveEventArgs<IDomain>>(null, ServiceContext.DomainService, new SaveEventArgs<IDomain>((IDomain) null)),
-                new EventDefinition<IDomainService, DeleteEventArgs<IDomain>>(null, ServiceContext.DomainService, new DeleteEventArgs<IDomain>((IDomain) null)),
+                new EventDefinition<IDomainService, SaveEventArgs<IDomain>>(null, ServiceContext.DomainService, new SaveEventArgs<IDomain>(Enumerable.Empty<IDomain>())),
+                new EventDefinition<IDomainService, DeleteEventArgs<IDomain>>(null, ServiceContext.DomainService, new DeleteEventArgs<IDomain>(Enumerable.Empty<IDomain>())),
 
-                new EventDefinition<ILocalizationService, SaveEventArgs<ILanguage>>(null, ServiceContext.LocalizationService, new SaveEventArgs<ILanguage>((ILanguage) null)),
-                new EventDefinition<ILocalizationService, DeleteEventArgs<ILanguage>>(null, ServiceContext.LocalizationService, new DeleteEventArgs<ILanguage>((ILanguage) null)),
+                new EventDefinition<ILocalizationService, SaveEventArgs<ILanguage>>(null, ServiceContext.LocalizationService, new SaveEventArgs<ILanguage>(Enumerable.Empty<ILanguage>())),
+                new EventDefinition<ILocalizationService, DeleteEventArgs<ILanguage>>(null, ServiceContext.LocalizationService, new DeleteEventArgs<ILanguage>(Enumerable.Empty<ILanguage>())),
 
-                new EventDefinition<IContentTypeService, SaveEventArgs<IContentType>>(null, ServiceContext.ContentTypeService, new SaveEventArgs<IContentType>((IContentType) null)),
-                new EventDefinition<IContentTypeService, DeleteEventArgs<IContentType>>(null, ServiceContext.ContentTypeService, new DeleteEventArgs<IContentType>((IContentType) null)),
-                new EventDefinition<IContentTypeService, SaveEventArgs<IMediaType>>(null, ServiceContext.ContentTypeService, new SaveEventArgs<IMediaType>((IMediaType) null)),
-                new EventDefinition<IContentTypeService, DeleteEventArgs<IMediaType>>(null, ServiceContext.ContentTypeService, new DeleteEventArgs<IMediaType>((IMediaType) null)),
+                new EventDefinition<IContentTypeService, SaveEventArgs<IContentType>>(null, ServiceContext.ContentTypeService, new SaveEventArgs<IContentType>(Enumerable.Empty<IContentType>())),
+                new EventDefinition<IContentTypeService, DeleteEventArgs<IContentType>>(null, ServiceContext.ContentTypeService, new DeleteEventArgs<IContentType>(Enumerable.Empty<IContentType>())),
+                new EventDefinition<IContentTypeService, SaveEventArgs<IMediaType>>(null, ServiceContext.ContentTypeService, new SaveEventArgs<IMediaType>(Enumerable.Empty<IMediaType>())),
+                new EventDefinition<IContentTypeService, DeleteEventArgs<IMediaType>>(null, ServiceContext.ContentTypeService, new DeleteEventArgs<IMediaType>(Enumerable.Empty<IMediaType>())),
 
-                new EventDefinition<IMemberTypeService, SaveEventArgs<IMemberType>>(null, ServiceContext.MemberTypeService, new SaveEventArgs<IMemberType>((IMemberType) null)),
-                new EventDefinition<IMemberTypeService, DeleteEventArgs<IMemberType>>(null, ServiceContext.MemberTypeService, new DeleteEventArgs<IMemberType>((IMemberType) null)),
+                new EventDefinition<IMemberTypeService, SaveEventArgs<IMemberType>>(null, ServiceContext.MemberTypeService, new SaveEventArgs<IMemberType>(Enumerable.Empty<IMemberType>())),
+                new EventDefinition<IMemberTypeService, DeleteEventArgs<IMemberType>>(null, ServiceContext.MemberTypeService, new DeleteEventArgs<IMemberType>(Enumerable.Empty<IMemberType>())),
 
-                new EventDefinition<IFileService, SaveEventArgs<ITemplate>>(null, ServiceContext.FileService, new SaveEventArgs<ITemplate>((ITemplate) null)),
-                new EventDefinition<IFileService, DeleteEventArgs<ITemplate>>(null, ServiceContext.FileService, new DeleteEventArgs<ITemplate>((ITemplate) null)),
+                new EventDefinition<IFileService, SaveEventArgs<ITemplate>>(null, ServiceContext.FileService, new SaveEventArgs<ITemplate>(Enumerable.Empty<ITemplate>())),
+                new EventDefinition<IFileService, DeleteEventArgs<ITemplate>>(null, ServiceContext.FileService, new DeleteEventArgs<ITemplate>(Enumerable.Empty<ITemplate>())),
 
-                new EventDefinition<IMacroService, SaveEventArgs<IMacro>>(null, ServiceContext.MacroService, new SaveEventArgs<IMacro>((IMacro) null)),
-                new EventDefinition<IMacroService, DeleteEventArgs<IMacro>>(null, ServiceContext.MacroService, new DeleteEventArgs<IMacro>((IMacro) null)),
+                new EventDefinition<IMacroService, SaveEventArgs<IMacro>>(null, ServiceContext.MacroService, new SaveEventArgs<IMacro>(Enumerable.Empty<IMacro>())),
+                new EventDefinition<IMacroService, DeleteEventArgs<IMacro>>(null, ServiceContext.MacroService, new DeleteEventArgs<IMacro>(Enumerable.Empty<IMacro>())),
 
-                new EventDefinition<IMemberService, SaveEventArgs<IMember>>(null, ServiceContext.MemberService, new SaveEventArgs<IMember>((IMember) null)),
-                new EventDefinition<IMemberService, DeleteEventArgs<IMember>>(null, ServiceContext.MemberService, new DeleteEventArgs<IMember>((IMember) null)),
+                new EventDefinition<IMemberService, SaveEventArgs<IMember>>(null, ServiceContext.MemberService, new SaveEventArgs<IMember>(Enumerable.Empty<IMember>())),
+                new EventDefinition<IMemberService, DeleteEventArgs<IMember>>(null, ServiceContext.MemberService, new DeleteEventArgs<IMember>(Enumerable.Empty<IMember>())),
 
-                new EventDefinition<IMemberGroupService, SaveEventArgs<IMemberGroup>>(null, ServiceContext.MemberGroupService, new SaveEventArgs<IMemberGroup>((IMemberGroup) null)),
-                new EventDefinition<IMemberGroupService, DeleteEventArgs<IMemberGroup>>(null, ServiceContext.MemberGroupService, new DeleteEventArgs<IMemberGroup>((IMemberGroup) null)),
+                new EventDefinition<IMemberGroupService, SaveEventArgs<IMemberGroup>>(null, ServiceContext.MemberGroupService, new SaveEventArgs<IMemberGroup>(Enumerable.Empty<IMemberGroup>())),
+                new EventDefinition<IMemberGroupService, DeleteEventArgs<IMemberGroup>>(null, ServiceContext.MemberGroupService, new DeleteEventArgs<IMemberGroup>(Enumerable.Empty<IMemberGroup>())),
 
-                new EventDefinition<IMediaService, SaveEventArgs<IMedia>>(null, ServiceContext.MediaService, new SaveEventArgs<IMedia>((IMedia) null)),
-                new EventDefinition<IMediaService, DeleteEventArgs<IMedia>>(null, ServiceContext.MediaService, new DeleteEventArgs<IMedia>((IMedia) null)),
+                new EventDefinition<IMediaService, SaveEventArgs<IMedia>>(null, ServiceContext.MediaService, new SaveEventArgs<IMedia>(Enumerable.Empty<IMedia>())),
+                new EventDefinition<IMediaService, DeleteEventArgs<IMedia>>(null, ServiceContext.MediaService, new DeleteEventArgs<IMedia>(Enumerable.Empty<IMedia>())),
                 new EventDefinition<IMediaService, MoveEventArgs<IMedia>>(null, ServiceContext.MediaService, new MoveEventArgs<IMedia>(new MoveEventInfo<IMedia>(null, "", -1)), "Moved"),
                 new EventDefinition<IMediaService, MoveEventArgs<IMedia>>(null, ServiceContext.MediaService, new MoveEventArgs<IMedia>(new MoveEventInfo<IMedia>(null, "", -1)), "Trashed"),
                 new EventDefinition<IMediaService, RecycleBinEventArgs>(null, ServiceContext.MediaService, new RecycleBinEventArgs(Guid.NewGuid(), new Dictionary<int, IEnumerable<Property>>(), true)),
 
-                new EventDefinition<IContentService, SaveEventArgs<IContent>>(null, ServiceContext.ContentService, new SaveEventArgs<IContent>((IContent) null)),
-                new EventDefinition<IContentService, DeleteEventArgs<IContent>>(null, ServiceContext.ContentService, new DeleteEventArgs<IContent>((IContent) null)),
+                new EventDefinition<IContentService, SaveEventArgs<IContent>>(null, ServiceContext.ContentService, new SaveEventArgs<IContent>(Enumerable.Empty<IContent>())),
+                new EventDefinition<IContentService, DeleteEventArgs<IContent>>(null, ServiceContext.ContentService, new DeleteEventArgs<IContent>(Enumerable.Empty<IContent>())),
                 new EventDefinition<IContentService, CopyEventArgs<IContent>>(null, ServiceContext.ContentService, new CopyEventArgs<IContent>(null, null, -1)),
                 new EventDefinition<IContentService, MoveEventArgs<IContent>>(null, ServiceContext.ContentService, new MoveEventArgs<IContent>(new MoveEventInfo<IContent>(null, "", -1)), "Trashed"),
                 new EventDefinition<IContentService, RecycleBinEventArgs>(null, ServiceContext.ContentService, new RecycleBinEventArgs(Guid.NewGuid(), new Dictionary<int, IEnumerable<Property>>(), true)),
-                new EventDefinition<IContentService, PublishEventArgs<IContent>>(null, ServiceContext.ContentService, new PublishEventArgs<IContent>((IContent) null), "Published"),
-                new EventDefinition<IContentService, PublishEventArgs<IContent>>(null, ServiceContext.ContentService, new PublishEventArgs<IContent>((IContent) null), "UnPublished"),
+                new EventDefinition<IContentService, PublishEventArgs<IContent>>(null, ServiceContext.ContentService, new PublishEventArgs<IContent>(Enumerable.Empty<IContent>()), "Published"),
+                new EventDefinition<IContentService, PublishEventArgs<IContent>>(null, ServiceContext.ContentService, new PublishEventArgs<IContent>(Enumerable.Empty<IContent>()), "UnPublished"),
 
-                new EventDefinition<IPublicAccessService, SaveEventArgs<PublicAccessEntry>>(null, ServiceContext.PublicAccessService, new SaveEventArgs<PublicAccessEntry>((PublicAccessEntry) null)),
-                new EventDefinition<IPublicAccessService, DeleteEventArgs<PublicAccessEntry>>(null, ServiceContext.PublicAccessService, new DeleteEventArgs<PublicAccessEntry>((PublicAccessEntry) null)),
+                new EventDefinition<IPublicAccessService, SaveEventArgs<PublicAccessEntry>>(null, ServiceContext.PublicAccessService, new SaveEventArgs<PublicAccessEntry>(Enumerable.Empty<PublicAccessEntry>())),
+                new EventDefinition<IPublicAccessService, DeleteEventArgs<PublicAccessEntry>>(null, ServiceContext.PublicAccessService, new DeleteEventArgs<PublicAccessEntry>(Enumerable.Empty<PublicAccessEntry>())),
 
-                new EventDefinition<IRelationService, SaveEventArgs<IRelationType>>(null, ServiceContext.RelationService, new SaveEventArgs<IRelationType>((IRelationType) null)),
-                new EventDefinition<IRelationService, DeleteEventArgs<IRelationType>>(null, ServiceContext.RelationService, new DeleteEventArgs<IRelationType>((IRelationType) null)),
+                new EventDefinition<IRelationService, SaveEventArgs<IRelationType>>(null, ServiceContext.RelationService, new SaveEventArgs<IRelationType>(Enumerable.Empty<IRelationType>())),
+                new EventDefinition<IRelationService, DeleteEventArgs<IRelationType>>(null, ServiceContext.RelationService, new DeleteEventArgs<IRelationType>(Enumerable.Empty<IRelationType>())),
 
-                new EventDefinition<IRelationService, SaveEventArgs<IRelationType>>(null, ServiceContext.RelationService, new SaveEventArgs<IRelationType>((IRelationType) null)),
-                new EventDefinition<IRelationService, DeleteEventArgs<IRelationType>>(null, ServiceContext.RelationService, new DeleteEventArgs<IRelationType>((IRelationType) null)),
+                new EventDefinition<IRelationService, SaveEventArgs<IRelationType>>(null, ServiceContext.RelationService, new SaveEventArgs<IRelationType>(Enumerable.Empty<IRelationType>())),
+                new EventDefinition<IRelationService, DeleteEventArgs<IRelationType>>(null, ServiceContext.RelationService, new DeleteEventArgs<IRelationType>(Enumerable.Empty<IRelationType>())),
             };
 
             foreach (var definition in definitions)

src/Umbraco.Tests/Logging/AsyncRollingFileAppenderTest.cs

@@ -1,168 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Diagnostics;
-using System.IO;
-using System.Linq;
-using System.Threading;
-using log4net;
-using log4net.Config;
-using log4net.Core;
-using log4net.Layout;
-using log4net.Repository;
-using NUnit.Framework;
-using Umbraco.Core;
-using Umbraco.Core.Logging;
-
-namespace Umbraco.Tests.Logging
-{
-    [TestFixture]
-    public class AsyncRollingFileAppenderTest
-    {
-        private const string ErrorMessage = "TEST ERROR MESSAGE";
-        private const string FileFolderPath = @"c:\LogTesting\";
-        private readonly Level ErrorLevel = Level.Error;
-        private AsynchronousRollingFileAppender appender;
-        private ILoggerRepository rep;
-        private Guid fileGuid;
-
-        private string GetFilePath()
-        {
-            return string.Format("{0}{1}.log", FileFolderPath, fileGuid);
-        }
-
-        [SetUp]
-        public void SetUp()
-        {
-            fileGuid = Guid.NewGuid();
-            if (File.Exists(GetFilePath()))
-            {
-                File.Delete(GetFilePath());
-            }
-
-            appender = new AsynchronousRollingFileAppender();
-            appender.Threshold = ErrorLevel;
-            appender.File = GetFilePath();
-            appender.Layout = new PatternLayout("%d|%-5level|%logger| %message %exception%n");
-            appender.StaticLogFileName = true;
-            appender.AppendToFile = true;
-            appender.ActivateOptions();
-
-            rep = LogManager.CreateRepository(Guid.NewGuid().ToString());
-            BasicConfigurator.Configure(rep, appender);
-        }
-
-        [TearDown]
-        public void TearDown()
-        {
-            rep.Shutdown();
-            if (File.Exists(GetFilePath()))
-            {
-                File.Delete(GetFilePath());
-            }
-        }
-
-        [TestFixtureTearDown]
-        public void FixtureTearDown()
-        {
-            foreach (string file in Directory.GetFiles(FileFolderPath))
-            {
-                try
-                {
-                    File.Delete(file);
-                }
-                catch { }
-            }
-        }
-
-        private void ReleaseFileLocks()
-        {
-            rep.Shutdown();
-            appender.Close();
-        }
-
-        [Test]
-        public void CanWriteToFile()
-        {
-            // Arrange
-            ILog log = LogManager.GetLogger(rep.Name, "CanWriteToDatabase");
-
-            // Act
-            log.Error(ErrorMessage);
-            Thread.Sleep(200); // let background thread finish
-
-            // Assert
-            ReleaseFileLocks();
-            Assert.That(File.Exists(GetFilePath()), Is.True);
-            IEnumerable<string> readLines = File.ReadLines(GetFilePath());
-            Assert.That(readLines.Count(), Is.GreaterThanOrEqualTo(1));
-        }
-
-        [Test]
-        public void ReturnsQuicklyAfterLogging100Messages()
-        {
-            // Arrange
-            ILog log = LogManager.GetLogger(rep.Name, "ReturnsQuicklyAfterLogging100Messages");
-
-            // Act
-            DateTime startTime = DateTime.UtcNow;
-            100.Times(i => log.Error(ErrorMessage));
-            DateTime endTime = DateTime.UtcNow;
-
-            // Give background thread time to finish
-            Thread.Sleep(500);
-
-            // Assert
-            ReleaseFileLocks();
-            Assert.That(endTime - startTime, Is.LessThan(TimeSpan.FromMilliseconds(100)));
-            Assert.That(File.Exists(GetFilePath()), Is.True);
-            IEnumerable<string> readLines = File.ReadLines(GetFilePath());
-            Assert.That(readLines.Count(), Is.GreaterThanOrEqualTo(100));
-        }
-
-        [Test]
-        [Ignore]
-        public void CanLogAtleast1000MessagesASecond()
-        {
-            // Arrange
-            ILog log = LogManager.GetLogger(rep.Name, "CanLogAtLeast1000MessagesASecond");
-
-            int logCount = 0;
-            bool logging = true;
-            bool logsCounted = false;
-
-            var logTimer = new Timer(s =>
-            {
-                logging = false;
-
-                if (File.Exists(GetFilePath()))
-                {
-                    ReleaseFileLocks();
-                    IEnumerable<string> readLines = File.ReadLines(GetFilePath());
-                    logCount = readLines.Count();
-                }
-                logsCounted = true;
-            }, null, TimeSpan.FromSeconds(3), TimeSpan.FromMilliseconds(-1));
-
-            // Act
-            DateTime startTime = DateTime.UtcNow;
-            while (logging)
-            {
-                log.Error(ErrorMessage);
-            }
-            TimeSpan testDuration = DateTime.UtcNow - startTime;
-
-            while (!logsCounted)
-            {
-                Thread.Sleep(1);
-            }
-
-            logTimer.Dispose();
-
-            // Assert
-            var logsPerSecond = logCount / testDuration.TotalSeconds;
-
-            Debug.Print("{0} messages logged in {1}s => {2}/s", logCount, testDuration.TotalSeconds, logsPerSecond);
-            Assert.That(logsPerSecond, Is.GreaterThan(1000), "Must log at least 1000 messages per second");
-        }
-    }
-}

src/Umbraco.Tests/Logging/DebugAppender.cs

@@ -1,25 +0,0 @@
-using System;
-using System.Threading;
-using log4net.Appender;
-using log4net.Core;
-
-namespace Umbraco.Tests.Logging
-{
-    /// <summary>
-    /// Borrowed from https://github.com/cjbhaines/Log4Net.Async - will reference Nuget packages directly in v8
-    /// </summary>
-    public class DebugAppender : MemoryAppender
-    {
-        public TimeSpan AppendDelay { get; set; }
-        public int LoggedEventCount { get { return m_eventsList.Count; } }
-
-        protected override void Append(LoggingEvent loggingEvent)
-        {
-            if (AppendDelay > TimeSpan.Zero)
-            {
-                Thread.Sleep(AppendDelay);
-            }
-            base.Append(loggingEvent);
-        }
-    }
-}

src/Umbraco.Tests/Logging/ParallelForwarderTest.cs

@@ -1,327 +0,0 @@
-using System;
-using System.Diagnostics;
-using System.Security.Principal;
-using System.Threading;
-using log4net;
-using log4net.Appender;
-using log4net.Config;
-using log4net.Core;
-using log4net.Filter;
-using log4net.Repository;
-using Moq;
-using NUnit.Framework;
-using Umbraco.Core.Logging;
-
-namespace Umbraco.Tests.Logging
-{
-    /// <summary>
-    /// Borrowed from https://github.com/cjbhaines/Log4Net.Async - will reference Nuget packages directly in v8
-    /// </summary>
-    [TestFixture]
-    public class ParallelForwarderTest : IDisposable
-    {
-        private ParallelForwardingAppender asyncForwardingAppender;
-        private DebugAppender debugAppender;
-        private ILoggerRepository repository;
-        private ILog log;
-
-        [SetUp]
-        public void TestFixtureSetUp()
-        {
-            debugAppender = new DebugAppender();
-            debugAppender.ActivateOptions();
-
-            asyncForwardingAppender = new ParallelForwardingAppender();
-            asyncForwardingAppender.AddAppender(debugAppender);
-            asyncForwardingAppender.ActivateOptions();
-
-            repository = LogManager.CreateRepository(Guid.NewGuid().ToString());
-            BasicConfigurator.Configure(repository, asyncForwardingAppender);
-
-            log = LogManager.GetLogger(repository.Name, "TestLogger");
-        }
-
-        [TearDown]
-        public void TearDown()
-        {
-            LogManager.Shutdown();
-        }
-
-        [Test]
-        public void CanHandleNullLoggingEvent()
-        {
-            // Arrange
-
-            // Act
-            asyncForwardingAppender.DoAppend((LoggingEvent)null);
-            log.Info("SusequentMessage");
-            asyncForwardingAppender.Close();
-
-            // Assert - should not have had an exception from previous call
-            Assert.That(debugAppender.LoggedEventCount, Is.EqualTo(1), "Expected subsequent message only");
-            Assert.That(debugAppender.GetEvents()[0].MessageObject, Is.EqualTo("SusequentMessage"));
-        }
-
-        [Test]
-        public void CanHandleNullLoggingEvents()
-        {
-            // Arrange
-
-            // Act
-            asyncForwardingAppender.DoAppend((LoggingEvent[])null);
-            log.Info("SusequentMessage");
-            asyncForwardingAppender.Close();
-
-            // Assert - should not have had an exception from previous call
-            Assert.That(debugAppender.LoggedEventCount, Is.EqualTo(1), "Expected subsequent message only");
-            Assert.That(debugAppender.GetEvents()[0].MessageObject, Is.EqualTo("SusequentMessage"));
-        }
-
-        [Test]
-        public void CanHandleAppenderThrowing()
-        {
-            // Arrange
-            var badAppender = new Mock<IAppender>();
-            asyncForwardingAppender.AddAppender(badAppender.Object);
-
-            badAppender
-                .Setup(ba => ba.DoAppend(It.IsAny<LoggingEvent>()))
-                .Throws(new Exception("Bad Appender"));
-                //.Verifiable();
-
-            // Act
-            log.Info("InitialMessage");
-            log.Info("SusequentMessage");
-            asyncForwardingAppender.Close();
-
-            // Assert
-            Assert.That(debugAppender.LoggedEventCount, Is.EqualTo(2));
-            Assert.That(debugAppender.GetEvents()[1].MessageObject, Is.EqualTo("SusequentMessage"));
-            badAppender.Verify(appender => appender.DoAppend(It.IsAny<LoggingEvent>()), Times.Exactly(2));
-        }
-
-        [Test]
-        public void WillLogFastWhenThereIsASlowAppender()
-        {
-            const int testSize = 1000;
-
-            // Arrange
-            debugAppender.AppendDelay = TimeSpan.FromSeconds(30);
-            var watch = new Stopwatch();
-
-            // Act
-            watch.Start();
-            for (int i = 0; i < testSize; i++)
-            {
-                log.Error("Exception");
-            }
-            watch.Stop();
-
-            // Assert
-            Assert.That(debugAppender.LoggedEventCount, Is.EqualTo(0));
-            Assert.That(watch.ElapsedMilliseconds, Is.LessThan(testSize));
-            Debug.Print("Logged {0} errors in {1}ms", testSize, watch.ElapsedMilliseconds);
-        }
-
-        [Test]
-        public void WillNotOverflow()
-        {
-            const int testSize = 1000;
-
-            // Arrange
-            debugAppender.AppendDelay = TimeSpan.FromMilliseconds(1);
-            asyncForwardingAppender.BufferSize = 100;
-
-            // Act
-            for (int i = 0; i < testSize; i++)
-            {
-                log.Error("Exception");
-            }
-
-            while (asyncForwardingAppender.BufferEntryCount > 0) ;
-            asyncForwardingAppender.Close();
-
-            // Assert
-            Assert.That(debugAppender.LoggedEventCount, Is.EqualTo(testSize));
-        }
-
-        [Test]
-        public void WillTryToFlushBufferOnShutdown()
-        {
-            const int testSize = 250;
-
-            // Arrange
-            debugAppender.AppendDelay = TimeSpan.FromMilliseconds(1);
-
-            // Act
-            for (int i = 0; i < testSize; i++)
-            {
-                log.Error("Exception");
-            }
-
-            Thread.Sleep(50);
-
-            var numberLoggedBeforeClose = debugAppender.LoggedEventCount;
-            asyncForwardingAppender.Close();
-            var numberLoggedAfterClose = debugAppender.LoggedEventCount;
-
-            // Assert
-            //We can't use specific numbers here because the timing and counts will be different on different systems.
-            Assert.That(numberLoggedBeforeClose, Is.GreaterThan(0), "Some number of Logging events should be logged prior to appender close.");
-            //On some systems, we may not be able to flush all events prior to close, but it is reasonable to assume in this test case
-            //that some events should be logged after close.
-            Assert.That(numberLoggedAfterClose, Is.GreaterThan(numberLoggedBeforeClose), "Some number of LoggingEvents should be logged after close.");
-            Debug.Print("Flushed {0} events during shutdown", numberLoggedAfterClose - numberLoggedBeforeClose);
-        }
-
-        [Test, Explicit("Long-running")]
-        public void WillShutdownIfBufferCannotBeFlushedFastEnough()
-        {
-            const int testSize = 250;
-
-            // Arrange
-            debugAppender.AppendDelay = TimeSpan.FromSeconds(1);
-            Stopwatch watch = new Stopwatch();
-
-            // Act
-            for (int i = 0; i < testSize; i++)
-            {
-                log.Error("Exception");
-            }
-
-            Thread.Sleep(TimeSpan.FromSeconds(2));
-            var numberLoggedBeforeClose = debugAppender.LoggedEventCount;
-
-            watch.Start();
-            asyncForwardingAppender.Close();
-            watch.Stop();
-
-            var numberLoggedAfterClose = debugAppender.LoggedEventCount;
-
-            // Assert
-            Assert.That(numberLoggedBeforeClose, Is.GreaterThan(0));
-            Assert.That(numberLoggedAfterClose, Is.GreaterThan(numberLoggedBeforeClose));
-            Assert.That(numberLoggedAfterClose, Is.LessThan(testSize));
-            //We can't assume what the shutdown time will be.  It will vary from system to system. Don't test shutdown time.            
-            var events = debugAppender.GetEvents();
-            var evnt = events[events.Length - 1];
-            Assert.That(evnt.MessageObject, Is.EqualTo("The buffer was not able to be flushed before timeout occurred."));
-            Debug.Print("Flushed {0} events during shutdown which lasted {1}ms", numberLoggedAfterClose - numberLoggedBeforeClose, watch.ElapsedMilliseconds);
-        }
-
-        [Test]
-        public void ThreadContextPropertiesArePreserved()
-        {
-            // Arrange
-            ThreadContext.Properties["TestProperty"] = "My Value";
-            Assert.That(asyncForwardingAppender.Fix & FixFlags.Properties, Is.EqualTo(FixFlags.Properties), "Properties must be fixed if they are to be preserved");
-
-            // Act
-            log.Info("Information");
-            asyncForwardingAppender.Close();
-
-            // Assert
-            var lastLoggedEvent = debugAppender.GetEvents()[0];
-            Assert.That(lastLoggedEvent.Properties["TestProperty"], Is.EqualTo("My Value"));
-        }
-
-        [Test]
-        public void MessagesExcludedByFilterShouldNotBeAppended()
-        {
-            // Arrange
-            var levelFilter =
-                new LevelRangeFilter
-                {
-                    LevelMin = Level.Warn,
-                    LevelMax = Level.Error,
-                };
-
-            asyncForwardingAppender.AddFilter(levelFilter);
-
-            // Act
-            log.Info("Info");
-            log.Warn("Warn");
-            log.Error("Error");
-            log.Fatal("Fatal");
-
-            asyncForwardingAppender.Close();
-
-            //Assert
-            Assert.That(debugAppender.LoggedEventCount, Is.EqualTo(2));
-        }
-
-        [Test]
-        public void HelperCanGenerateLoggingEventWithAllProperties()
-        {
-            // Arrange
-            var helper = new LoggingEventHelper("TestLoggerName", FixFlags.All);
-            ThreadContext.Properties["MyProperty"] = "MyValue";
-            var exception = new Exception("SomeError");
-
-            var stackFrame = new StackFrame(0);
-            var currentUser = WindowsIdentity.GetCurrent();
-            var loggingTime = DateTime.Now; // Log4Net does not seem to be using UtcNow
-
-            // Act
-            var loggingEvent = helper.CreateLoggingEvent(Level.Emergency, "Who's on live support?", exception);
-            Thread.Sleep(50); // to make sure the time stamp is actually captured
-
-            // Assert
-            Assert.That(loggingEvent.Domain, Is.EqualTo(AppDomain.CurrentDomain.FriendlyName), "Domain");
-            //The identity assigned to new threads is dependent upon AppDomain principal policy.
-            //Background information here:http://www.neovolve.com/post/2010/10/21/Unit-testing-a-workflow-that-relies-on-ThreadCurrentPrincipalIdentityName.aspx
-            //VS2013 does have a principal assigned to new threads in the unit test.
-            //It's probably best not to test that the identity has been set.
-            //Assert.That(loggingEvent.Identity, Is.Empty, "Identity: always empty for some reason");
-            Assert.That(loggingEvent.UserName, Is.EqualTo(currentUser == null ? String.Empty : currentUser.Name), "UserName");
-            Assert.That(loggingEvent.ThreadName, Is.EqualTo(Thread.CurrentThread.Name), "ThreadName");
-
-            Assert.That(loggingEvent.Repository, Is.Null, "Repository: Helper does not have access to this");
-            Assert.That(loggingEvent.LoggerName, Is.EqualTo("TestLoggerName"), "LoggerName");
-
-            Assert.That(loggingEvent.Level, Is.EqualTo(Level.Emergency), "Level");
-            //Raised time to within 10 ms.   However, this may not be a valid test.  The time is going to vary from system to system.  The
-            //tolerance setting here is arbitrary.
-            Assert.That(loggingEvent.TimeStamp, Is.EqualTo(loggingTime).Within(TimeSpan.FromMilliseconds(10)), "TimeStamp");
-            Assert.That(loggingEvent.ExceptionObject, Is.EqualTo(exception), "ExceptionObject");
-            Assert.That(loggingEvent.MessageObject, Is.EqualTo("Who's on live support?"), "MessageObject");
-
-            Assert.That(loggingEvent.LocationInformation.MethodName, Is.EqualTo(stackFrame.GetMethod().Name), "LocationInformation");
-            Assert.That(loggingEvent.Properties["MyProperty"], Is.EqualTo("MyValue"), "Properties");
-        }
-
-        private bool _disposed = false;
-
-        //Implement IDisposable.
-        public void Dispose()
-        {
-            Dispose(true);
-            GC.SuppressFinalize(this);
-        }
-
-        protected virtual void Dispose(bool disposing)
-        {
-            if (!_disposed)
-            {
-                if (disposing)
-                {
-                    if (asyncForwardingAppender != null)
-                    {
-                        asyncForwardingAppender.Dispose();
-                        asyncForwardingAppender = null;
-                    }
-                }
-                // Free your own state (unmanaged objects).
-                // Set large fields to null.
-                _disposed = true;
-            }
-        }
-
-        // Use C# destructor syntax for finalization code.
-        ~ParallelForwarderTest()
-        {
-            // Simply call Dispose(false).
-            Dispose(false);
-        }
-    }
-}

src/Umbraco.Tests/Logging/RingBufferTest.cs

@@ -1,150 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Diagnostics;
-using System.Threading;
-using System.Threading.Tasks;
-using NUnit.Framework;
-using Umbraco.Core.Logging;
-using Umbraco.Tests.TestHelpers;
-
-namespace Umbraco.Tests.Logging
-{
-    /// <summary>
-    /// Borrowed from https://github.com/cjbhaines/Log4Net.Async - will reference Nuget packages directly in v8
-    /// </summary>
-    [TestFixture]
-    public class RingBufferTest
-    {
-        [Test]
-        public void PerfTest()
-        {
-            RingBuffer<string> ringBuffer = new RingBuffer<string>(1000);
-            Stopwatch ringWatch = new Stopwatch();
-            ringWatch.Start();
-            for (int i = 0; i < 1000000; i++)
-            {
-                ringBuffer.Enqueue("StringOfFun");
-            }
-            ringWatch.Stop();
-
-            Assert.That(ringWatch.ElapsedMilliseconds, Is.LessThan(150));
-        }
-
-        [Test]
-        public void PerfTestThreads()
-        {
-            RingBuffer<string> ringBuffer = new RingBuffer<string>(1000);
-
-            Stopwatch ringWatch = new Stopwatch();
-            List<Task> ringTasks = new List<Task>();
-            CancellationTokenSource cancelationTokenSource = new CancellationTokenSource();
-            CancellationToken cancelationToken = cancelationTokenSource.Token;
-            for (int t = 0; t < 10; t++)
-            {
-                ringTasks.Add(new Task(() =>
-                {
-                    for (int i = 0; i < 1000000; i++)
-                    {
-                        ringBuffer.Enqueue("StringOfFun");
-                    }
-                }, cancelationToken));
-            }
-            ringWatch.Start();
-            ringTasks.ForEach(t => t.Start());
-            var allTasks = ringTasks.ToArray();
-            Task.WaitAny(allTasks);
-            ringWatch.Stop();
-            //Cancel tasks to avoid System.AppDominUnloadException which is caused when the domain is unloaded
-            //and threads created in the domain are not stopped.
-            //Do this before assertions because they may throw an exception causing the thread cancellation to not happen.
-            cancelationTokenSource.Cancel();
-            try
-            {
-                Task.WaitAll(allTasks);
-            }
-            catch (AggregateException)
-            {
-                //Don't care about cancellation Exceptions.
-            }
-            //Tolerance at 500 was too low
-            ringTasks.ForEach(t => t.Dispose());
-            Assert.That(ringWatch.ElapsedMilliseconds, Is.LessThan(1000));
-        }
-
-        [Test]
-        public void PerfTestThreadsWithDequeues()
-        {
-            RingBuffer<string> ringBuffer = new RingBuffer<string>(1000);
-
-            Stopwatch ringWatch = new Stopwatch();
-            List<Task> ringTasks = new List<Task>();
-            CancellationTokenSource cancelationTokenSource = new CancellationTokenSource();
-            CancellationToken cancelationToken = cancelationTokenSource.Token;
-            for (int t = 0; t < 10; t++)
-            {
-                ringTasks.Add(new Task(() =>
-                {
-                    for (int i = 0; i < 1000000; i++)
-                    {
-                        ringBuffer.Enqueue("StringOfFun");
-                    }
-                }, cancelationToken));
-            }
-            for (int t = 0; t < 10; t++)
-            {
-                ringTasks.Add(new Task(() =>
-                {
-                    for (int i = 0; i < 1000000; i++)
-                    {
-                        string foo;
-                        ringBuffer.TryDequeue(out foo);
-                    }
-                }));
-            }
-            ringWatch.Start();
-            ringTasks.ForEach(t => t.Start());
-            var allTasks = ringTasks.ToArray();
-            Task.WaitAny(allTasks);
-            ringWatch.Stop();
-            //Cancel tasks to avoid System.AppDominUnloadException which is caused when the domain is unloaded
-            //and threads created in the domain are not stopped.
-            //Do this before assertions because they may throw an exception causing the thread cancellation to not happen.
-            cancelationTokenSource.Cancel();
-            try
-            {
-                Task.WaitAll(allTasks);
-            }
-            catch (AggregateException)
-            {
-                //Don't care about cancellation Exceptions.
-            }
-            ringTasks.ForEach(t => t.Dispose());
-            Assert.That(ringWatch.ElapsedMilliseconds, Is.LessThan(800));
-        }
-
-        [Test]
-        public void WhenRingSizeLimitIsHit_ItemsAreDequeued()
-        {
-            // Arrange
-            const int limit = 2;
-            object object1 = "one";
-            object object2 = "two";
-            object object3 = "three";
-            RingBuffer<object> queue = new RingBuffer<object>(limit);
-
-            // Act
-            queue.Enqueue(object1);
-            queue.Enqueue(object2);
-            queue.Enqueue(object3);
-
-            // Assert
-            object value;
-            queue.TryDequeue(out value);
-            Assert.That(value, Is.EqualTo(object2));
-            queue.TryDequeue(out value);
-            Assert.That(value, Is.EqualTo(object3));
-            queue.TryDequeue(out value);
-            Assert.That(value, Is.Null);
-        }
-    }
-}

src/Umbraco.Tests/PropertyEditors/ImageCropperTest.cs

@@ -376,7 +376,7 @@ namespace Umbraco.Tests.PropertyEditors
         {
             var cropperJson = "{\"focalPoint\": {\"left\": 0.5,\"top\": 0.5},\"src\": \"" + mediaPath + "\",\"crops\": [{\"alias\": \"home\",\"width\": 270,\"height\": 161}]}";
 
-            var urlString = mediaPath.GetCropUrl(400, 400, cropperJson, imageCropMode: ImageCropMode.Pad, backgroundColor: "fff");
+            var urlString = mediaPath.GetCropUrl(400, 400, cropperJson, imageCropMode: ImageCropMode.Pad, furtherOptions: "&bgcolor=fff");
             Assert.AreEqual(mediaPath + "?mode=pad&width=400&height=400&bgcolor=fff", urlString);
         }
     }

src/Umbraco.Tests/Routing/SiteDomainHelperTests.cs

@@ -25,14 +25,14 @@ namespace Umbraco.Tests.Routing
         {
             SiteDomainHelper.AddSite("site1", "domain1.com", "domain1.net", "domain1.org");
             SiteDomainHelper.AddSite("site2", "domain2.com", "domain2.net", "domain2.org");
-            
+
             var sites = SiteDomainHelper.Sites;
 
             Assert.AreEqual(2, sites.Count);
 
             Assert.Contains("site1", sites.Keys);
             Assert.Contains("site2", sites.Keys);
-            
+
             var domains = sites["site1"];
             Assert.AreEqual(3, domains.Count());
             Assert.Contains("domain1.com", domains);
@@ -84,7 +84,7 @@ namespace Umbraco.Tests.Routing
 
             Assert.Contains("site2", sites.Keys);
         }
-    
+
         [Test]
         public void AddSiteAgain()
         {
@@ -175,15 +175,15 @@ namespace Umbraco.Tests.Routing
 
             // map methods are not static because we can override them
             var helper = new SiteDomainHelper();
-            
+
             // current is a site1 uri, domains contain current
             // so we'll get current
             //
             var current = new Uri("http://domain1.com/foo/bar");
             var output = helper.MapDomain(current, new[]
                 {
-                    new DomainAndUri(new UmbracoDomain("domain1.com"), Uri.UriSchemeHttp), 
-                    new DomainAndUri(new UmbracoDomain("domain2.com"), Uri.UriSchemeHttp), 
+                    new DomainAndUri(new UmbracoDomain("domain1.com"), Uri.UriSchemeHttp),
+                    new DomainAndUri(new UmbracoDomain("domain2.com"), Uri.UriSchemeHttp),
                 }).Uri.ToString();
             Assert.AreEqual("http://domain1.com/", output);
 
@@ -193,7 +193,7 @@ namespace Umbraco.Tests.Routing
             current = new Uri("http://domain1.com/foo/bar");
             output = helper.MapDomain(current, new[]
                 {
-                    new DomainAndUri(new UmbracoDomain("domain1.net"), Uri.UriSchemeHttp), 
+                    new DomainAndUri(new UmbracoDomain("domain1.net"), Uri.UriSchemeHttp),
                     new DomainAndUri(new UmbracoDomain("domain2.net"), Uri.UriSchemeHttp)
                 }).Uri.ToString();
             Assert.AreEqual("http://domain1.net/", output);
@@ -205,12 +205,73 @@ namespace Umbraco.Tests.Routing
             current = new Uri("http://domain1.com/foo/bar");
             output = helper.MapDomain(current, new[]
                 {
-                    new DomainAndUri(new UmbracoDomain("domain2.net"), Uri.UriSchemeHttp), 
+                    new DomainAndUri(new UmbracoDomain("domain2.net"), Uri.UriSchemeHttp),
                     new DomainAndUri(new UmbracoDomain("domain1.net"), Uri.UriSchemeHttp)
                 }).Uri.ToString();
             Assert.AreEqual("http://domain1.net/", output);
         }
 
+        private DomainAndUri[] DomainAndUris(Uri current, IDomain[] domains)
+        {
+            var scheme = current == null ? Uri.UriSchemeHttp : current.Scheme;
+            return domains
+                .Where(d => d.IsWildcard == false)
+                .Select(d => new DomainAndUri(d, scheme))
+                .OrderByDescending(d => d.Uri.ToString())
+                .ToArray();
+        }
+
+        [Test]
+        public void MapDomainWithScheme()
+        {
+            SiteDomainHelper.AddSite("site1", "domain1.com", "domain1.net", "domain1.org");
+            SiteDomainHelper.AddSite("site2", "domain2.com", "domain2.net", "domain2.org");
+            SiteDomainHelper.AddSite("site3", "domain3.com", "domain3.net", "domain3.org");
+            SiteDomainHelper.AddSite("site4", "https://domain4.com", "https://domain4.net", "https://domain4.org");
+
+            // map methods are not static because we can override them
+            var helper = new SiteDomainHelper();
+
+            // this works, but it's purely by chance / arbitrary
+            // don't use the www in tests here!
+            var current = new Uri("https://www.domain1.com/foo/bar");
+            var domainAndUris = DomainAndUris(current, new []
+            {
+                new UmbracoDomain("domain2.com"),
+                new UmbracoDomain("domain1.com"),
+            });
+            var output = helper.MapDomain(current, domainAndUris).Uri.ToString();
+            Assert.AreEqual("https://domain1.com/", output);
+
+            // will pick it all right
+            current = new Uri("https://domain1.com/foo/bar");
+            domainAndUris = DomainAndUris(current, new[]
+            {
+                new UmbracoDomain("https://domain1.com"),
+                new UmbracoDomain("https://domain2.com")
+            });
+            output = helper.MapDomain(current, domainAndUris).Uri.ToString();
+            Assert.AreEqual("https://domain1.com/", output);
+
+            current = new Uri("https://domain1.com/foo/bar");
+            domainAndUris = DomainAndUris(current, new[]
+            {
+                new UmbracoDomain("https://domain1.com"),
+                new UmbracoDomain("https://domain4.com")
+            });
+            output = helper.MapDomain(current, domainAndUris).Uri.ToString();
+            Assert.AreEqual("https://domain1.com/", output);
+
+            current = new Uri("https://domain4.com/foo/bar");
+            domainAndUris = DomainAndUris(current, new[]
+            {
+                new UmbracoDomain("https://domain1.com"),
+                new UmbracoDomain("https://domain4.com")
+            });
+            output = helper.MapDomain(current, domainAndUris).Uri.ToString();
+            Assert.AreEqual("https://domain4.com/", output);
+        }
+
         [Test]
         public void MapDomains()
         {

src/Umbraco.Tests/Scheduling/BackgroundTaskRunnerTests2.cs

@@ -3,7 +3,7 @@ using System.Diagnostics;
 using System.Threading;
 using System.Threading.Tasks;
 using NUnit.Framework;
-using Umbraco.Tests.Logging;
+using Umbraco.Tests.TestHelpers;
 using Umbraco.Web.Scheduling;
 
 namespace Umbraco.Tests.Scheduling

src/Umbraco.Tests/Scoping/ScopeEventDispatcherTests.cs

@@ -4,13 +4,16 @@ using System.Linq;
 using Moq;
 using NUnit.Framework;
 using Umbraco.Core.Events;
+using Umbraco.Core.Models;
 using Umbraco.Core.Persistence;
 using Umbraco.Core.Scoping;
+using Umbraco.Tests.TestHelpers;
+using Umbraco.Tests.TestHelpers.Entities;
 
 namespace Umbraco.Tests.Scoping
 {
     [TestFixture]
-    public class ScopeEventDispatcherTests
+    public class ScopeEventDispatcherTests : BaseUmbracoConfigurationTest
     {
         [SetUp]
         public void Setup()
@@ -79,7 +82,7 @@ namespace Umbraco.Tests.Scoping
                 var events = scope.Events.GetEvents(EventDefinitionFilter.All).ToArray();
 
                 var knownNames = new[] { "DoThing1", "DoThing2", "DoThing3" };
-                var knownArgTypes = new[] { typeof (SaveEventArgs<string>), typeof (SaveEventArgs<int>), typeof (SaveEventArgs<decimal>) };
+                var knownArgTypes = new[] { typeof(SaveEventArgs<string>), typeof(SaveEventArgs<int>), typeof(SaveEventArgs<decimal>) };
 
                 for (var i = 0; i < events.Length; i++)
                 {
@@ -89,6 +92,166 @@ namespace Umbraco.Tests.Scoping
             }
         }
 
+        [Test]
+        public void SupersededEvents()
+        {
+            DoSaveForContent += OnDoThingFail;
+            DoDeleteForContent += OnDoThingFail;
+            DoForTestArgs += OnDoThingFail;
+            DoForTestArgs2 += OnDoThingFail;
+            
+            var contentType = MockedContentTypes.CreateBasicContentType();
+
+            var content1 = MockedContent.CreateBasicContent(contentType);
+            content1.Id = 123;
+
+            var content2 = MockedContent.CreateBasicContent(contentType);
+            content2.Id = 456;
+
+            var content3 = MockedContent.CreateBasicContent(contentType);
+            content3.Id = 789;
+
+            var scopeProvider = new ScopeProvider(Mock.Of<IDatabaseFactory2>());
+            using (var scope = scopeProvider.CreateScope(eventDispatcher: new PassiveEventDispatcher()))
+            {
+                
+                //content1 will be filtered from the args
+                scope.Events.Dispatch(DoSaveForContent, this, new SaveEventArgs<IContent>(new[]{ content1 , content3}));
+                scope.Events.Dispatch(DoDeleteForContent, this, new DeleteEventArgs<IContent>(content1));
+                scope.Events.Dispatch(DoSaveForContent, this, new SaveEventArgs<IContent>(content2));
+                //this entire event will be filtered
+                scope.Events.Dispatch(DoForTestArgs, this, new TestEventArgs(content1));
+                scope.Events.Dispatch(DoForTestArgs2, this, new TestEventArgs2(content1));
+
+                // events have been queued
+                var events = scope.Events.GetEvents(EventDefinitionFilter.All).ToArray();
+                Assert.AreEqual(4, events.Length);
+
+                Assert.AreEqual(typeof(SaveEventArgs<IContent>), events[0].Args.GetType());
+                Assert.AreEqual(1, ((SaveEventArgs<IContent>)events[0].Args).SavedEntities.Count());
+                Assert.AreEqual(content3.Id, ((SaveEventArgs<IContent>)events[0].Args).SavedEntities.First().Id);
+
+                Assert.AreEqual(typeof(DeleteEventArgs<IContent>), events[1].Args.GetType());
+                Assert.AreEqual(content1.Id, ((DeleteEventArgs<IContent>) events[1].Args).DeletedEntities.First().Id);
+
+                Assert.AreEqual(typeof(SaveEventArgs<IContent>), events[2].Args.GetType());
+                Assert.AreEqual(content2.Id, ((SaveEventArgs<IContent>)events[2].Args).SavedEntities.First().Id);
+
+                Assert.AreEqual(typeof(TestEventArgs2), events[3].Args.GetType());
+            }
+        }
+
+        /// <summary>
+        /// This will test that when we track events that before we Get the events we normalize all of the
+        /// event entities to be the latest one (most current) found amongst the event so that there is 
+        /// no 'stale' entities in any of the args
+        /// </summary>
+        [Test]
+        public void LatestEntities()
+        {
+            DoSaveForContent += OnDoThingFail;            
+
+            var now = DateTime.Now;
+            var contentType = MockedContentTypes.CreateBasicContentType();
+            var content1 = MockedContent.CreateBasicContent(contentType);
+            content1.Id = 123;
+            content1.UpdateDate = now.AddMinutes(1);
+            var content2 = MockedContent.CreateBasicContent(contentType);
+            content2.Id = 123;
+            content2.UpdateDate = now.AddMinutes(2);
+            var content3 = MockedContent.CreateBasicContent(contentType);
+            content3.Id = 123;
+            content3.UpdateDate = now.AddMinutes(3);
+
+            var scopeProvider = new ScopeProvider(Mock.Of<IDatabaseFactory2>());
+            using (var scope = scopeProvider.CreateScope(eventDispatcher: new PassiveEventDispatcher()))
+            {                                
+                scope.Events.Dispatch(DoSaveForContent, this, new SaveEventArgs<IContent>(content1));
+                scope.Events.Dispatch(DoSaveForContent, this, new SaveEventArgs<IContent>(content2));
+                scope.Events.Dispatch(DoSaveForContent, this, new SaveEventArgs<IContent>(content3));
+
+                // events have been queued
+                var events = scope.Events.GetEvents(EventDefinitionFilter.All).ToArray();
+                Assert.AreEqual(3, events.Length);
+                
+                foreach (var t in events)
+                {
+                    var args = (SaveEventArgs<IContent>)t.Args;
+                    foreach (var entity in args.SavedEntities)
+                    {
+                        Assert.AreEqual(content3, entity);
+                        Assert.IsTrue(object.ReferenceEquals(content3, entity));
+                    }
+                }
+            }
+        }
+
+        [Test]
+        public void FirstIn()
+        {
+            DoSaveForContent += OnDoThingFail;
+
+            var now = DateTime.Now;
+            var contentType = MockedContentTypes.CreateBasicContentType();
+            var content1 = MockedContent.CreateBasicContent(contentType);
+            content1.Id = 123;
+            content1.UpdateDate = now.AddMinutes(1);
+            var content2 = MockedContent.CreateBasicContent(contentType);
+            content2.Id = 123;
+            content1.UpdateDate = now.AddMinutes(2);
+            var content3 = MockedContent.CreateBasicContent(contentType);
+            content3.Id = 123;
+            content1.UpdateDate = now.AddMinutes(3);
+
+            var scopeProvider = new ScopeProvider(Mock.Of<IDatabaseFactory2>());
+            using (var scope = scopeProvider.CreateScope(eventDispatcher: new PassiveEventDispatcher()))
+            {
+                scope.Events.Dispatch(DoSaveForContent, this, new SaveEventArgs<IContent>(content1));
+                scope.Events.Dispatch(DoSaveForContent, this, new SaveEventArgs<IContent>(content2));
+                scope.Events.Dispatch(DoSaveForContent, this, new SaveEventArgs<IContent>(content3));
+
+                // events have been queued
+                var events = scope.Events.GetEvents(EventDefinitionFilter.FirstIn).ToArray();
+                Assert.AreEqual(1, events.Length);                
+                Assert.AreEqual(content1, ((SaveEventArgs<IContent>) events[0].Args).SavedEntities.First());
+                Assert.IsTrue(object.ReferenceEquals(content1, ((SaveEventArgs<IContent>)events[0].Args).SavedEntities.First()));
+                Assert.AreEqual(content1.UpdateDate, ((SaveEventArgs<IContent>) events[0].Args).SavedEntities.First().UpdateDate);
+            }
+        }
+
+        [Test]
+        public void LastIn()
+        {
+            DoSaveForContent += OnDoThingFail;
+
+            var now = DateTime.Now;
+            var contentType = MockedContentTypes.CreateBasicContentType();
+            var content1 = MockedContent.CreateBasicContent(contentType);
+            content1.Id = 123;
+            content1.UpdateDate = now.AddMinutes(1);
+            var content2 = MockedContent.CreateBasicContent(contentType);
+            content2.Id = 123;
+            content2.UpdateDate = now.AddMinutes(2);
+            var content3 = MockedContent.CreateBasicContent(contentType);
+            content3.Id = 123;
+            content3.UpdateDate = now.AddMinutes(3);
+
+            var scopeProvider = new ScopeProvider(Mock.Of<IDatabaseFactory2>());
+            using (var scope = scopeProvider.CreateScope(eventDispatcher: new PassiveEventDispatcher()))
+            {
+                scope.Events.Dispatch(DoSaveForContent, this, new SaveEventArgs<IContent>(content1));
+                scope.Events.Dispatch(DoSaveForContent, this, new SaveEventArgs<IContent>(content2));
+                scope.Events.Dispatch(DoSaveForContent, this, new SaveEventArgs<IContent>(content3));
+
+                // events have been queued
+                var events = scope.Events.GetEvents(EventDefinitionFilter.LastIn).ToArray();
+                Assert.AreEqual(1, events.Length);
+                Assert.AreEqual(content3, ((SaveEventArgs<IContent>)events[0].Args).SavedEntities.First());
+                Assert.IsTrue(object.ReferenceEquals(content3, ((SaveEventArgs<IContent>)events[0].Args).SavedEntities.First()));
+                Assert.AreEqual(content3.UpdateDate, ((SaveEventArgs<IContent>)events[0].Args).SavedEntities.First().UpdateDate);
+            }
+        }
+
         [TestCase(true)]
         [TestCase(false)]
         public void EventsDispatching_Passive(bool complete)
@@ -177,12 +340,41 @@ namespace Umbraco.Tests.Scoping
             Assert.Fail();
         }
 
+        public static event EventHandler<SaveEventArgs<IContent>> DoSaveForContent;
+        public static event EventHandler<DeleteEventArgs<IContent>> DoDeleteForContent;
+        public static event EventHandler<TestEventArgs> DoForTestArgs;
+        public static event EventHandler<TestEventArgs2> DoForTestArgs2;
         public static event EventHandler<SaveEventArgs<string>> DoThing1;
 
         public static event EventHandler<SaveEventArgs<int>> DoThing2;
 
         public static event TypedEventHandler<ScopeEventDispatcherTests, SaveEventArgs<decimal>> DoThing3;
 
+        public class TestEventArgs : CancellableObjectEventArgs
+        {
+            public TestEventArgs(object eventObject) : base(eventObject)
+            {
+            }
+
+            public object MyEventObject
+            {
+                get { return EventObject; }
+            }
+        }
+
+        [SupersedeEvent(typeof(TestEventArgs))]
+        public class TestEventArgs2 : CancellableObjectEventArgs
+        {
+            public TestEventArgs2(object eventObject) : base(eventObject)
+            {
+            }
+
+            public object MyEventObject
+            {
+                get { return EventObject; }
+            }
+        }
+
         public class PassiveEventDispatcher : ScopeEventDispatcherBase
         {
             public PassiveEventDispatcher()

src/Umbraco.Tests/Scoping/ScopeTests.cs

@@ -591,7 +591,7 @@ namespace Umbraco.Tests.Scoping
                         Assert.IsNull(scopeProvider.AmbientContext);
 
                         // back to original thread
-                        ScopeProvider.HttpContextItemsGetter = () => httpContextItems; 
+                        ScopeProvider.HttpContextItemsGetter = () => httpContextItems;
                     }
                     Assert.IsNotNull(scopeProvider.AmbientScope);
                     Assert.AreSame(scope, scopeProvider.AmbientScope);
@@ -656,6 +656,44 @@ namespace Umbraco.Tests.Scoping
             Assert.IsNotNull(ambientContext); // the context is still there
         }
 
+        [TestCase(true)]
+        [TestCase(false)]
+        public void ScopeContextEnlistAgain(bool complete)
+        {
+            var scopeProvider = DatabaseContext.ScopeProvider;
+
+            bool? completed = null;
+            Exception exception = null;
+
+            Assert.IsNull(scopeProvider.AmbientScope);
+            using (var scope = scopeProvider.CreateScope())
+            {
+                scopeProvider.Context.Enlist("name", c =>
+                {
+                    completed = c;
+
+                    // at that point the scope is gone, but the context is still there
+                    var ambientContext = scopeProvider.AmbientContext;
+
+                    try
+                    {
+                        ambientContext.Enlist("another", c2 => { });
+                    }
+                    catch (Exception e)
+                    {
+                        exception = e;
+                    }
+                });
+                if (complete)
+                    scope.Complete();
+            }
+            Assert.IsNull(scopeProvider.AmbientScope);
+            Assert.IsNull(scopeProvider.AmbientContext);
+            Assert.IsNotNull(completed);
+            Assert.IsNotNull(exception);
+            Assert.IsInstanceOf<InvalidOperationException>(exception);
+        }
+
         [Test]
         public void ScopeContextException()
         {

src/Umbraco.Tests/Scoping/ScopedXmlTests.cs

@@ -179,7 +179,9 @@ namespace Umbraco.Tests.Scoping
                     scope.Complete();
             }
 
-            Assert.AreEqual(complete ? 2 : 0, evented);
+            //The reason why there is only 1 event occuring is because we are publishing twice for the same event for the same
+            //object and the scope deduplicates the events (uses the latest)
+            Assert.AreEqual(complete ? 1 : 0, evented);
 
             // this should never change
             Assert.AreEqual(beforeOuterXml, beforeXml.OuterXml);

src/Umbraco.Tests/Services/BaseServiceTest.cs

@@ -27,27 +27,27 @@ namespace Umbraco.Tests.Services
 		{
 			//NOTE Maybe not the best way to create/save test data as we are using the services, which are being tested.
 
-			//Create and Save ContentType "umbTextpage" -> 1045
+			//Create and Save ContentType "umbTextpage" -> 1060
 			ContentType contentType = MockedContentTypes.CreateSimpleContentType("umbTextpage", "Textpage");
 			contentType.Key = new Guid("1D3A8E6E-2EA9-4CC1-B229-1AEE19821522");
 			ServiceContext.ContentTypeService.Save(contentType);
 
-			//Create and Save Content "Homepage" based on "umbTextpage" -> 1046
+			//Create and Save Content "Homepage" based on "umbTextpage" -> 1061
 			Content textpage = MockedContent.CreateSimpleContent(contentType);
 			textpage.Key = new Guid("B58B3AD4-62C2-4E27-B1BE-837BD7C533E0");
 			ServiceContext.ContentService.Save(textpage, 0);
 
-			//Create and Save Content "Text Page 1" based on "umbTextpage" -> 1047
+			//Create and Save Content "Text Page 1" based on "umbTextpage" -> 1062
 			Content subpage = MockedContent.CreateSimpleContent(contentType, "Text Page 1", textpage.Id);
 			subpage.ReleaseDate = DateTime.Now.AddMinutes(-5);
             subpage.ChangePublishedState(PublishedState.Saved);
 			ServiceContext.ContentService.Save(subpage, 0);
 
-			//Create and Save Content "Text Page 1" based on "umbTextpage" -> 1048
+			//Create and Save Content "Text Page 1" based on "umbTextpage" -> 1063
 			Content subpage2 = MockedContent.CreateSimpleContent(contentType, "Text Page 2", textpage.Id);
 			ServiceContext.ContentService.Save(subpage2, 0);
 
-			//Create and Save Content "Text Page Deleted" based on "umbTextpage" -> 1049
+			//Create and Save Content "Text Page Deleted" based on "umbTextpage" -> 1064
 			Content trashed = MockedContent.CreateSimpleContent(contentType, "Text Page Deleted", -20);
 			trashed.Trashed = true;
 			ServiceContext.ContentService.Save(trashed, 0);

src/Umbraco.Tests/Services/EntityServiceTests.cs

@@ -533,6 +533,44 @@ namespace Umbraco.Tests.Services
             Assert.AreEqual(mediaObjectType, UmbracoObjectTypes.MediaType);
         }
 
+        [Test]
+        public void EntityService_Can_Get_Key_For_Id()
+        {
+            var service = ServiceContext.EntityService;
+            var result = service.GetKeyForId(1060, UmbracoObjectTypes.DocumentType);
+
+            Assert.IsTrue(result.Success);
+            Assert.AreEqual(Guid.Parse("1D3A8E6E-2EA9-4CC1-B229-1AEE19821522"), result.Result);
+        }
+
+        [Test]
+        public void EntityService_Cannot_Get_Key_For_Id_With_Incorrect_Object_Type()
+        {
+            var service = ServiceContext.EntityService;
+            var result = service.GetKeyForId(1060, UmbracoObjectTypes.MediaType);
+
+            Assert.IsFalse(result.Success);
+        }
+
+        [Test]
+        public void EntityService_Can_Get_Id_For_Key()
+        {
+            var service = ServiceContext.EntityService;
+            var result = service.GetIdForKey(Guid.Parse("1D3A8E6E-2EA9-4CC1-B229-1AEE19821522"), UmbracoObjectTypes.DocumentType);
+
+            Assert.IsTrue(result.Success);
+            Assert.AreEqual(1060, result.Result);
+        }
+
+        [Test]
+        public void EntityService_Cannot_Get_Id_For_Key_With_Incorrect_Object_Type()
+        {
+            var service = ServiceContext.EntityService;
+            var result = service.GetIdForKey(Guid.Parse("1D3A8E6E-2EA9-4CC1-B229-1AEE19821522"), UmbracoObjectTypes.MediaType);
+
+            Assert.IsFalse(result.Success);
+        }
+
         private static bool _isSetup = false;
 
         private int folderId;

src/Umbraco.Tests/TestHelpers/ConsoleLogger.cs

@@ -2,7 +2,7 @@
 using System.Linq;
 using Umbraco.Core.Logging;
 
-namespace Umbraco.Tests.Logging
+namespace Umbraco.Tests.TestHelpers
 {
     public class ConsoleLogger : ILogger
     {

src/Umbraco.Tests/Umbraco.Tests.csproj

@@ -58,14 +58,20 @@
     <Reference Include="AutoMapper.Net4, Version=3.3.1.0, Culture=neutral, PublicKeyToken=be96cd2c38ef1005, processorArchitecture=MSIL">
       <HintPath>..\packages\AutoMapper.3.3.1\lib\net40\AutoMapper.Net4.dll</HintPath>
     </Reference>
+    <Reference Include="Castle.Core, Version=4.0.0.0, Culture=neutral, PublicKeyToken=407dd0808d44fbdc, processorArchitecture=MSIL">
+      <HintPath>..\packages\Castle.Core.4.0.0\lib\net45\Castle.Core.dll</HintPath>
+    </Reference>
     <Reference Include="Examine, Version=0.1.82.0, Culture=neutral, processorArchitecture=MSIL">
       <HintPath>..\packages\Examine.0.1.82\lib\net45\Examine.dll</HintPath>
     </Reference>
     <Reference Include="ICSharpCode.SharpZipLib, Version=0.86.0.518, Culture=neutral, PublicKeyToken=1b03e6acf1164f73, processorArchitecture=MSIL">
       <HintPath>..\packages\SharpZipLib.0.86.0\lib\20\ICSharpCode.SharpZipLib.dll</HintPath>
     </Reference>
-    <Reference Include="log4net, Version=1.2.15.0, Culture=neutral, PublicKeyToken=669e0ddf0bb1aa2a, processorArchitecture=MSIL">
-      <HintPath>..\packages\log4net.2.0.5\lib\net45-full\log4net.dll</HintPath>
+    <Reference Include="log4net, Version=2.0.8.0, Culture=neutral, PublicKeyToken=669e0ddf0bb1aa2a, processorArchitecture=MSIL">
+      <HintPath>..\packages\log4net.2.0.8\lib\net45-full\log4net.dll</HintPath>
+    </Reference>
+    <Reference Include="Log4Net.Async, Version=2.0.4.0, Culture=neutral, processorArchitecture=MSIL">
+      <HintPath>..\packages\Log4Net.Async.2.0.4\lib\net40\Log4Net.Async.dll</HintPath>
     </Reference>
     <Reference Include="Lucene.Net, Version=2.9.4.1, Culture=neutral, PublicKeyToken=85089178b9ac3181, processorArchitecture=MSIL">
       <HintPath>..\packages\Lucene.Net.2.9.4.1\lib\net40\Lucene.Net.dll</HintPath>
@@ -82,8 +88,8 @@
     <Reference Include="Moq, Version=4.1.1309.919, Culture=neutral, PublicKeyToken=69f491c39445e920, processorArchitecture=MSIL">
       <HintPath>..\packages\Moq.4.1.1309.0919\lib\net40\Moq.dll</HintPath>
     </Reference>
-    <Reference Include="Newtonsoft.Json, Version=9.0.0.0, Culture=neutral, PublicKeyToken=30ad4fe6b2a6aeed, processorArchitecture=MSIL">
-      <HintPath>..\packages\Newtonsoft.Json.9.0.1\lib\net45\Newtonsoft.Json.dll</HintPath>
+    <Reference Include="Newtonsoft.Json, Version=10.0.0.0, Culture=neutral, PublicKeyToken=30ad4fe6b2a6aeed, processorArchitecture=MSIL">
+      <HintPath>..\packages\Newtonsoft.Json.10.0.2\lib\net45\Newtonsoft.Json.dll</HintPath>
     </Reference>
     <Reference Include="nunit.framework, Version=2.6.2.12296, Culture=neutral, PublicKeyToken=96d09a1eb7f44a77, processorArchitecture=MSIL">
       <HintPath>..\packages\NUnit.2.6.2\lib\nunit.framework.dll</HintPath>
@@ -91,9 +97,8 @@
     <Reference Include="Owin, Version=1.0.0.0, Culture=neutral, PublicKeyToken=f0ebd12fd5e55cc5, processorArchitecture=MSIL">
       <HintPath>..\packages\Owin.1.0\lib\net40\Owin.dll</HintPath>
     </Reference>
-    <Reference Include="Semver, Version=2.0.4.0, Culture=neutral, processorArchitecture=MSIL">
-      <HintPath>..\packages\Semver.2.0.4\lib\netstandard1.1\Semver.dll</HintPath>
-      <Private>True</Private>
+    <Reference Include="Semver, Version=1.1.2.0, Culture=neutral, processorArchitecture=MSIL">
+      <HintPath>..\packages\semver.1.1.2\lib\net45\Semver.dll</HintPath>
     </Reference>
     <Reference Include="System" />
     <Reference Include="System.ComponentModel.Composition" />
@@ -162,7 +167,7 @@
     <Compile Include="Issues\U9560.cs" />
     <Compile Include="Collections\OrderedHashSetTests.cs" />
     <Compile Include="IO\ShadowFileSystemTests.cs" />
-    <Compile Include="Logging\ConsoleLogger.cs" />
+    <Compile Include="TestHelpers\ConsoleLogger.cs" />
     <Compile Include="Migrations\CreateTableMigrationTests.cs" />
     <Compile Include="Migrations\MigrationIssuesTests.cs" />
     <Compile Include="Persistence\LocksTests.cs" />
@@ -204,9 +209,6 @@
     <Compile Include="Collections\DeepCloneableListTests.cs" />
     <Compile Include="Web\Controllers\BackOfficeControllerUnitTests.cs" />
     <Compile Include="DelegateExtensionsTests.cs" />
-    <Compile Include="Logging\AsyncRollingFileAppenderTest.cs" />
-    <Compile Include="Logging\DebugAppender.cs" />
-    <Compile Include="Logging\ParallelForwarderTest.cs" />
     <Compile Include="Web\Mvc\RenderIndexActionSelectorAttributeTests.cs" />
     <Compile Include="Persistence\Repositories\AuditRepositoryTest.cs" />
     <Compile Include="Persistence\Repositories\DomainRepositoryTest.cs" />
@@ -484,7 +486,6 @@
     <Compile Include="PublishedContent\PublishedContentMoreTests.cs" />
     <Compile Include="Publishing\PublishingStrategyTests.cs" />
     <Compile Include="Resolvers\ActionsResolverTests.cs" />
-    <Compile Include="Logging\RingBufferTest.cs" />
     <Compile Include="TestHelpers\BaseUmbracoConfigurationTest.cs" />
     <Compile Include="TestHelpers\DatabaseTestBehaviorAttribute.cs" />
     <Compile Include="TestHelpers\Entities\MockedMember.cs" />

src/Umbraco.Tests/packages.config

@@ -2,8 +2,10 @@
 <packages>
   <package id="AspNetWebApi.SelfHost" version="4.0.20710.0" targetFramework="net45" />
   <package id="AutoMapper" version="3.3.1" targetFramework="net45" />
+  <package id="Castle.Core" version="4.0.0" targetFramework="net45" />
   <package id="Examine" version="0.1.82" targetFramework="net45" />
-  <package id="log4net" version="2.0.5" targetFramework="net45" />
+  <package id="log4net" version="2.0.8" targetFramework="net45" />
+  <package id="Log4Net.Async" version="2.0.4" targetFramework="net45" />
   <package id="Lucene.Net" version="2.9.4.1" targetFramework="net45" />
   <package id="Microsoft.AspNet.Mvc" version="5.2.3" targetFramework="net45" />
   <package id="Microsoft.AspNet.Razor" version="3.2.3" targetFramework="net45" />
@@ -17,15 +19,15 @@
   <package id="Microsoft.Web.Infrastructure" version="1.0.0.0" targetFramework="net45" />
   <package id="MiniProfiler" version="2.1.0" targetFramework="net45" />
   <package id="Moq" version="4.1.1309.0919" targetFramework="net45" />
-  <package id="Newtonsoft.Json" version="9.0.1" targetFramework="net462" />
+  <package id="Newtonsoft.Json" version="10.0.2" targetFramework="net45" />
   <package id="NUnit" version="2.6.2" targetFramework="net45" />
   <package id="Owin" version="1.0" targetFramework="net45" />
   <package id="Selenium.WebDriver" version="2.32.0" targetFramework="net45" />
-  <package id="Semver" version="2.0.4" targetFramework="net45" />
+  <package id="semver" version="1.1.2" targetFramework="net45" />
   <package id="SharpZipLib" version="0.86.0" targetFramework="net45" />
   <package id="SqlServerCE" version="4.0.0.1" targetFramework="net45" />
-  <package id="System.Runtime" version="4.1.0" targetFramework="net45" />
-  <package id="System.Runtime.Extensions" version="4.1.0" targetFramework="net45" />
-  <package id="System.Runtime.InteropServices" version="4.1.0" targetFramework="net45" />
-  <package id="System.Text.RegularExpressions" version="4.1.0" targetFramework="net45" />
+  <package id="System.Runtime" version="4.3.0" targetFramework="net45" />
+  <package id="System.Runtime.Extensions" version="4.3.0" targetFramework="net45" />
+  <package id="System.Runtime.InteropServices" version="4.3.0" targetFramework="net45" />
+  <package id="System.Text.RegularExpressions" version="4.3.0" targetFramework="net45" />
 </packages>

src/Umbraco.Web.UI.Client/gruntFile.js

@@ -536,7 +536,23 @@ module.exports = function (grunt) {
                             ]
                         },
                         'ace-builds': {
-                           files: ['src-min-noconflict/**']
+                           files: [
+                                'src-min-noconflict/ace.js',
+                                
+                                'src-min-noconflict/ext-language_tools.js',
+                                'src-min-noconflict/ext-searchbox.js',
+                                'src-min-noconflict/ext-settings_menu.js',
+
+                                'src-min-noconflict/snippets/text.js',
+                                'src-min-noconflict/snippets/javascript.js',
+                                
+                                'src-min-noconflict/theme-chrome.js',
+                                
+                                'src-min-noconflict/mode-razor.js',
+                                'src-min-noconflict/mode-javascript.js',
+                                
+                                'src-min-noconflict/worker-javascript.js',
+                            ]
                        }
                     }
                 }

src/Umbraco.Web.UI.Client/lib/tinymce/skins/umbraco/content.min.css

@@ -1,7 +1,8 @@
 body.mce-content-body {
     background-color: #fff;
     font-family: Verdana,Arial,Helvetica,sans-serif;
-    font-size: 11px;
+    font-size: 14px;
+    line-height: 1.5em;
     scrollbar-3dlight-color: #f0f0ee;
     scrollbar-arrow-color: #676662;
     scrollbar-base-color: #f0f0ee;

src/Umbraco.Web.UI.Client/src/common/resources/contenttype.resource.js

@@ -92,6 +92,16 @@ function contentTypeResource($q, $http, umbRequestHelper, umbDataFormatter) {
                'Failed to retrieve property type aliases');
         },
 
+        getAllStandardFields: function () {
+
+            return umbRequestHelper.resourcePromise(
+               $http.get(
+                   umbRequestHelper.getApiUrl(
+                       "contentTypeApiBaseUrl",
+                       "GetAllStandardFields")),
+               'Failed to retrieve standard fields');
+        },
+
         getPropertyTypeScaffold : function (id) {
               return umbRequestHelper.resourcePromise(
                $http.get(

src/Umbraco.Web.UI.Client/src/common/resources/ourpackagerrepository.resource.js

@@ -5,15 +5,14 @@
     **/
 function ourPackageRepositoryResource($q, $http, umbDataFormatter, umbRequestHelper) {
 
-    //var baseurl = "http://localhost:24292/webapi/packages/v1";
-    var baseurl = "https://our.umbraco.org/webapi/packages/v1";
+    var baseurl = Umbraco.Sys.ServerVariables.umbracoUrls.packagesRestApiBaseUrl;
 
     return {
         
         getDetails: function (packageId) {
 
             return umbRequestHelper.resourcePromise(
-               $http.get(baseurl + "/" + packageId),
+               $http.get(baseurl + "/" + packageId + "?version=" + Umbraco.Sys.ServerVariables.application.version),
                'Failed to get package details');
         },
 

src/Umbraco.Web.UI.Client/src/less/alerts.less

@@ -11,7 +11,7 @@
   margin-bottom: @baseLineHeight;
   background-color: @warningBackground;
   border: 1px solid @warningBorder;
-  .border-radius(@baseBorderRadius);
+  .border-radius(@alertBorderRadius);
 }
 .alert,
 .alert h4,

src/Umbraco.Web.UI.Client/src/less/buttons.less

@@ -65,7 +65,10 @@
     -webkit-box-shadow:none;
 }
 
-
+.btn-group .btn.dropdown-toggle {
+    border-left-width: 1px;
+    border-left-style: solid;
+}
 
 // Button Sizes
 // --------------------------------------------------