Bumps version to 7.8.2

# Conflicts:
#	src/SolutionInfo.cs
#	src/Umbraco.Core/Configuration/UmbracoVersion.cs

.editorconfig

@@ -1,10 +1,16 @@
-root=true
+# editorconfig.org
 
+# top-most EditorConfig file
+root = true
+
+# Default settings:
+# A newline ending every file
+# Use 4 spaces as indentation
 [*]
-end_of_line = lf
+insert_final_newline = true
 indent_style = space
 indent_size = 4
-trim_trailing_whitespace = true
 
-[*.{cs,cshtml,csx,vb,vbx,vbhtml,fs,fsx,txt,ps1,sql}]
-indent_size = 4
+# Trim trailing whitespace, limited support.
+# https://github.com/editorconfig/editorconfig/wiki/Property-research:-Trim-trailing-spaces
+trim_trailing_whitespace = true

.gitattributes

@@ -0,0 +1,49 @@
+*.doc  diff=astextplain
+*.DOC	diff=astextplain
+*.docx	diff=astextplain
+*.DOCX	diff=astextplain
+*.dot	diff=astextplain
+*.DOT	diff=astextplain
+*.pdf	diff=astextplain
+*.PDF	diff=astextplain
+*.rtf	diff=astextplain
+*.RTF	diff=astextplain
+
+*.jpg  	binary
+*.png 	binary
+*.gif 	binary
+
+*.cs text=auto diff=csharp 
+*.vb text=auto
+*.c text=auto
+*.cpp text=auto
+*.cxx text=auto
+*.h text=auto
+*.hxx text=auto
+*.py text=auto
+*.rb text=auto
+*.java text=auto
+*.html text=auto
+*.htm text=auto
+*.css text=auto
+*.scss text=auto
+*.sass text=auto
+*.less text=auto
+*.js text=auto
+*.lisp text=auto
+*.clj text=auto
+*.sql text=auto
+*.php text=auto
+*.lua text=auto
+*.m text=auto
+*.asm text=auto
+*.erl text=auto
+*.fs text=auto
+*.fsx text=auto
+*.hs text=auto
+
+*.csproj text=auto merge=union 
+*.vbproj text=auto merge=union 
+*.fsproj text=auto merge=union 
+*.dbproj text=auto merge=union 
+*.sln text=auto eol=crlf merge=union 

.gitignore

@@ -139,4 +139,5 @@ src/PrecompiledWeb/*
 
 build.out/
 build.tmp/
-build/Modules/*/temp/
+build/Modules/*/temp/
+/src/.idea/*

build/Modules/Umbraco.Build/Build-UmbracoDocs.ps1

@@ -44,7 +44,7 @@ function Build-UmbracoDocs
   # change baseUrl
   $baseUrl = "https://our.umbraco.org/apidocs/ui/"
   $indexPath = "$src/Umbraco.Web.UI.Client/docs/api/index.html"
-  (Get-Content $indexPath).Replace("location.href.replace(rUrl, indexFile)", "'$baseUrl'") `
+  (Get-Content $indexPath).Replace("origin + location.href.substr(origin.length).replace(rUrl, indexFile)", "'$baseUrl'") `
     | Set-Content $indexPath
     
   # restore
@@ -100,8 +100,9 @@ function Get-DocFx($uenv, $buildTemp)
   $docFx = "$buildTemp\docfx"
   if (-not (test-path $docFx))
   {
-    Write-Host "Download DocFx..."
     $source = "https://github.com/dotnet/docfx/releases/download/v2.19.2/docfx.zip"
+    Write-Host "Download DocFx from $source"
+    
     Invoke-WebRequest $source -OutFile "$buildTemp\docfx.zip"
     
     &$uenv.Zip x "$buildTemp\docfx.zip" -o"$buildTemp\docfx" -aos > $nul

build/Modules/Umbraco.Build/Umbraco.Build.psm1

@@ -239,18 +239,18 @@ function Prepare-Tests
   
   # data
   Write-Host "Copy data files"
-  if( -Not (Test-Path -Path "$tmp\tests\Packaging" ) )
+  if (-Not (Test-Path -Path "$tmp\tests\Packaging" ) )
   {
     Write-Host "Create packaging directory"
-    New-Item -ItemType directory -Path "$tmp\tests\Packaging"
+    mkdir "$tmp\tests\Packaging" > $null
   }
   Copy-Files "$src\Umbraco.Tests\Packaging\Packages" "*" "$tmp\tests\Packaging\Packages"
   
   # required for package install tests  
-  if( -Not (Test-Path -Path "$tmp\tests\bin" ) )
+  if (-Not (Test-Path -Path "$tmp\tests\bin" ) )
   {
     Write-Host "Create bin directory"
-    New-Item -ItemType directory -Path "$tmp\tests\bin"
+    mkdir "$tmp\tests\bin" > $null
   }
 }
 

build/NuSpecs/UmbracoCms.Core.nuspec

@@ -27,13 +27,12 @@
       <dependency id="MiniProfiler" version="[2.1.0, 3.0.0)" />
       <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.9, 7.0.0)" />
-      <dependency id="ClientDependency" version="[1.9.2, 2.0.0)" />
+      <dependency id="ClientDependency" version="[1.9.6, 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="[10.0.2, 11.0.0)" />
-      <dependency id="Examine" version="[0.1.88, 1.0.0)" />
+      <dependency id="Examine" version="[0.1.89, 1.0.0)" />
       <dependency id="ImageProcessor" version="[2.5.6, 3.0.0)" />
       <dependency id="ImageProcessor.Web" version="[4.8.7, 5.0.0)" />
       <dependency id="semver" version="[1.1.2, 3.0.0)" />

build/NuSpecs/UmbracoCms.nuspec

@@ -17,7 +17,7 @@
     <dependencies>
       <dependency id="UmbracoCms.Core" version="[$version$]" />
       <dependency id="Newtonsoft.Json" version="[10.0.2, 11.0.0)" />
-      <dependency id="Umbraco.ModelsBuilder" version="[3.0.7, 4.0.0)" />
+      <dependency id="Umbraco.ModelsBuilder" version="[3.0.10, 4.0.0)" />
       <dependency id="Microsoft.AspNet.SignalR.Core" version="[2.2.1, 3.0.0)" />
 	  <dependency id="ImageProcessor.Web.Config" version="[2.3.1, 3.0.0)" />
     </dependencies>
@@ -32,6 +32,7 @@
     <file src="$BuildTmp$\WebApp\bin\amd64\**" target="UmbracoFiles\bin\amd64" />
     <file src="$BuildTmp$\WebApp\bin\x86\**" target="UmbracoFiles\bin\x86" />
     <file src="$BuildTmp$\WebApp\config\splashes\**" target="UmbracoFiles\Config\splashes" />
+    <file src="$BuildTmp$\WebApp\config\BackOfficeTours\**" target="Content\Config\BackOfficeTours" />
     <file src="$BuildTmp$\WebApp\umbraco\**" target="UmbracoFiles\umbraco" />
     <file src="$BuildTmp$\WebApp\umbraco_client\**" target="UmbracoFiles\umbraco_client" />
     <file src="$BuildTmp$\WebApp\Media\Web.config" target="Content\Media\Web.config" />

build/NuSpecs/tools/install.ps1

@@ -98,10 +98,51 @@ if ($project) {
 		$umbracoUIXMLDestination = Join-Path $projectPath "Umbraco\Config\Create\UI.xml"
 		Copy-Item $umbracoUIXMLSource $umbracoUIXMLDestination -Force
 	} else {
+		# This part only runs for upgrades
+	
 		$upgradeViewSource = Join-Path $umbracoFolderSource "Views\install\*"
 		$upgradeView = Join-Path $umbracoFolder "Views\install\"
 		Write-Host "Copying2 ${upgradeViewSource} to ${upgradeView}"
 		Copy-Item $upgradeViewSource $upgradeView -Force
+		
+		Try 
+		{
+			# Disable tours for upgrades, presumably Umbraco experience is already available
+			$umbracoSettingsConfigPath = Join-Path $configFolder "umbracoSettings.config"
+			$content = (Get-Content $umbracoSettingsConfigPath).Replace('<tours enable="true">','<tours enable="false">')
+			# Saves with UTF-8 encoding without BOM which makes sure Umbraco can still read it
+			# Reference: https://stackoverflow.com/a/32951824/5018
+			[IO.File]::WriteAllLines($umbracoSettingsConfigPath, $content)
+		} 
+		Catch 
+		{
+			# Not a big problem if this fails, let it go
+		}
+		
+		Try 
+		{
+			$uiXmlConfigPath = Join-Path $umbracoFolder -ChildPath "Config" | Join-Path -ChildPath "create" | Join-Path -ChildPath "UI.xml"
+			$uiXmlFile = Join-Path $umbracoFolder -ChildPath "Config" | Join-Path -ChildPath "create" | Join-Path -ChildPath "UI.xml"
+
+			$uiXml = New-Object System.Xml.XmlDocument
+			$uiXml.PreserveWhitespace = $true
+
+			$uiXml.Load($uiXmlFile)
+			$createExists = $uiXml.SelectNodes("//nodeType[@alias='macros']/tasks/create")
+
+			if($createExists.Count -eq 0) 
+			{    
+				$macrosTasksNode = $uiXml.SelectNodes("//nodeType[@alias='macros']/tasks")
+
+				#Creating: <create assembly="umbraco" type="macroTasks" />
+				$createNode = $uiXml.CreateElement("create")
+				$createNode.SetAttribute("assembly", "umbraco")
+				$createNode.SetAttribute("type", "macroTasks")
+				$macrosTasksNode.AppendChild($createNode)
+				$uiXml.Save($uiXmlFile)
+			}
+		} 
+		Catch { }
 	}
 	
 	$installFolder = Join-Path $projectPath "Install"

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

@@ -79,14 +79,14 @@
   <add sortOrder="1" alias="dataTypes" application="developer"
        xdt:Locator="Match(application,alias)" 
        xdt:Transform="SetAttributes(sortOrder)" />
-	   
-  <add application="developer" alias="macros" title="Macros" type="umbraco.loadMacros, umbraco" iconClosed="icon-folder" iconOpen="icon-folder" sortOrder="2" 
+
+  <add initialize="true" sortOrder="2" alias="macros" application="developer" iconClosed="icon-folder" iconOpen="icon-folder-open" type="Umbraco.Web.Trees.MacroTreeController, umbraco"
        xdt:Locator="Match(application,alias)" 
        xdt:Transform="SetAttributes()" />
   <add application="developer" alias="relationTypes" title="Relation Types" type="umbraco.loadRelationTypes, umbraco" iconClosed="icon-folder" iconOpen="icon-folder" sortOrder="4" 
        xdt:Locator="Match(application,alias)" 
        xdt:Transform="SetAttributes()" />
-  <add application="developer" alias="xslt" title="XSLT Files" type="umbraco.loadXslt, umbraco" iconClosed="icon-folder" iconOpen="icon-folder" sortOrder="5" 
+  <add initialize="true" sortOrder="5" alias="xslt" application="developer" iconClosed="icon-folder" iconOpen="icon-folder-open" type="Umbraco.Web.Trees.XsltTreeController, umbraco"
        xdt:Locator="Match(application,alias)" 
        xdt:Transform="SetAttributes()" />
   

src/SQLCE4Umbraco/SqlCE4Umbraco.csproj

@@ -49,11 +49,9 @@
     <Reference Include="System.Core" />
     <Reference Include="System.Data.SqlServerCe, Version=4.0.0.1, Culture=neutral, PublicKeyToken=89845dcd8080cc91, processorArchitecture=MSIL">
       <HintPath>..\packages\SqlServerCE.4.0.0.1\lib\System.Data.SqlServerCe.dll</HintPath>
-      <Private>True</Private>
     </Reference>
     <Reference Include="System.Data.SqlServerCe.Entity, Version=4.0.0.1, Culture=neutral, PublicKeyToken=89845dcd8080cc91, processorArchitecture=MSIL">
       <HintPath>..\packages\SqlServerCE.4.0.0.1\lib\System.Data.SqlServerCe.Entity.dll</HintPath>
-      <Private>True</Private>
     </Reference>
     <Reference Include="System.Xml.Linq" />
     <Reference Include="System.Data.DataSetExtensions" />

src/SolutionInfo.cs

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

src/Umbraco.Core/ApplicationContext.cs

@@ -1,6 +1,8 @@
 using System;
+using System.Collections.Generic;
 using System.Configuration;
 using System.Threading;
+using Semver;
 using Umbraco.Core.Configuration;
 using Umbraco.Core.Logging;
 using Umbraco.Core.ObjectResolution;
@@ -260,7 +262,7 @@ namespace Umbraco.Core
         /// - http://issues.umbraco.org/issue/U4-5728
         /// - http://issues.umbraco.org/issue/U4-5391
         /// </remarks>
-        internal string UmbracoApplicationUrl
+        public string UmbracoApplicationUrl
         {
             get
             {
@@ -268,9 +270,21 @@ namespace Umbraco.Core
                 return _umbracoApplicationUrl;
             }
         }
+
+        /// <summary>
+        /// Resets the url.
+        /// </summary>
+        public void ResetUmbracoApplicationUrl()
+        {
+            _umbracoApplicationUrl = null;
+        }
 
 	    // ReSharper disable once InconsistentNaming
-	    internal string _umbracoApplicationUrl;
+	    internal string _umbracoApplicationUrl;
+
+        internal List<string> _umbracoApplicationDomains = new List<string>();
+
+        internal string _umbracoApplicationDeploymentId;
 
         private Lazy<bool> _configured;
         internal MainDom MainDom { get; private set; }
@@ -341,6 +355,52 @@ namespace Umbraco.Core
 			}
 		}
 
+        /// <summary>
+        /// Gets the Current Version of the Umbraco Site before an upgrade
+        /// by using the last/most recent Umbraco Migration that has been run
+        /// </summary>
+        /// <returns>A SemVersion of the latest Umbraco DB Migration run</returns>
+        /// <remarks>
+        /// NOTE: This existed in the InstallHelper previously but should really be here so it can be re-used if necessary
+        /// </remarks>
+        internal SemVersion CurrentVersion()
+        {
+            //Set a default version of 0.0.0
+            var version = new SemVersion(0);
+
+            //If we have a db context available, if we don't then we are not installed anyways
+            if (DatabaseContext.IsDatabaseConfigured && DatabaseContext.CanConnect)
+                version = DatabaseContext.ValidateDatabaseSchema().DetermineInstalledVersionByMigrations(Services.MigrationEntryService);
+
+            if (version != new SemVersion(0))
+                return version;
+
+            // If we aren't able to get a result from the umbracoMigrations table then use the version in web.config, if it's available
+            if (string.IsNullOrWhiteSpace(GlobalSettings.ConfigurationStatus))
+                return version;
+
+            var configuredVersion = GlobalSettings.ConfigurationStatus;
+
+            string currentComment = null;
+
+            var current = configuredVersion.Split('-');
+            if (current.Length > 1)
+                currentComment = current[1];
+
+            Version currentVersion;
+            if (Version.TryParse(current[0], out currentVersion))
+            {
+                version = new SemVersion(
+                    currentVersion.Major,
+                    currentVersion.Minor,
+                    currentVersion.Build,
+                    string.IsNullOrWhiteSpace(currentComment) ? null : currentComment,
+                    currentVersion.Revision > 0 ? currentVersion.Revision.ToString() : null);
+            }
+
+            return version;
+        }
+
         private void AssertIsNotReady()
         {
             if (this.IsReady)

src/Umbraco.Core/Cache/HttpRequestCacheProvider.cs

@@ -146,7 +146,7 @@ namespace Umbraco.Core.Cache
         #region Insert
         #endregion
 
-        private class NoopLocker : DisposableObject
+        private class NoopLocker : DisposableObjectSlim
         {
             protected override void DisposeResources()
             { }

src/Umbraco.Core/Collections/CompositeTypeTypeKey.cs

@@ -0,0 +1,61 @@
+using System;
+
+namespace Umbraco.Core.Collections
+{
+    /// <summary>
+    /// Represents a composite key of (Type, Type) for fast dictionaries.
+    /// </summary>
+    internal struct CompositeTypeTypeKey : IEquatable<CompositeTypeTypeKey>
+    {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="CompositeTypeTypeKey"/> struct.
+        /// </summary>
+        public CompositeTypeTypeKey(Type type1, Type type2) : this()
+        {
+            Type1 = type1;
+            Type2 = type2;
+        }
+
+        /// <summary>
+        /// Gets the first type.
+        /// </summary>
+        public Type Type1 { get; private set; }
+
+        /// <summary>
+        /// Gets the second type.
+        /// </summary>
+        public Type Type2 { get; private set; }
+
+        /// <inheritdoc/>
+        public bool Equals(CompositeTypeTypeKey other)
+        {
+            return Type1 == other.Type1 && Type2 == other.Type2;
+        }
+
+        /// <inheritdoc/>
+        public override bool Equals(object obj)
+        {
+            var other = obj is CompositeTypeTypeKey ? (CompositeTypeTypeKey)obj : default(CompositeTypeTypeKey);
+            return Type1 == other.Type1 && Type2 == other.Type2;
+        }
+
+        public static bool operator ==(CompositeTypeTypeKey key1, CompositeTypeTypeKey key2)
+        {
+            return key1.Type1 == key2.Type1 && key1.Type2 == key2.Type2;
+        }
+
+        public static bool operator !=(CompositeTypeTypeKey key1, CompositeTypeTypeKey key2)
+        {
+            return key1.Type1 != key2.Type1 || key1.Type2 != key2.Type2;
+        }
+
+        /// <inheritdoc/>
+        public override int GetHashCode()
+        {
+            unchecked
+            {
+                return (Type1.GetHashCode() * 397) ^ Type2.GetHashCode();
+            }
+        }
+    }
+}

src/Umbraco.Core/Collections/TypeList.cs

@@ -0,0 +1,33 @@
+using System;
+using System.Collections.Generic;
+
+namespace Umbraco.Core.Collections
+{
+    /// <summary>
+    /// Represents a list of types.
+    /// </summary>
+    /// <remarks>Types in the list are, or derive from, or implement, the base type.</remarks>
+    /// <typeparam name="TBase">The base type.</typeparam>
+    internal class TypeList<TBase>
+    {
+        private readonly List<Type> _list = new List<Type>();
+
+        /// <summary>
+        /// Adds a type to the list.
+        /// </summary>
+        /// <typeparam name="T">The type to add.</typeparam>
+        public void Add<T>()
+            where T : TBase
+        {
+            _list.Add(typeof(T));
+        }
+
+        /// <summary>
+        /// Determines whether a type is in the list.
+        /// </summary>
+        public bool Contains(Type type)
+        {
+            return _list.Contains(type);
+        }
+    }
+}

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

@@ -0,0 +1,18 @@
+using System.Configuration;
+
+namespace Umbraco.Core.Configuration.UmbracoSettings
+{
+    internal class BackOfficeElement : UmbracoConfigurationElement, IBackOfficeSection
+    {
+        [ConfigurationProperty("tours")]
+        internal TourConfigElement Tours
+        {
+            get { return (TourConfigElement)this["tours"]; }
+        }
+
+        ITourSection IBackOfficeSection.Tours
+        {
+            get { return Tours; }
+        }
+    }
+}

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

@@ -0,0 +1,7 @@
+namespace Umbraco.Core.Configuration.UmbracoSettings
+{
+    public interface IBackOfficeSection
+    {
+        ITourSection Tours { get; }
+    }
+}

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

@@ -0,0 +1,7 @@
+namespace Umbraco.Core.Configuration.UmbracoSettings
+{
+    public interface ITourSection
+    {
+        bool EnableTours { get; }
+    }
+}

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

@@ -5,6 +5,8 @@ namespace Umbraco.Core.Configuration.UmbracoSettings
 {
     public interface IUmbracoSettingsSection : IUmbracoConfigurationSection
     {
+        IBackOfficeSection BackOffice { get; }
+
         IContentSection Content { get; }
 
         ISecuritySection Security { get; }

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

@@ -0,0 +1,17 @@
+using System.Configuration;
+
+namespace Umbraco.Core.Configuration.UmbracoSettings
+{
+    internal class TourConfigElement : UmbracoConfigurationElement, ITourSection
+    {
+        //disabled by default so that upgraders don't get it enabled by default
+        //TODO: we probably just want to disable the initial one from automatically loading ?
+        [ConfigurationProperty("enable", DefaultValue = false)]
+        public bool EnableTours
+        {
+            get { return (bool)this["enable"]; }
+        }
+
+        //TODO: We could have additional filters, etc... defined here
+    }
+}

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

@@ -8,6 +8,12 @@ namespace Umbraco.Core.Configuration.UmbracoSettings
 
     public class UmbracoSettingsSection : ConfigurationSection, IUmbracoSettingsSection
     {
+        [ConfigurationProperty("backOffice")]
+        internal BackOfficeElement BackOffice
+        {
+            get { return (BackOfficeElement)this["backOffice"]; }
+        }
+
         [ConfigurationProperty("content")]
         internal ContentElement Content
         {
@@ -149,6 +155,11 @@ namespace Umbraco.Core.Configuration.UmbracoSettings
             get { return Templates; }
         }
 
+        IBackOfficeSection IUmbracoSettingsSection.BackOffice
+        {
+            get { return BackOffice; }
+        }
+
         IDeveloperSection IUmbracoSettingsSection.Developer
         {
             get { return Developer; }

src/Umbraco.Core/Configuration/UmbracoVersion.cs

@@ -6,7 +6,7 @@ namespace Umbraco.Core.Configuration
 {
     public class UmbracoVersion
     {
-        private static readonly Version Version = new Version("7.7.7");
+        private static readonly Version Version = new Version("7.8.2");
 
         /// <summary>
         /// Gets the current version of Umbraco.

src/Umbraco.Core/Constants-Applications.cs

@@ -73,6 +73,11 @@
             /// </summary>
             public const string Media = "media";
 
+            /// <summary>
+            /// alias for the macro tree.
+            /// </summary>
+            public const string Macros = "macros";
+            
             /// <summary>
             /// alias for the datatype tree.
             /// </summary>

src/Umbraco.Core/Constants-System.cs

@@ -11,17 +11,53 @@
             /// The integer identifier for global system root node.
             /// </summary>
             public const int Root = -1;
+
+            /// <summary>
+            /// The string identifier for global system root node.
+            /// </summary>
+            /// <remarks>Use this instead of re-creating the string everywhere.</remarks>
+            public const string RootString = "-1";
 
             /// <summary>
             /// The integer identifier for content's recycle bin.
             /// </summary>
             public const int RecycleBinContent = -20;
+
+            /// <summary>
+            /// The string identifier for content's recycle bin.
+            /// </summary>
+            /// <remarks>Use this instead of re-creating the string everywhere.</remarks>
+            public const string RecycleBinContentString = "-20";
+
+            /// <summary>
+            /// The string path prefix of the content's recycle bin.
+            /// </summary>
+            /// <remarks>
+            /// <para>Everything that is in the content recycle bin, has a path that starts with the prefix.</para>
+            /// <para>Use this instead of re-creating the string everywhere.</para>
+            /// </remarks>
+            public const string RecycleBinContentPathPrefix = "-1,-20,";
 
             /// <summary>
             /// The integer identifier for media's recycle bin.
             /// </summary>
             public const int RecycleBinMedia = -21;
 
+            /// <summary>
+            /// The string identifier for media's recycle bin.
+            /// </summary>
+            /// <remarks>Use this instead of re-creating the string everywhere.</remarks>
+            public const string RecycleBinMediaString = "-21";
+
+            /// <summary>
+            /// The string path prefix of the media's recycle bin.
+            /// </summary>
+            /// <remarks>
+            /// <para>Everything that is in the media recycle bin, has a path that starts with the prefix.</para>
+            /// <para>Use this instead of re-creating the string everywhere.</para>
+            /// </remarks>
+            public const string RecycleBinMediaPathPrefix = "-1,-21,";
+
             public const int DefaultContentListViewDataTypeId = -95;
             public const int DefaultMediaListViewDataTypeId = -96;
             public const int DefaultMembersListViewDataTypeId = -97;
@@ -29,6 +65,6 @@
             public const string UmbracoConnectionName = "umbracoDbDSN";
             public const string UmbracoMigrationName = "Umbraco";
         }
-        
+
     }
 }

src/Umbraco.Core/DateTimeExtensions.cs

@@ -21,9 +21,9 @@ namespace Umbraco.Core
         public static DateTime TruncateTo(this DateTime dt, DateTruncate truncateTo)
         {
             if (truncateTo == DateTruncate.Year)
-                return new DateTime(dt.Year, 0, 0);
+                return new DateTime(dt.Year, 1, 1);
             if (truncateTo == DateTruncate.Month)
-                return new DateTime(dt.Year, dt.Month, 0);
+                return new DateTime(dt.Year, dt.Month, 1);
             if (truncateTo == DateTruncate.Day)
                 return new DateTime(dt.Year, dt.Month, dt.Day);
             if (truncateTo == DateTruncate.Hour)
@@ -41,43 +41,43 @@ namespace Umbraco.Core
             Hour,
             Minute,
             Second
-        }
-
+        }
+
         /// <summary>
-        /// Calculates the number of minutes from a date time, on a rolling daily basis (so if 
+        /// Calculates the number of minutes from a date time, on a rolling daily basis (so if 
         /// date time is before the time, calculate onto next day)
         /// </summary>
         /// <param name="fromDateTime">Date to start from</param>
         /// <param name="scheduledTime">Time to compare against (in Hmm form, e.g. 330, 2200)</param>
-        /// <returns></returns>
-        public static int PeriodicMinutesFrom(this DateTime fromDateTime, string scheduledTime)
-        {
-            // Ensure time provided is 4 digits long
-            if (scheduledTime.Length == 3)
-            {
-                scheduledTime = "0" + scheduledTime;
-            }
-
-            var scheduledHour = int.Parse(scheduledTime.Substring(0, 2));
-            var scheduledMinute = int.Parse(scheduledTime.Substring(2));
-
-            DateTime scheduledDateTime;
-            if (IsScheduledInRemainingDay(fromDateTime, scheduledHour, scheduledMinute))
-            {
-                scheduledDateTime = new DateTime(fromDateTime.Year, fromDateTime.Month, fromDateTime.Day, scheduledHour, scheduledMinute, 0);
-            }
-            else
-            {
-                var nextDay = fromDateTime.AddDays(1);
-                scheduledDateTime = new DateTime(nextDay.Year, nextDay.Month, nextDay.Day, scheduledHour, scheduledMinute, 0);
-            }
-
-            return (int)(scheduledDateTime - fromDateTime).TotalMinutes;
-        }
-
-        private static bool IsScheduledInRemainingDay(DateTime fromDateTime, int scheduledHour, int scheduledMinute)
-        {
-            return scheduledHour > fromDateTime.Hour || (scheduledHour == fromDateTime.Hour && scheduledMinute >= fromDateTime.Minute);
+        /// <returns></returns>
+        public static int PeriodicMinutesFrom(this DateTime fromDateTime, string scheduledTime)
+        {
+            // Ensure time provided is 4 digits long
+            if (scheduledTime.Length == 3)
+            {
+                scheduledTime = "0" + scheduledTime;
+            }
+
+            var scheduledHour = int.Parse(scheduledTime.Substring(0, 2));
+            var scheduledMinute = int.Parse(scheduledTime.Substring(2));
+
+            DateTime scheduledDateTime;
+            if (IsScheduledInRemainingDay(fromDateTime, scheduledHour, scheduledMinute))
+            {
+                scheduledDateTime = new DateTime(fromDateTime.Year, fromDateTime.Month, fromDateTime.Day, scheduledHour, scheduledMinute, 0);
+            }
+            else
+            {
+                var nextDay = fromDateTime.AddDays(1);
+                scheduledDateTime = new DateTime(nextDay.Year, nextDay.Month, nextDay.Day, scheduledHour, scheduledMinute, 0);
+            }
+
+            return (int)(scheduledDateTime - fromDateTime).TotalMinutes;
+        }
+
+        private static bool IsScheduledInRemainingDay(DateTime fromDateTime, int scheduledHour, int scheduledMinute)
+        {
+            return scheduledHour > fromDateTime.Hour || (scheduledHour == fromDateTime.Hour && scheduledMinute >= fromDateTime.Minute);
         }
     }
 }

src/Umbraco.Core/DisposableObject.cs

@@ -2,60 +2,60 @@ using System;
 using System.Threading;
 
 namespace Umbraco.Core
-{
-	/// <summary>
-	/// Abstract implementation of IDisposable.
-	/// </summary>
-	/// <remarks>
-	/// Can also be used as a pattern for when inheriting is not possible.
-	/// 
+{
+    /// <summary>
+    /// Abstract implementation of IDisposable.
+    /// </summary>
+    /// <remarks>
+    /// Can also be used as a pattern for when inheriting is not possible.
+    /// 
     /// See also: https://msdn.microsoft.com/en-us/library/b1yfkh5e%28v=vs.110%29.aspx
     /// See also: https://lostechies.com/chrispatterson/2012/11/29/idisposable-done-right/
     /// 
     /// Note: if an object's ctor throws, it will never be disposed, and so if that ctor
     /// has allocated disposable objects, it should take care of disposing them.
-	/// </remarks>
-	public abstract class DisposableObject : IDisposable
-	{
-		private bool _disposed;
-	    private readonly object _locko = new object();
-
-		// gets a value indicating whether this instance is disposed.
+    /// </remarks>
+    public abstract class DisposableObject : IDisposable
+    {
+        private bool _disposed;
+        private readonly object _locko = new object();
+
+        // gets a value indicating whether this instance is disposed.
         // for internal tests only (not thread safe)
         //TODO make this internal + rename "Disposed" when we can break compatibility
-		public bool IsDisposed { get { return _disposed; } }
-
-		// implements IDisposable
-		public void Dispose()
-		{
-			Dispose(true);
-			GC.SuppressFinalize(this);
-		}
-
-        // finalizer
-		~DisposableObject()
-		{
-			Dispose(false);
-		}
+        public bool IsDisposed { get { return _disposed; } }
+
+        // implements IDisposable
+        public void Dispose()
+        {
+            Dispose(true);
+            GC.SuppressFinalize(this);
+        }
+
+        // finalizer
+        ~DisposableObject()
+        {
+            Dispose(false);
+        }
 
         //TODO make this private, non-virtual when we can break compatibility
-        protected virtual void Dispose(bool disposing)
-		{
-		    lock (_locko)
-		    {
-		        if (_disposed) return;
-		        _disposed = true;
-		    }
+        protected virtual void Dispose(bool disposing)
+        {
+            lock (_locko)
+            {
+                if (_disposed) return;
+                _disposed = true;
+            }
 
             DisposeUnmanagedResources();
 
             if (disposing)
-                DisposeResources();
-		}
-
-		protected abstract void DisposeResources();
-
-		protected virtual void DisposeUnmanagedResources()
-		{ }
-	}
+                DisposeResources();
+        }
+
+        protected abstract void DisposeResources();
+
+        protected virtual void DisposeUnmanagedResources()
+        { }
+    }
 }

src/Umbraco.Core/DisposableObjectSlim.cs

@@ -0,0 +1,38 @@
+using System;
+
+namespace Umbraco.Core
+{
+    /// <summary>
+    /// This should not be use if there are ubmanaged resources to be disposed, use DisposableObject instead
+    /// </summary>
+    public abstract class DisposableObjectSlim : IDisposable
+    {
+        private bool _disposed;
+        private readonly object _locko = new object();
+
+        // gets a value indicating whether this instance is disposed.
+        // for internal tests only (not thread safe)
+        internal bool Disposed { get { return _disposed; } }
+
+        // implements IDisposable
+        public void Dispose()
+        {
+            Dispose(true);
+            GC.SuppressFinalize(this);
+        }
+
+        private void Dispose(bool disposing)
+        {
+            lock (_locko)
+            {
+                if (_disposed) return;
+                _disposed = true;
+            }
+
+            if (disposing)
+                DisposeResources();
+        }
+
+        protected abstract void DisposeResources();
+    }
+}

src/Umbraco.Core/DisposableTimer.cs

@@ -11,8 +11,8 @@ namespace Umbraco.Core
 	/// <summary>
 	/// Starts the timer and invokes a  callback upon disposal. Provides a simple way of timing an operation by wrapping it in a <code>using</code> (C#) statement.
 	/// </summary>
-	public class DisposableTimer : DisposableObject
-	{
+	public class DisposableTimer : DisposableObjectSlim
+    {
 	    private readonly ILogger _logger;
 	    private readonly LogType? _logType;
 	    private readonly IProfiler _profiler;
@@ -209,13 +209,13 @@ namespace Umbraco.Core
                 loggerType,
                 startMessage(),
                 completeMessage());
-        } 
+        }
         #endregion
-
-		/// <summary>
-		/// Handles the disposal of resources. Derived from abstract class <see cref="DisposableObject"/> which handles common required locking logic.
-		/// </summary>
-		protected override void DisposeResources()
+
+        /// <summary>
+        /// Handles the disposal of resources. Derived from abstract class <see cref="DisposableObjectSlim"/> which handles common required locking logic.
+        /// </summary>
+        protected override void DisposeResources()
 		{
             if (_profiler != null)
             {

src/Umbraco.Core/Events/EventMessages.cs

@@ -5,7 +5,7 @@ namespace Umbraco.Core.Events
     /// <summary>
     /// Event messages collection
     /// </summary>
-    public sealed class EventMessages : DisposableObject
+    public sealed class EventMessages : DisposableObjectSlim
     {
         private readonly List<EventMessage> _msgs = new List<EventMessage>();
 

src/Umbraco.Core/Events/ImportPackageEventArgs.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.ComponentModel;
 using Umbraco.Core.Packaging.Models;
 
 namespace Umbraco.Core.Events
@@ -7,18 +8,27 @@ namespace Umbraco.Core.Events
     public class ImportPackageEventArgs<TEntity> : CancellableEnumerableObjectEventArgs<TEntity>, IEquatable<ImportPackageEventArgs<TEntity>>
     {
         private readonly MetaData _packageMetaData;
-
+
+        [EditorBrowsable(EditorBrowsableState.Never)]
+        [Obsolete("Use the overload specifying packageMetaData instead")]
         public ImportPackageEventArgs(TEntity eventObject, bool canCancel)
             : base(new[] { eventObject }, canCancel)
         {
         }
 
-        public ImportPackageEventArgs(TEntity eventObject, MetaData packageMetaData)
-            : base(new[] { eventObject })
+        public ImportPackageEventArgs(TEntity eventObject, MetaData packageMetaData, bool canCancel)
+            : base(new[] { eventObject }, canCancel)
         {
+            if (packageMetaData == null) throw new ArgumentNullException("packageMetaData");
             _packageMetaData = packageMetaData;
         }
 
+        public ImportPackageEventArgs(TEntity eventObject, MetaData packageMetaData)
+            : this(eventObject, packageMetaData, true)
+        {
+            
+        }
+
         public MetaData PackageMetaData
         {
             get { return _packageMetaData; }

src/Umbraco.Core/Events/ScopeEventDispatcherBase.cs

@@ -76,260 +76,257 @@ namespace Umbraco.Core.Events
         {
             if (_events == null)
                 return Enumerable.Empty<IEventDefinition>();
-            
+
+            IReadOnlyList<IEventDefinition> events;
             switch (filter)
             {
                 case EventDefinitionFilter.All:
-                    return FilterSupersededAndUpdateToLatestEntity(_events);
+                    events = _events;
+                    break;
                 case EventDefinitionFilter.FirstIn:
                     var l1 = new OrderedHashSet<IEventDefinition>();
                     foreach (var e in _events)
-                    {
                         l1.Add(e);
-                    }
-                    return FilterSupersededAndUpdateToLatestEntity(l1);
+                    events = l1;
+                    break;
                 case EventDefinitionFilter.LastIn:
                     var l2 = new OrderedHashSet<IEventDefinition>(keepOldest: false);
                     foreach (var e in _events)
-                    {
                         l2.Add(e);
-                    }
-                    return FilterSupersededAndUpdateToLatestEntity(l2);
+                    events = l2;
+                    break;
                 default:
                     throw new ArgumentOutOfRangeException("filter", filter, null);
             }
+
+            return FilterSupersededAndUpdateToLatestEntity(events);
         }
-        
-        private class EventDefinitionTypeData
+
+        private class EventDefinitionInfos
         {
             public IEventDefinition EventDefinition { get; set; }
-            public Type EventArgType { get; set; }
-            public SupersedeEventAttribute[] SupersedeAttributes { get; set; }
+            public Type[] SupersedeTypes { 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)
+
+        // fixme
+        // this is way too convoluted, the superceede attribute is used only on DeleteEventargs to specify
+        // that it superceeds save, publish, move and copy - BUT - publish event args is also used for
+        // unpublishing and should NOT be superceeded - so really it should not be managed at event args
+        // level but at event level
+        //
+        // what we want is:
+        // if an entity is deleted, then all Saved, Moved, Copied, Published events prior to this should
+        // not trigger for the entity - and even though, does it make any sense? making a copy of an entity
+        // should ... trigger?
+        //
+        // not going to refactor it all - we probably want to *always* trigger event but tell people that
+        // due to scopes, they should not expected eg a saved entity to still be around - however, now,
+        // going to write a ugly condition to deal with U4-10764
+
+        // iterates 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)
+        internal 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>();
+            // keeps the 'latest' entity and associated event data
+            var entities = new List<Tuple<IEntity, EventDefinitionInfos>>();
 
+            // collects the event definitions
+            // collects the arguments in result, that require their entities to be updated
             var result = new List<IEventDefinition>();
+            var resultArgs = new List<CancellableObjectEventArgs>();
 
-            //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())
+            // eagerly fetch superceeded arg types for each arg type
+            var argTypeSuperceeding = 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)
+                .ToDictionary(x => x, x => x.GetCustomAttributes<SupersedeEventAttribute>(false).Select(y => y.SupersededEventArgsType).ToArray());
+
+            // iterate over all events and filter
+            //
+            // process the list in reverse, because events are added in the order they are raised and we want to keep
+            // the latest (most recent) entities and filter out what is not relevant anymore (too old), eg if an entity
+            // is Deleted after being Saved, we want to filter out the Saved event
             for (var index = events.Count - 1; index >= 0; index--)
             {
-                var eventDefinition = events[index];
+                var def = events[index];
 
-                var argType = eventDefinition.Args.GetType();
-                var attributes = allArgTypesWithAttributes[eventDefinition.Args.GetType()];
-
-                var meta = new EventDefinitionTypeData
+                var infos = new EventDefinitionInfos
                 {
-                    EventDefinition = eventDefinition,
-                    EventArgType = argType,
-                    SupersedeAttributes = attributes
+                    EventDefinition = def,
+                    SupersedeTypes = argTypeSuperceeding[def.Args.GetType()]
                 };
 
-                var args = eventDefinition.Args as CancellableObjectEventArgs;
-                if (args != null)
+                var args = def.Args as CancellableObjectEventArgs;
+                if (args == null)
                 {
-                    var list = TypeHelper.CreateGenericEnumerableFromObject(args.EventObject);
-
-                    if (list == null)
+                    // not a cancellable event arg, include event definition in result
+                    result.Add(def);
+                }
+                else
+                {
+                    // event object can either be a single object or an enumerable of objects
+                    // try to get as an enumerable, get null if it's not
+                    var eventObjects = TypeHelper.CreateGenericEnumerableFromObject(args.EventObject);
+                    if (eventObjects == null)
                     {
-                        //extract the event object
-                        var obj = args.EventObject as IEntity;
-                        if (obj != null)
+                        // single object, cast as an IEntity
+                        // if cannot cast, cannot filter, nothing - just include event definition in result
+                        var eventEntity = args.EventObject as IEntity;
+                        if (eventEntity == 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));
-                            }
+                            result.Add(def);
+                            continue;
                         }
-                        else
+
+                        // look for this entity in superceding event args
+                        // found = must be removed (ie not added), else track
+                        if (IsSuperceeded(eventEntity, infos, entities) == false)
                         {
-                            //Can't retrieve the entity so cant' filter or inspect, just add to the output
-                            result.Add(eventDefinition);                            
+                            // track
+                            entities.Add(Tuple.Create(eventEntity, infos));
+
+                            // track result arguments
+                            // include event definition in result
+                            resultArgs.Add(args);
+                            result.Add(def);
                         }
                     }
                     else
                     {
+                        // enumerable of objects
                         var toRemove = new List<IEntity>();
-                        foreach (var entity in list)
+                        foreach (var eventObject in eventObjects)
                         {
-                            //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));
-                                }
-                            }
+                            // extract the event object, cast as an IEntity
+                            // if cannot cast, cannot filter, nothing to do - just leave it in the list & continue
+                            var eventEntity = eventObject as IEntity;
+                            if (eventEntity == null)
+                                continue;
+
+                            // look for this entity in superceding event args
+                            // found = must be removed, else track
+                            if (IsSuperceeded(eventEntity, infos, entities))
+                                toRemove.Add(eventEntity);
                             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
-                            }
+                                entities.Add(Tuple.Create(eventEntity, infos));
                         }
 
-                        //remove anything that has been filtered
+                        // remove superceded entities
                         foreach (var entity in toRemove)
-                        {
-                            list.Remove(entity);
-                        }
+                            eventObjects.Remove(entity);
 
-                        //track the event and include in the response if there's still entities remaining in the list
-                        if (list.Count > 0)
+                        // if there are still entities in the list, keep the event definition
+                        if (eventObjects.Count > 0)
                         {
                             if (toRemove.Count > 0)
                             {
-                                //re-assign if the items have changed
-                                args.EventObject = list;
+                                // re-assign if changed
+                                args.EventObject = eventObjects;
                             }
-                            cancelableArgs.Add(args);
-                            result.Add(eventDefinition);
+
+                            // track result arguments
+                            // include event definition in result
+                            resultArgs.Add(args);
+                            result.Add(def);
                         }
                     }
                 }
-                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);
+            // go over all args in result, and update them with the latest instanceof each entity
+            UpdateToLatestEntities(entities, resultArgs);
 
-            //we need to reverse the result since we've been adding by latest added events first!
+            // reverse, since we processed the list in reverse
             result.Reverse();
 
             return result;
         }
 
-        private static void UpdateToLatestEntities(IEnumerable<Tuple<IEntity, EventDefinitionTypeData>> allEntities, IEnumerable<CancellableObjectEventArgs> cancelableArgs)
+        // edits event args to use the latest instance of each entity
+        private static void UpdateToLatestEntities(IEnumerable<Tuple<IEntity, EventDefinitionInfos>> entities, IEnumerable<CancellableObjectEventArgs> args)
         {
-            //Now we'll deal with ensuring that only the latest(non stale) entities are used throughout all event args
-
+            // get the latest entities
+            // ordered hash set + keepOldest will keep the latest inserted entity (in case of duplicates)
             var latestEntities = new OrderedHashSet<IEntity>(keepOldest: true);
-            foreach (var entity in allEntities.OrderByDescending(entity => entity.Item1.UpdateDate))
-            {
+            foreach (var entity in entities.OrderByDescending(entity => entity.Item1.UpdateDate))
                 latestEntities.Add(entity.Item1);
-            }
 
-            foreach (var args in cancelableArgs)
+            foreach (var arg in args)
             {
-                var list = TypeHelper.CreateGenericEnumerableFromObject(args.EventObject);
-                if (list == null)
+                // event object can either be a single object or an enumerable of objects
+                // try to get as an enumerable, get null if it's not
+                var eventObjects = TypeHelper.CreateGenericEnumerableFromObject(arg.EventObject);
+                if (eventObjects == 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));
+                    // single object
+                    // look for a more recent entity for that object, and replace if any
+                    // works by "equalling" entities ie the more recent one "equals" this one (though different object)
+                    var foundEntity = latestEntities.FirstOrDefault(x => Equals(x, arg.EventObject));
                     if (foundEntity != null)
-                    {
-                        args.EventObject = foundEntity;
-                    }
+                        arg.EventObject = foundEntity;
                 }
                 else
                 {
+                    // enumerable of objects
+                    // same as above but for each object
                     var updated = false;
-
-                    for (int i = 0; i < list.Count; i++)
+                    for (var i = 0; i < eventObjects.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;
-                        }
+                        var foundEntity = latestEntities.FirstOrDefault(x => Equals(x, eventObjects[i]));
+                        if (foundEntity == null) continue;
+                        eventObjects[i] = foundEntity;
+                        updated = true;
                     }
 
                     if (updated)
-                    {
-                        args.EventObject = list;
-                    }
+                        arg.EventObject = eventObjects;
                 }
             }
         }
 
-        /// <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)
+        // determines if a given entity, appearing in a given event definition, should be filtered out,
+        // considering the entities that have already been visited - an entity is filtered out if it
+        // appears in another even definition, which superceedes this event definition.
+        private static bool IsSuperceeded(IEntity entity, EventDefinitionInfos infos, List<Tuple<IEntity, EventDefinitionInfos>> entities)
         {
-            var argType = eventDef.EventDefinition.Args.GetType();
+            //var argType = meta.EventArgsType;
+            var argType = infos.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))
+            // look for other instances of the same entity, coming from an event args that supercedes other event args,
+            // ie is marked with the attribute, and is not this event args (cannot supersede itself)
+            var superceeding = entities
+                .Where(x => x.Item2.SupersedeTypes.Length > 0 // has the attribute
+                    && x.Item2.EventDefinition.Args.GetType() != argType // is not the same
+                    && Equals(x.Item1, entity)) // same entity
                 .ToArray();
 
-            //no args have been processed with this entity so it should not be filtered
-            if (foundByEntity.Length == 0)
+            // first time we see this entity = not filtered
+            if (superceeding.Length == 0)
                 return false;
 
+            // fixme see notes above
+            // delete event args does NOT superceedes 'unpublished' event
+            if (argType.IsGenericType && argType.GetGenericTypeDefinition() == typeof(PublishEventArgs<>) && infos.EventDefinition.EventName == "UnPublished")
+                return false;
+
+            // found occurences, need to determine if this event args is superceded
             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)));
+                // generic, must compare type arguments
+                var supercededBy = superceeding.FirstOrDefault(x =>
+                    x.Item2.SupersedeTypes.Any(y =>
+                        // superceeding a generic type which has the same generic type definition
+                        // fixme no matter the generic type parameters? could be different?
+                        y.IsGenericTypeDefinition && y == argType.GetGenericTypeDefinition()
+                        // or superceeding a non-generic type which is ... fixme how is this ever possible? argType *is* generic?
+                        || y.IsGenericTypeDefinition == false && y == 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));
+                // non-generic, can compare types 1:1
+                var supercededBy = superceeding.FirstOrDefault(x =>
+                    x.Item2.SupersedeTypes.Any(y => y == argType));
                 return supercededBy != null;
             }
         }

src/Umbraco.Core/HashGenerator.cs

@@ -14,7 +14,7 @@ namespace Umbraco.Core
     /// This will use the crypto libs to generate the hash and will try to ensure that 
     /// strings, etc... are not re-allocated so it's not consuming much memory.
     /// </remarks>
-    internal class HashGenerator : DisposableObject
+    internal class HashGenerator : DisposableObjectSlim
     {
         public HashGenerator()
         {

src/Umbraco.Core/HttpContextExtensions.cs

@@ -26,13 +26,13 @@ namespace Umbraco.Core
                 var ipAddress = httpContext.Request.ServerVariables["HTTP_X_FORWARDED_FOR"];
 
                 if (string.IsNullOrEmpty(ipAddress))
-                    return httpContext.Request.ServerVariables["REMOTE_ADDR"];
+                    return httpContext.Request.UserHostAddress;
 
                 var addresses = ipAddress.Split(',');
                 if (addresses.Length != 0)
                     return addresses[0];
 
-                return httpContext.Request.ServerVariables["REMOTE_ADDR"];
+                return httpContext.Request.UserHostAddress;
             }
             catch (System.Exception ex)
             {

src/Umbraco.Core/IO/PhysicalFileSystem.cs

@@ -2,6 +2,7 @@
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
+using System.Threading;
 using Umbraco.Core.Logging;
 
 namespace Umbraco.Core.IO
@@ -107,7 +108,7 @@ namespace Umbraco.Core.IO
 
             try
             {
-                Directory.Delete(fullPath, recursive);
+                WithRetry(() => Directory.Delete(fullPath, recursive));
             }
             catch (DirectoryNotFoundException ex)
             {
@@ -225,8 +226,8 @@ namespace Umbraco.Core.IO
                 return;
 
             try
-            {
-                File.Delete(fullPath);
+            {
+                WithRetry(() => File.Delete(fullPath));
             }
             catch (FileNotFoundException ex)
             {
@@ -378,7 +379,7 @@ namespace Umbraco.Core.IO
             {
                 if (overrideIfExists == false)
                     throw new InvalidOperationException(string.Format("A file at path '{0}' already exists", path));
-                File.Delete(fullPath);
+                WithRetry(() => File.Delete(fullPath));
             }
 
             var directory = Path.GetDirectoryName(fullPath);
@@ -386,9 +387,9 @@ namespace Umbraco.Core.IO
             Directory.CreateDirectory(directory); // ensure it exists
 
             if (copy)
-                File.Copy(physicalPath, fullPath);
+                WithRetry(() => File.Copy(physicalPath, fullPath));
             else
-                File.Move(physicalPath, fullPath);
+                WithRetry(() => File.Move(physicalPath, fullPath));
         }
 
         #region Helper Methods
@@ -417,6 +418,35 @@ namespace Umbraco.Core.IO
             return path;
         }
 
+        protected void WithRetry(Action action)
+        {
+            // 10 times 100ms is 1s
+            const int count = 10;
+            const int pausems = 100;
+
+            for (var i = 0;; i++)
+            {
+                try
+                {
+                    action();
+                    break; // done
+                }
+                catch (IOException e)
+                {
+                    // if it's not *exactly* IOException then it could be
+                    // some inherited exception such as FileNotFoundException,
+                    // and then we don't want to retry
+                    if (e.GetType() != typeof(IOException)) throw;
+
+                    // if we have tried enough, throw, else swallow
+                    // the exception and retry after a pause
+                    if (i == count) throw;
+                }
+
+                Thread.Sleep(pausems);
+            }
+        }
+
         #endregion
     }
 }

src/Umbraco.Core/Manifest/ManifestWatcher.cs

@@ -6,7 +6,7 @@ using Umbraco.Core.Logging;
 
 namespace Umbraco.Core.Manifest
 {
-    internal class ManifestWatcher : DisposableObject
+    internal class ManifestWatcher : DisposableObjectSlim
     {
         private readonly ILogger _logger;
         private readonly List<FileSystemWatcher> _fws = new List<FileSystemWatcher>();

src/Umbraco.Core/Models/AuditItem.cs

@@ -2,18 +2,30 @@
 
 namespace Umbraco.Core.Models
 {
-    public sealed class AuditItem : Entity, IAggregateRoot
+    public sealed class AuditItem : Entity, IAuditItem
     {
+        /// <summary>
+        /// Constructor for creating an item to be created
+        /// </summary>
+        /// <param name="objectId"></param>
+        /// <param name="comment"></param>
+        /// <param name="type"></param>
+        /// <param name="userId"></param>
         public AuditItem(int objectId, string comment, AuditType type, int userId)
         {
+            DisableChangeTracking();
+
             Id = objectId;
             Comment = comment;
             AuditType = type;
             UserId = userId;
+
+            EnableChangeTracking();
         }
 
         public string Comment { get; private set; }
         public AuditType AuditType { get; private set; }
         public int UserId { get; private set; }
+     
     }
 }

src/Umbraco.Core/Models/ContentType.cs

@@ -95,8 +95,10 @@ namespace Umbraco.Core.Models
             get { return _allowedTemplates; }
             set
             {
-                SetPropertyValueAndDetectChanges(value, ref _allowedTemplates, Ps.Value.AllowedTemplatesSelector,
-                   Ps.Value.TemplateComparer);
+                SetPropertyValueAndDetectChanges(value, ref _allowedTemplates, Ps.Value.AllowedTemplatesSelector, Ps.Value.TemplateComparer);
+
+                if (_allowedTemplates.Any(x => x.Id == _defaultTemplate) == false)
+                    DefaultTemplateId = 0;
             }
         }
 

src/Umbraco.Core/Models/IAuditItem.cs

@@ -0,0 +1,12 @@
+using System;
+using Umbraco.Core.Models.EntityBase;
+
+namespace Umbraco.Core.Models
+{
+    public interface IAuditItem : IAggregateRoot
+    {
+        string Comment { get; }
+        AuditType AuditType { get; }
+        int UserId { get; }
+    }
+}

src/Umbraco.Core/Models/Identity/IdentityModelMappings.cs

@@ -40,19 +40,6 @@ namespace Umbraco.Core.Models.Identity
                     identityUser.EnableChangeTracking();
                 });
             
-            config.CreateMap<BackOfficeIdentityUser, UserData>()
-                .ConstructUsing((BackOfficeIdentityUser user) => new UserData(Guid.NewGuid().ToString("N"))) //this is the 'session id'
-                .ForMember(detail => detail.Id, opt => opt.MapFrom(user => user.Id))
-                .ForMember(detail => detail.AllowedApplications, opt => opt.MapFrom(user => user.AllowedSections))
-                .ForMember(detail => detail.Roles, opt => opt.MapFrom(user => user.Roles.Select(x => x.RoleId).ToArray()))
-                .ForMember(detail => detail.RealName, opt => opt.MapFrom(user => user.Name))
-                //When mapping to UserData which is used in the authcookie we want ALL start nodes including ones defined on the groups
-                .ForMember(detail => detail.StartContentNodes, opt => opt.MapFrom(user => user.CalculatedContentStartNodeIds))
-                //When mapping to UserData which is used in the authcookie we want ALL start nodes including ones defined on the groups
-                .ForMember(detail => detail.StartMediaNodes, opt => opt.MapFrom(user => user.CalculatedMediaStartNodeIds))
-                .ForMember(detail => detail.Username, opt => opt.MapFrom(user => user.UserName))
-                .ForMember(detail => detail.Culture, opt => opt.MapFrom(user => user.Culture))
-                .ForMember(detail => detail.SessionId, opt => opt.MapFrom(user => user.SecurityStamp.IsNullOrWhiteSpace() ? Guid.NewGuid().ToString("N") : user.SecurityStamp));
         }
 
         private string GetPasswordHash(string storedPass)

src/Umbraco.Core/Models/Membership/IUser.cs

@@ -69,6 +69,11 @@ namespace Umbraco.Core.Models.Membership
         /// <summary>
         /// Will hold the media file system relative path of the users custom avatar if they uploaded one
         /// </summary>
-        string Avatar { get; set; }
+        string Avatar { get; set; }
+
+        /// <summary>
+        /// A Json blob stored for recording tour data for a user
+        /// </summary>
+        string TourData { get; set; }
     }
 }

src/Umbraco.Core/Models/Membership/User.cs

@@ -99,6 +99,7 @@ namespace Umbraco.Core.Models.Membership
         private string _name;
         private string _securityStamp;
         private string _avatar;
+        private string _tourData;
         private int _sessionTimeout;
         private int[] _startContentIds;
         private int[] _startMediaIds;
@@ -132,6 +133,7 @@ namespace Umbraco.Core.Models.Membership
 
             public readonly PropertyInfo SecurityStampSelector = ExpressionHelper.GetPropertyInfo<User, string>(x => x.SecurityStamp);
             public readonly PropertyInfo AvatarSelector = ExpressionHelper.GetPropertyInfo<User, string>(x => x.Avatar);
+            public readonly PropertyInfo TourDataSelector = ExpressionHelper.GetPropertyInfo<User, string>(x => x.TourData);
             public readonly PropertyInfo SessionTimeoutSelector = ExpressionHelper.GetPropertyInfo<User, int>(x => x.SessionTimeout);
             public readonly PropertyInfo StartContentIdSelector = ExpressionHelper.GetPropertyInfo<User, int[]>(x => x.StartContentIds);
             public readonly PropertyInfo StartMediaIdSelector = ExpressionHelper.GetPropertyInfo<User, int[]>(x => x.StartMediaIds);
@@ -464,8 +466,18 @@ namespace Umbraco.Core.Models.Membership
         {
             get { return _avatar; }
             set { SetPropertyValueAndDetectChanges(value, ref _avatar, Ps.Value.AvatarSelector); }
-        }        
+        }
 
+        /// <summary>
+        /// A Json blob stored for recording tour data for a user
+        /// </summary>
+        [DataMember]
+        public string TourData
+        {
+            get { return _tourData; }
+            set { SetPropertyValueAndDetectChanges(value, ref _tourData, Ps.Value.TourDataSelector); }
+        }
+
         /// <summary>
         /// Gets or sets the session timeout.
         /// </summary>

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

@@ -27,5 +27,10 @@ namespace Umbraco.Core.Models.Rdbms
         [NullSetting(NullSetting = NullSettings.NotNull)]
         [Length(500)]
         public string OriginIdentity { get; set; }
+
+        [Column("instructionCount")]
+        [NullSetting(NullSetting = NullSettings.NotNull)]
+        [Constraint(Default = 1)]
+        public int InstructionCount { get; set; }
     }
 }

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

@@ -24,4 +24,5 @@ namespace Umbraco.Core.Models.Rdbms
         [ResultColumn]
         public NodeDto NodeDto { get; set; }
     }
+    
 }

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

@@ -32,6 +32,6 @@ namespace Umbraco.Core.Models.Rdbms
         [Column("logComment")]
         [NullSetting(NullSetting = NullSettings.Null)]
         [Length(4000)]
-        public string Comment { get; set; }
+        public string Comment { get; set; }        
     }
 }

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

@@ -0,0 +1,29 @@
+using System;
+using Umbraco.Core.Persistence;
+using Umbraco.Core.Persistence.DatabaseAnnotations;
+
+namespace Umbraco.Core.Models.Rdbms
+{
+    [TableName("cmsMedia")]
+    [PrimaryKey("versionId", autoIncrement = false)]
+    [ExplicitColumns]
+    internal class MediaDto
+    {
+        [Column("nodeId")]
+        [ForeignKey(typeof(ContentDto), Column = "nodeId")]
+        [ForeignKey(typeof(NodeDto))]
+        [Index(IndexTypes.UniqueNonClustered, Name = "IX_cmsMedia", ForColumns = "nodeId, versionId, mediaPath")]
+        public int NodeId { get; set; }        
+
+        [Column("versionId")]
+        [PrimaryKeyColumn(AutoIncrement = false)]
+        public Guid VersionId { get; set; }
+        
+        [Column("mediaPath")]
+        [NullSetting(NullSetting = NullSettings.Null)]
+        public string MediaPath { get; set; }
+
+        [ResultColumn]
+        public ContentVersionDto ContentVersionDto { get; set; }
+    }
+}

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

@@ -27,6 +27,7 @@ namespace Umbraco.Core.Models.Rdbms
         [ForeignKey(typeof(PropertyTypeGroupDto))]
         public int? PropertyTypeGroupId { get; set; }
 
+        [Index(IndexTypes.NonClustered, Name = "IX_cmsPropertyTypeAlias")]
         [Column("Alias")]
         public string Alias { get; set; }
 

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

@@ -15,7 +15,7 @@ namespace Umbraco.Core.Models.Rdbms
         {
             UserGroupDtos = new List<UserGroupDto>();
             UserStartNodeDtos = new HashSet<UserStartNodeDto>();
-        }
+        }
 
         [Column("id")]
         [PrimaryKeyColumn(Name = "PK_user")]
@@ -40,7 +40,7 @@ namespace Umbraco.Core.Models.Rdbms
         [Column("userPassword")]
         [Length(500)]
         public string Password { get; set; }
-
+
         /// <summary>
         /// This will represent a JSON structure of how the password has been created (i.e hash algorithm, iterations)
         /// </summary>
@@ -95,7 +95,7 @@ namespace Umbraco.Core.Models.Rdbms
         [NullSetting(NullSetting = NullSettings.NotNull)]
         [Constraint(Default = SystemMethods.CurrentDateTime)]
         public DateTime UpdateDate { get; set; }
-
+
         /// <summary>
         /// Will hold the media file system relative path of the users custom avatar if they uploaded one
         /// </summary>
@@ -103,6 +103,14 @@ namespace Umbraco.Core.Models.Rdbms
         [NullSetting(NullSetting = NullSettings.Null)]
         [Length(500)]
         public string Avatar { get; set; }
+
+        /// <summary>
+        /// A Json blob stored for recording tour data for a user
+        /// </summary>
+        [Column("tourData")]
+        [NullSetting(NullSetting = NullSettings.Null)]
+        [SpecialDbType(SpecialDbTypes.NTEXT)]
+        public string TourData { get; set; }
 
         [ResultColumn]
         public List<UserGroupDto> UserGroupDtos { get; set; }

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

@@ -0,0 +1,52 @@
+using System;
+using Umbraco.Core.Persistence;
+using Umbraco.Core.Persistence.DatabaseAnnotations;
+
+namespace Umbraco.Core.Models.Rdbms
+{
+    [TableName("umbracoUserLogin")]
+    [PrimaryKey("sessionId", autoIncrement = false)]
+    [ExplicitColumns]
+    internal class UserLoginDto
+    {
+        [Column("sessionId")]
+        [PrimaryKeyColumn(AutoIncrement = false)]
+        public Guid SessionId { get; set; }
+
+        [Column("userId")]
+        [ForeignKey(typeof(UserDto), Name = "FK_umbracoUserLogin_umbracoUser_id")]
+        public int UserId { get; set; }
+
+        /// <summary>
+        /// Tracks when the session is created
+        /// </summary>
+        [Column("loggedInUtc")]
+        [NullSetting(NullSetting = NullSettings.NotNull)]
+        public DateTime LoggedInUtc { get; set; }
+
+        /// <summary>
+        /// Updated every time a user's session is validated
+        /// </summary>
+        /// <remarks>
+        /// This allows us to guess if a session is timed out if a user doesn't actively log out
+        /// and also allows us to trim the data in the table
+        /// </remarks>
+        [Column("lastValidatedUtc")]
+        [NullSetting(NullSetting = NullSettings.NotNull)]
+        public DateTime LastValidatedUtc { get; set; }
+
+        /// <summary>
+        /// Tracks when the session is removed when the user's account is logged out
+        /// </summary>
+        [Column("loggedOutUtc")]
+        [NullSetting(NullSetting = NullSettings.Null)]
+        public DateTime? LoggedOutUtc { get; set; }
+
+        /// <summary>
+        /// Logs the IP address of the session if available
+        /// </summary>
+        [Column("ipAddress")]
+        [NullSetting(NullSetting = NullSettings.Null)]
+        public string IpAddress { get; set; }
+    }
+}

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

@@ -4,7 +4,7 @@ using Umbraco.Core.Persistence.DatabaseAnnotations;
 
 namespace Umbraco.Core.Models.Rdbms
 {
-    [Obsolete("Table no longer exists as of 7.6 - retained only to support migrations from previous versions")]
+    [Obsolete("Table no longer exists as of 7.7 - retained only to support migrations from previous versions")]
     [TableName("umbracoUserType")]
     [PrimaryKey("id")]
     [ExplicitColumns]

src/Umbraco.Core/Models/UmbracoObjectTypes.cs

@@ -192,7 +192,7 @@ namespace Umbraco.Core.Models
         /// </summary>
         [UmbracoObjectType(Constants.ObjectTypes.DocumentBlueprint, typeof(IContent))]
         [FriendlyName("DocumentBlueprint")]
-        [UmbracoUdiType(Constants.UdiEntityType.DocumentBluePrint)]
+        [UmbracoUdiType(Constants.UdiEntityType.DocumentBlueprint)]
         DocumentBlueprint,
         
         /// <summary>

src/Umbraco.Core/Models/UserExtensions.cs

@@ -30,12 +30,11 @@ namespace Umbraco.Core.Models
         /// Tries to lookup the user's gravatar to see if the endpoint can be reached, if so it returns the valid URL
         /// </summary>
         /// <param name="user"></param>
-        /// <param name="userService"></param>
         /// <param name="staticCache"></param>
         /// <returns>
         /// A list of 5 different sized avatar URLs
         /// </returns>
-        internal static string[] GetCurrentUserAvatarUrls(this IUser user, IUserService userService, ICacheProvider staticCache)
+        internal static string[] GetUserAvatarUrls(this IUser user, ICacheProvider staticCache)
         {
             //check if the user has explicitly removed all avatars including a gravatar, this will be possible and the value will be "none"
             if (user.Avatar == "none")

src/Umbraco.Core/ObjectResolution/ManyObjectsResolverBase.cs

@@ -394,7 +394,7 @@ namespace Umbraco.Core.ObjectResolution
         /// WARNING! Do not use this unless you know what you are doing, clear all types registered and instances
         /// created. Typically only used if a resolver is no longer used in an application and memory is to be GC'd
         /// </summary>
-        internal void ResetCollections()
+        internal virtual void ResetCollections()
         {
             using (new WriteLock(_lock))
             {

src/Umbraco.Core/Packaging/PackageExtraction.cs

@@ -2,7 +2,7 @@
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
-using ICSharpCode.SharpZipLib.Zip;
+using System.IO.Compression;
 
 namespace Umbraco.Core.Packaging
 {
@@ -14,17 +14,17 @@ namespace Umbraco.Core.Packaging
             bool fileFound = false;
             string foundDir = null;
 
-            ReadZipfileEntries(packageFilePath, (entry, stream) =>
+            ReadZipfileEntries(packageFilePath, entry =>
             {
                 string fileName = Path.GetFileName(entry.Name);
 
-                if (string.IsNullOrEmpty(fileName) == false &&
-                    fileName.Equals(fileToRead, StringComparison.CurrentCultureIgnoreCase))
+                if (string.IsNullOrEmpty(fileName) == false && fileName.Equals(fileToRead, StringComparison.CurrentCultureIgnoreCase))
                 {
 
                     foundDir = entry.Name.Substring(0, entry.Name.Length - fileName.Length);
                     fileFound = true;
-                    using (var reader = new StreamReader(stream))
+                    using (var entryStream = entry.Open())
+                    using (var reader = new StreamReader(entryStream))
                     {
                         retVal = reader.ReadToEnd();
                         return false;
@@ -77,7 +77,7 @@ namespace Umbraco.Core.Packaging
             var d = sourceDestination.ToDictionary(k => k.Key.ToLower(), v => v.Value);
 
 
-            ReadZipfileEntries(packageFilePath, (entry, stream) =>
+            ReadZipfileEntries(packageFilePath, entry =>
             {
                 string fileName = (Path.GetFileName(entry.Name) ?? string.Empty).ToLower();
                 if (fileName == string.Empty) { return true; }
@@ -86,8 +86,9 @@ namespace Umbraco.Core.Packaging
                 if (string.IsNullOrEmpty(fileName) == false && d.TryGetValue(fileName, out destination))
                 {
                     using (var streamWriter = File.Open(destination, FileMode.Create))
+                    using (var entryStream = entry.Open())
                     {
-                        stream.CopyTo(streamWriter);
+                        entryStream.CopyTo(streamWriter);
                     }
 
                     d.Remove(fileName);
@@ -106,7 +107,7 @@ namespace Umbraco.Core.Packaging
         {
             var retVal = expectedFiles.ToList();
 
-            ReadZipfileEntries(packageFilePath, (zipEntry, stream) =>
+            ReadZipfileEntries(packageFilePath, zipEntry =>
             {
                 string fileName = Path.GetFileName(zipEntry.Name);
 
@@ -125,7 +126,7 @@ namespace Umbraco.Core.Packaging
             var dictionary = new Dictionary<string, List<string>>();
 
 
-            ReadZipfileEntries(packageFilePath, (entry, stream) =>
+            ReadZipfileEntries(packageFilePath, entry =>
             {
                 string fileName = (Path.GetFileName(entry.Name) ?? string.Empty).ToLower();
 
@@ -148,53 +149,42 @@ namespace Umbraco.Core.Packaging
         {
             CheckPackageExists(packageFilePath);
 
-            var files = new HashSet<string>(filesToGet.Select(f => f.ToLower()));
+            var files = new HashSet<string>(filesToGet.Select(f => f.ToLowerInvariant()));
 
-            using (var fs = File.OpenRead(packageFilePath))
+            using (var fs = File.OpenRead(packageFilePath))
+            using (var zipArchive = new ZipArchive(fs))
             {
-                using (var zipInputStream = new ZipInputStream(fs))
+                foreach (var zipEntry in zipArchive.Entries)
                 {
-                    ZipEntry zipEntry;
-                    while ((zipEntry = zipInputStream.GetNextEntry()) != null)
-                    {
-                        
-                        if (zipEntry.IsDirectory) continue;
+                    if (zipEntry.Name.IsNullOrWhiteSpace() && zipEntry.FullName.EndsWith("/")) continue;
 
-                        if (files.Contains(zipEntry.Name))
+                    if (files.Contains(zipEntry.Name.ToLowerInvariant()))
+                    {
+                        using (var memStream = new MemoryStream())
+                        using (var entryStream = zipEntry.Open())
                         {
-                            using (var memStream = new MemoryStream())
-                            {
-                                zipInputStream.CopyTo(memStream);
-                                yield return memStream.ToArray();
-                                memStream.Close();
-                            }
+                            entryStream.CopyTo(memStream);
+                            memStream.Close();
+                            yield return memStream.ToArray();
                         }
                     }
-
-                    zipInputStream.Close();
                 }
-                fs.Close();
             }
         }
 
-        private void ReadZipfileEntries(string packageFilePath, Func<ZipEntry, ZipInputStream, bool> entryFunc, bool skipsDirectories = true)
+        private void ReadZipfileEntries(string packageFilePath, Func<ZipArchiveEntry, bool> entryFunc, bool skipsDirectories = true)
         {
             CheckPackageExists(packageFilePath);
 
             using (var fs = File.OpenRead(packageFilePath))
+            using (var zipArchive = new ZipArchive(fs))
             {
-                using (var zipInputStream = new ZipInputStream(fs))
+                foreach (var zipEntry in zipArchive.Entries)
                 {
-                    ZipEntry zipEntry;
-                    while ((zipEntry = zipInputStream.GetNextEntry()) != null)
-                    {
-                        if (zipEntry.IsDirectory && skipsDirectories) continue;
-                        if (entryFunc(zipEntry, zipInputStream) == false) break;
-                    }
-
-                    zipInputStream.Close();
+                    if (zipEntry.Name.IsNullOrWhiteSpace() && zipEntry.FullName.EndsWith("/") && skipsDirectories)
+                        continue;
+                    if (entryFunc(zipEntry) == false) break;
                 }
-                fs.Close();
             }
         }
     }

src/Umbraco.Core/Persistence/DefaultDatabaseFactory.cs

@@ -12,7 +12,7 @@ namespace Umbraco.Core.Persistence
 	/// it will create one per context, otherwise it will be a global singleton object which is NOT thread safe
 	/// since we need (at least) a new instance of the database object per thread.
 	/// </remarks>
-	internal class DefaultDatabaseFactory : DisposableObject, IDatabaseFactory2
+	internal class DefaultDatabaseFactory : DisposableObjectSlim, IDatabaseFactory2
 	{
 	    private readonly string _connectionStringName;
 	    private readonly ILogger _logger;

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

@@ -98,18 +98,18 @@ namespace Umbraco.Core.Persistence.Factories
         {
             //NOTE Currently doesn't add Alias (legacy that eventually will go away)
             var documentDto = new DocumentDto
-                                  {
-                                      Newest = true,
-                                      NodeId = entity.Id,
-                                      Published = entity.Published,
-                                      Text = entity.Name,
-                                      UpdateDate = entity.UpdateDate,
-                                      WriterUserId = entity.WriterId,
-                                      VersionId = entity.Version,
-                                      ExpiresDate = null,
-                                      ReleaseDate = null,
-                                      ContentVersionDto = BuildContentVersionDto(entity)
-                                  };
+            {
+                Newest = true,
+                NodeId = entity.Id,
+                Published = entity.Published,
+                Text = entity.Name,
+                UpdateDate = entity.UpdateDate,
+                WriterUserId = entity.WriterId,
+                VersionId = entity.Version,
+                ExpiresDate = null,
+                ReleaseDate = null,
+                ContentVersionDto = BuildContentVersionDto(entity)
+            };
 
             if (entity.Template != null && entity.Template.Id > 0)
                 documentDto.TemplateId = entity.Template.Id;

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

@@ -5,6 +5,7 @@ using Umbraco.Core.Models.Rdbms;
 
 namespace Umbraco.Core.Persistence.Factories
 {
+    
     internal class MacroFactory 
     {
         public IMacro BuildEntity(MacroDto dto)

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

@@ -1,5 +1,6 @@
 using System;
 using System.Globalization;
+using System.Text.RegularExpressions;
 using Umbraco.Core.Models;
 using Umbraco.Core.Models.Rdbms;
 
@@ -9,20 +10,17 @@ namespace Umbraco.Core.Persistence.Factories
     {
         private readonly IMediaType _contentType;
         private readonly Guid _nodeObjectTypeId;
-        private readonly int _id;
         private int _primaryKey;
 
-        public MediaFactory(IMediaType contentType, Guid nodeObjectTypeId, int id)
+        public MediaFactory(IMediaType contentType, Guid nodeObjectTypeId)
         {
             _contentType = contentType;
             _nodeObjectTypeId = nodeObjectTypeId;
-            _id = id;
         }
 
-        public MediaFactory(Guid nodeObjectTypeId, int id)
+        public MediaFactory(Guid nodeObjectTypeId)
         {
             _nodeObjectTypeId = nodeObjectTypeId;
-            _id = id;
         }
 
         #region Implementation of IEntityFactory<IMedia,ContentVersionDto>
@@ -64,15 +62,27 @@ namespace Umbraco.Core.Persistence.Factories
             return BuildEntity(dto, _contentType);
         }
 
-        public ContentVersionDto BuildDto(IMedia entity)
+        public MediaDto BuildDto(IMedia entity)
         {
-            var dto = new ContentVersionDto
-                                        {
-                                            NodeId = entity.Id,
-                                            VersionDate = entity.UpdateDate,
-                                            VersionId = entity.Version,
-                                            ContentDto = BuildContentDto(entity)
-                                        };
+            var versionDto = new ContentVersionDto
+            {
+                NodeId = entity.Id,
+                VersionDate = entity.UpdateDate,
+                VersionId = entity.Version,
+                ContentDto = BuildContentDto(entity)
+            };
+
+            //Extract the media path for storage
+            string mediaPath;
+            TryMatch(entity.GetValue<string>("umbracoFile"), out mediaPath);
+
+            var dto = new MediaDto()
+            {
+                NodeId = entity.Id,
+                ContentVersionDto = versionDto,
+                MediaPath = mediaPath,
+                VersionId = entity.Version
+            };
             return dto;
         }
 
@@ -119,5 +129,30 @@ namespace Umbraco.Core.Persistence.Factories
 
             return nodeDto;
         }
+
+        private static readonly Regex MediaPathPattern = new Regex(@"(/media/.+?)(?:['""]|$)", RegexOptions.Compiled);
+
+        /// <summary>
+        /// Try getting a media path out of the string being stored for media
+        /// </summary>
+        /// <param name="text"></param>
+        /// <param name="mediaPath"></param>
+        /// <returns></returns>
+        internal static bool TryMatch(string text, out string mediaPath)
+        {
+            mediaPath = null;
+
+            if (string.IsNullOrWhiteSpace(text))
+                return false;
+
+            var match = MediaPathPattern.Match(text);
+            if (match.Success == false || match.Groups.Count != 2)
+                return false;
+
+            
+            var url = match.Groups[1].Value;
+            mediaPath = url;
+            return true;
+        }
     }
 }

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

@@ -36,6 +36,7 @@ namespace Umbraco.Core.Persistence.Factories
                 user.Avatar = dto.Avatar;
                 user.EmailConfirmedDate = dto.EmailConfirmedDate;
                 user.InvitedDate = dto.InvitedDate;
+                user.TourData = dto.TourData;
 
                 //on initial construction we don't want to have dirty properties tracked
                 // http://issues.umbraco.org/issue/U4-1946
@@ -69,7 +70,8 @@ namespace Umbraco.Core.Persistence.Factories
                 UpdateDate = entity.UpdateDate,
                 Avatar = entity.Avatar,
                 EmailConfirmedDate = entity.EmailConfirmedDate,
-                InvitedDate = entity.InvitedDate
+                InvitedDate = entity.InvitedDate,
+                TourData = entity.TourData
             };
 
             foreach (var startNodeId in entity.StartContentIds)

src/Umbraco.Core/Persistence/Mappers/AuditMapper.cs

@@ -0,0 +1,47 @@
+using System.Collections.Concurrent;
+using Umbraco.Core.Models;
+using Umbraco.Core.Models.Rdbms;
+using Umbraco.Core.Persistence.SqlSyntax;
+
+namespace Umbraco.Core.Persistence.Mappers
+{
+    [MapperFor(typeof(AuditItem))]
+    [MapperFor(typeof(IAuditItem))]
+    public sealed class AuditMapper : BaseMapper
+    {
+        private static readonly ConcurrentDictionary<string, DtoMapModel> PropertyInfoCacheInstance = new ConcurrentDictionary<string, DtoMapModel>();
+
+        public AuditMapper(ISqlSyntaxProvider sqlSyntax) : base(sqlSyntax)
+        {
+
+        }
+
+        //NOTE: its an internal class but the ctor must be public since we're using Activator.CreateInstance to create it
+        // otherwise that would fail because there is no public constructor.
+        public AuditMapper()
+        {
+            BuildMap();
+        }
+
+        #region Overrides of BaseMapper
+
+        internal override ConcurrentDictionary<string, DtoMapModel> PropertyInfoCache
+        {
+            get { return PropertyInfoCacheInstance; }
+        }
+
+        internal override void BuildMap()
+        {
+            if (PropertyInfoCache.IsEmpty)
+            {
+                CacheMap<AuditItem, LogDto>(src => src.Id, dto => dto.NodeId);
+                CacheMap<AuditItem, LogDto>(src => src.CreateDate, dto => dto.Datestamp);
+                CacheMap<AuditItem, LogDto>(src => src.UserId, dto => dto.UserId);
+                CacheMap<AuditItem, LogDto>(src => src.AuditType, dto => dto.Header);                
+                CacheMap<AuditItem, LogDto>(src => src.Comment, dto => dto.Comment);
+            }
+        }
+
+        #endregion
+    }
+}

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

@@ -43,27 +43,28 @@ namespace Umbraco.Core.Persistence.Migrations.Initial
                                                                               {3, typeof (ContentDto)},
                                                                               {4, typeof (ContentVersionDto)},
                                                                               {5, typeof (DocumentDto)},
+                                                                              {6, typeof (MediaDto)},
                                                                               
-                                                                              {6, typeof (ContentTypeTemplateDto)},
-                                                                              {7, typeof (DataTypeDto)},
-                                                                              {8, typeof (DataTypePreValueDto)},
-                                                                              {9, typeof (DictionaryDto)},
-                                                                              {10, typeof (LanguageDto)},
-                                                                              {11, typeof (LanguageTextDto)},
-                                                                              {12, typeof (DomainDto)},
-                                                                              {13, typeof (LogDto)},
-                                                                              {14, typeof (MacroDto)},
-                                                                              {15, typeof (MacroPropertyDto)},
-                                                                              {16, typeof (MemberTypeDto)},
-                                                                              {17, typeof (MemberDto)},
-                                                                              {18, typeof (Member2MemberGroupDto)},
-                                                                              {19, typeof (ContentXmlDto)},
-                                                                              {20, typeof (PreviewXmlDto)},
-                                                                              {21, typeof (PropertyTypeGroupDto)},
-                                                                              {22, typeof (PropertyTypeDto)},
-                                                                              {23, typeof (PropertyDataDto)},
-                                                                              {24, typeof (RelationTypeDto)},
-                                                                              {25, typeof (RelationDto)},
+                                                                              {7, typeof (ContentTypeTemplateDto)},
+                                                                              {8, typeof (DataTypeDto)},
+                                                                              {9, typeof (DataTypePreValueDto)},
+                                                                              {10, typeof (DictionaryDto)},
+                                                                              {11, typeof (LanguageDto)},
+                                                                              {12, typeof (LanguageTextDto)},
+                                                                              {13, typeof (DomainDto)},
+                                                                              {14, typeof (LogDto)},
+                                                                              {15, typeof (MacroDto)},
+                                                                              {16, typeof (MacroPropertyDto)},
+                                                                              {17, typeof (MemberTypeDto)},
+                                                                              {18, typeof (MemberDto)},
+                                                                              {19, typeof (Member2MemberGroupDto)},
+                                                                              {20, typeof (ContentXmlDto)},
+                                                                              {21, typeof (PreviewXmlDto)},
+                                                                              {22, typeof (PropertyTypeGroupDto)},
+                                                                              {23, typeof (PropertyTypeDto)},
+                                                                              {24, typeof (PropertyDataDto)},
+                                                                              {25, typeof (RelationTypeDto)},
+                                                                              {26, typeof (RelationDto)},
                                                                               
                                                                               {28, typeof (TagDto)},
                                                                               {29, typeof (TagRelationshipDto)},
@@ -91,6 +92,7 @@ namespace Umbraco.Core.Persistence.Migrations.Initial
                                                                               {52, typeof (UserGroup2NodePermissionDto) },
                                                                               {53, typeof (UserGroup2AppDto) },
                                                                               {54, typeof (UserStartNodeDto) },
+                                                                              {55, typeof (UserLoginDto)}
                                                                           };
         #endregion
         

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

@@ -148,6 +148,12 @@ namespace Umbraco.Core.Persistence.Migrations.Initial
                 return new Version(7, 6, 0);
             }
 
+            //if the error is for cmsMedia it must be the previous version to 7.8 since that is when it is added
+            if (Errors.Any(x => x.Item1.Equals("Table") && (x.Item2.InvariantEquals("cmsMedia"))))
+            {
+                return new Version(7, 7, 0);
+            }
+
             return UmbracoVersion.Current;
         }
 

src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSevenEightZero/AddCmsMediaTable.cs

@@ -0,0 +1,101 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using Umbraco.Core.Logging;
+using Umbraco.Core.Models.Rdbms;
+using Umbraco.Core.Persistence.Factories;
+using Umbraco.Core.Persistence.SqlSyntax;
+
+namespace Umbraco.Core.Persistence.Migrations.Upgrades.TargetVersionSevenEightZero
+{
+    [Migration("7.8.0", 1, Constants.System.UmbracoMigrationName)]
+    public class AddCmsMediaTable : MigrationBase
+    {
+        public AddCmsMediaTable(ISqlSyntaxProvider sqlSyntax, ILogger logger) : base(sqlSyntax, logger)
+        {
+        }
+
+        public override void Up()
+        {
+            var tables = SqlSyntax.GetTablesInSchema(Context.Database).ToArray();
+
+            if (tables.InvariantContains("cmsMedia") == false)
+            {
+                Create.Table<MediaDto>();
+
+                MigrateMediaPaths();                
+            }
+        }
+
+        private void MigrateMediaPaths()
+        {
+            Execute.Code(database =>
+            {
+                //Due to how much data there can be and that this query will result in executing an Index Scan on the cmsPropertyData PK
+                //which will literally iterate over every row in there (assume there's 1,000,000 and you can see why this will perform
+                //horribly) ultimately we need to fix this: http://issues.umbraco.org/issue/U4-10286
+                //so in the meantime I've found an ugly query to work around this Index Scan issue which is to use a sub-query of Ids. 
+                //Doing this results in the same Index Scan taking place but it only visits the explicit rows that are provided, not every row
+                //in the cmsPropertyData table. This results in a tremendously faster query when there is tons of data.
+
+                //The will return any media property in nvarchar or ntext that is an umbracoFile that is not null.                
+                //This will give us the least amount of data returned to work with.
+                var sql = @"SELECT cmsPropertyData.dataNvarchar, cmsPropertyData.dataNtext, umbracoNode.id, cmsContentVersion.VersionId
+                            FROM cmsPropertyData
+                            INNER JOIN cmsPropertyType ON cmsPropertyType.id = cmsPropertyData.propertytypeid
+                            INNER JOIN umbracoNode ON umbracoNode.id = cmsPropertyData.contentNodeId
+                            INNER JOIN cmsContentVersion ON cmsContentVersion.ContentId = umbracoNode.id
+                            WHERE cmsPropertyType.Alias = (@alias)
+                                AND umbracoNode.id IN (SELECT umbracoNode.id
+                                    FROM umbracoNode 
+		                            INNER JOIN cmsContent ON cmsContent.nodeId = umbracoNode.id
+		                            INNER JOIN cmsContentType ON cmsContentType.nodeId = cmsContent.contentType
+		                            INNER JOIN cmsPropertyType ON cmsPropertyType.contentTypeId = cmsContentType.nodeId
+		                            WHERE cmsPropertyType.Alias = (@alias) AND umbracoNode.nodeObjectType = (@nodeObjectType))
+                                AND (cmsPropertyData.dataNvarchar IS NOT NULL OR cmsPropertyData.dataNtext IS NOT NULL)";
+
+                var paths = new List<MediaDto>();
+
+                //using QUERY = a db cursor, we won't load this all into memory first, just row by row
+                foreach (var row in database.Query<dynamic>(sql, new {alias = "umbracoFile", nodeObjectType = Constants.ObjectTypes.Media}))
+                {
+                    var id = (int) row.id;
+                    var versionId = (Guid)row.VersionId;
+
+                    string mediaPath = null;
+
+                    //if there's values in dataNvarchar then ensure there's a media path match and extract it
+                    if (row.dataNvarchar != null && MediaFactory.TryMatch((string) row.dataNvarchar, out mediaPath))
+                    {
+                        paths.Add(new MediaDto
+                        {
+                            MediaPath = mediaPath,
+                            NodeId = id,
+                            VersionId = versionId
+                        });
+                    }
+                    //if there's values in dataNtext then ensure there's a media path match and extract it
+                    else if (row.dataNtext != null && MediaFactory.TryMatch((string) row.dataNtext, out mediaPath))
+                    {
+                        paths.Add(new MediaDto
+                        {
+                            MediaPath = mediaPath,
+                            NodeId = id,
+                            VersionId = versionId
+                        });
+                    }
+                }
+
+                //now we need to insert paths for each item
+                database.BulkInsertRecords(paths, SqlSyntax);
+
+                return null;
+            });
+
+        }
+
+        public override void Down()
+        {
+        }
+    }
+}

src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSevenEightZero/AddIndexToPropertyTypeAliasColumn.cs

@@ -0,0 +1,48 @@
+using System.Linq;
+using Umbraco.Core.Logging;
+using Umbraco.Core.Persistence.SqlSyntax;
+
+namespace Umbraco.Core.Persistence.Migrations.Upgrades.TargetVersionSevenEightZero
+{
+    [Migration("7.8.0", 0, Constants.System.UmbracoMigrationName)]
+    public class AddIndexToPropertyTypeAliasColumn : MigrationBase
+    {
+        public AddIndexToPropertyTypeAliasColumn(ISqlSyntaxProvider sqlSyntax, ILogger logger)
+            : base(sqlSyntax, logger)
+        { }
+
+        public override void Up()
+        {
+            Execute.Code(database =>
+            {                
+                var dbIndexes = SqlSyntax.GetDefinedIndexesDefinitions(Context.Database);
+
+                //make sure it doesn't already exist
+                if (dbIndexes.Any(x => x.IndexName.InvariantEquals("IX_cmsPropertyTypeAlias")) == false)
+                {
+                    var localContext = new LocalMigrationContext(Context.CurrentDatabaseProvider, database, SqlSyntax, Logger);
+
+                    //we can apply the index
+                    localContext.Create.Index("IX_cmsPropertyTypeAlias").OnTable("cmsPropertyType")
+                        .OnColumn("Alias")
+                        .Ascending()
+                        .WithOptions()
+                        .NonClustered();
+
+                    return localContext.GetSql();
+                }
+
+                return null;
+
+            });
+
+
+        }
+
+        public override void Down()
+        {
+            Delete.Index("IX_cmsPropertyTypeAlias").OnTable("cmsPropertyType");
+        }
+
+    }
+}

src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSevenEightZero/AddInstructionCountColumn.cs

@@ -0,0 +1,32 @@
+using System.Linq;
+using Umbraco.Core.Logging;
+using Umbraco.Core.Persistence.SqlSyntax;
+
+namespace Umbraco.Core.Persistence.Migrations.Upgrades.TargetVersionSevenEightZero
+{
+    [Migration("7.8.0", 2, Constants.System.UmbracoMigrationName)]
+    public class AddInstructionCountColumn : MigrationBase
+    {
+        public AddInstructionCountColumn(ISqlSyntaxProvider sqlSyntax, ILogger logger)
+            : base(sqlSyntax, logger)
+        {
+        }
+
+        public override void Up()
+        {
+            //Don't exeucte if the column is already there
+            var columns = SqlSyntax.GetColumnsInSchema(Context.Database).ToArray();
+
+            if (columns.Any(x => x.TableName.InvariantEquals("umbracoCacheInstruction") && x.ColumnName.InvariantEquals("instructionCount")) == false)
+                Create.Column("instructionCount")
+                    .OnTable("umbracoCacheInstruction")
+                    .AsInt32()
+                    .WithDefaultValue(1)
+                    .NotNullable();
+        }
+
+        public override void Down()
+        {
+        }
+    }
+}

src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSevenEightZero/AddTourDataUserColumn.cs

@@ -0,0 +1,38 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Umbraco.Core.Logging;
+using Umbraco.Core.Persistence.DatabaseAnnotations;
+using Umbraco.Core.Persistence.SqlSyntax;
+
+namespace Umbraco.Core.Persistence.Migrations.Upgrades.TargetVersionSevenEightZero
+{
+    [Migration("7.8.0", 1, Constants.System.UmbracoMigrationName)]
+    public class AddTourDataUserColumn : MigrationBase
+    {
+        public AddTourDataUserColumn(ISqlSyntaxProvider sqlSyntax, ILogger logger)
+            : base(sqlSyntax, logger)
+        {
+        }
+
+        public override void Up()
+        {
+            //Don't exeucte if the column is already there
+            var columns = SqlSyntax.GetColumnsInSchema(Context.Database).ToArray();
+
+            if (columns.Any(x => x.TableName.InvariantEquals("umbracoUser") && x.ColumnName.InvariantEquals("tourData")) == false)
+            {
+                var textType = SqlSyntax.GetSpecialDbType(SpecialDbTypes.NTEXT);
+                Create.Column("tourData").OnTable("umbracoUser").AsCustom(textType).Nullable();
+            }
+                
+        }
+
+        public override void Down()
+        {
+        }
+    }
+    
+}

src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSevenEightZero/AddUserLoginTable.cs

@@ -0,0 +1,29 @@
+using System.Linq;
+using Umbraco.Core.Logging;
+using Umbraco.Core.Models.Rdbms;
+using Umbraco.Core.Persistence.SqlSyntax;
+
+namespace Umbraco.Core.Persistence.Migrations.Upgrades.TargetVersionSevenEightZero
+{
+    [Migration("7.8.0", 4, Constants.System.UmbracoMigrationName)]
+    public class AddUserLoginTable : MigrationBase
+    {
+        public AddUserLoginTable(ISqlSyntaxProvider sqlSyntax, ILogger logger) : base(sqlSyntax, logger)
+        {
+        }
+
+        public override void Up()
+        {
+            var tables = SqlSyntax.GetTablesInSchema(Context.Database).ToArray();
+
+            if (tables.InvariantContains("umbracoUserLogin") == false)
+            {
+                Create.Table<UserLoginDto>();
+            }
+        }
+        
+        public override void Down()
+        {
+        }
+    }
+}

src/Umbraco.Core/Persistence/PetaPoco.cs

@@ -402,7 +402,7 @@ namespace Umbraco.Core.Persistence
         }
 
         // Helper to handle named parameters from object properties
-		static Regex rxParams = new Regex(@"(?<!@)@\w+", RegexOptions.Compiled);
+		static readonly Regex rxParams = new Regex(@"(?<!@)@\w+", RegexOptions.Compiled);
 		public static string ProcessParams(string _sql, object[] args_src, List<object> args_dest)
 		{
 			return rxParams.Replace(_sql, m =>
@@ -545,7 +545,7 @@ namespace Umbraco.Core.Persistence
 		}
 
 		// Create a command
-		static Regex rxParamsPrefix = new Regex(@"(?<!@)@\w+", RegexOptions.Compiled);
+		static readonly Regex rxParamsPrefix = new Regex(@"(?<!@)@\w+", RegexOptions.Compiled);
 		public IDbCommand CreateCommand(IDbConnection connection, string sql, params object[] args)
 		{
 			// Perform named argument replacements
@@ -666,8 +666,8 @@ namespace Umbraco.Core.Persistence
 			return ExecuteScalar<T>(sql.SQL, sql.Arguments);
 		}
 
-		Regex rxSelect = new Regex(@"\A\s*(SELECT|EXECUTE|CALL)\s", RegexOptions.Compiled | RegexOptions.Singleline | RegexOptions.IgnoreCase | RegexOptions.Multiline);
-		Regex rxFrom = new Regex(@"\A\s*FROM\s", RegexOptions.Compiled | RegexOptions.Singleline | RegexOptions.IgnoreCase | RegexOptions.Multiline);
+		static readonly Regex rxSelect = new Regex(@"\A\s*(SELECT|EXECUTE|CALL)\s", RegexOptions.Compiled | RegexOptions.Singleline | RegexOptions.IgnoreCase | RegexOptions.Multiline);
+		static readonly Regex rxFrom = new Regex(@"\A\s*FROM\s", RegexOptions.Compiled | RegexOptions.Singleline | RegexOptions.IgnoreCase | RegexOptions.Multiline);
 		string AddSelectClause<T>(string sql)
 		{
 			if (sql.StartsWith(";"))
@@ -701,9 +701,9 @@ namespace Umbraco.Core.Persistence
 			return Fetch<T>(sql.SQL, sql.Arguments);
 		}
 
-		static Regex rxColumns = new Regex(@"\A\s*SELECT\s+((?:\((?>\((?<depth>)|\)(?<-depth>)|.?)*(?(depth)(?!))\)|.)*?)(?<!,\s+)\bFROM\b", RegexOptions.IgnoreCase | RegexOptions.Multiline | RegexOptions.Singleline | RegexOptions.Compiled);
-		static Regex rxOrderBy = new Regex(@"\bORDER\s+BY\s+(?:\((?>\((?<depth>)|\)(?<-depth>)|.?)*(?(depth)(?!))\)|[\w\(\)\.])+(?:\s+(?:ASC|DESC))?(?:\s*,\s*(?:\((?>\((?<depth>)|\)(?<-depth>)|.?)*(?(depth)(?!))\)|[\w\(\)\.])+(?:\s+(?:ASC|DESC))?)*", RegexOptions.IgnoreCase | RegexOptions.Multiline | RegexOptions.Singleline | RegexOptions.Compiled);
-        static Regex rxDistinct = new Regex(@"\ADISTINCT\s", RegexOptions.IgnoreCase | RegexOptions.Multiline | RegexOptions.Singleline | RegexOptions.Compiled);
+		static readonly Regex rxColumns = new Regex(@"\A\s*SELECT\s+((?:\((?>\((?<depth>)|\)(?<-depth>)|.?)*(?(depth)(?!))\)|.)*?)(?<!,\s+)\bFROM\b", RegexOptions.IgnoreCase | RegexOptions.Multiline | RegexOptions.Singleline | RegexOptions.Compiled);
+		static readonly Regex rxOrderBy = new Regex(@"\bORDER\s+BY\s+(?:\((?>\((?<depth>)|\)(?<-depth>)|.?)*(?(depth)(?!))\)|[\w\(\)\.])+(?:\s+(?:ASC|DESC))?(?:\s*,\s*(?:\((?>\((?<depth>)|\)(?<-depth>)|.?)*(?(depth)(?!))\)|[\w\(\)\.])+(?:\s+(?:ASC|DESC))?)*", RegexOptions.IgnoreCase | RegexOptions.Multiline | RegexOptions.Singleline | RegexOptions.Compiled);
+	    static readonly Regex rxDistinct = new Regex(@"\ADISTINCT\s", RegexOptions.IgnoreCase | RegexOptions.Multiline | RegexOptions.Singleline | RegexOptions.Compiled);
 		public static bool SplitSqlForPaging(string sql, out string sqlCount, out string sqlSelectRemoved, out string sqlOrderBy)
 		{
 			sqlSelectRemoved = null;
@@ -2546,5 +2546,4 @@ namespace Umbraco.Core.Persistence
 			}
 		}
 	}
-
 }

src/Umbraco.Core/Persistence/PetaPocoCommandExtensions.cs

@@ -1,6 +1,5 @@
 using System;
 using System.Data;
-using System.Data.SqlClient;
 using Umbraco.Core.Persistence.FaultHandling;
 
 namespace Umbraco.Core.Persistence

src/Umbraco.Core/Persistence/PetaPocoExtensions.cs

@@ -1,16 +1,12 @@
 using System;
 using System.Collections.Generic;
 using System.Data;
-using System.Data.Common;
 using System.Data.SqlClient;
 using System.Data.SqlServerCe;
 using System.Linq;
 using System.Text.RegularExpressions;
-using MySql.Data.MySqlClient;
 using StackExchange.Profiling.Data;
 using Umbraco.Core.Logging;
-using Umbraco.Core.Persistence.DatabaseModelDefinitions;
-using Umbraco.Core.Persistence.Querying;
 using Umbraco.Core.Persistence.SqlSyntax;
 
 namespace Umbraco.Core.Persistence

src/Umbraco.Core/Persistence/PocoDataDataReader.cs

@@ -38,8 +38,12 @@ namespace Umbraco.Core.Persistence
 
             _tableDefinition = DefinitionFactory.GetTableDefinition(sqlSyntaxProvider, pd.type);
             if (_tableDefinition == null) throw new InvalidOperationException("No table definition found for type " + pd.type);
-            
-            _readerColumns = pd.Columns.Select(x => x.Value).ToArray();
+
+            //Only return real columns, do not include columns that are result columns
+            _readerColumns = pd.Columns
+                .Where(x => x.Value.ResultColumn == false)
+                .Select(x => x.Value)
+                .ToArray();
             _sqlSyntaxProvider = sqlSyntaxProvider;
             _enumerator = dataSource.GetEnumerator();
             _columnDefinitions = _tableDefinition.Columns.ToArray();

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

@@ -1,29 +1,113 @@
 using System;
 using System.Collections.Generic;
+using System.Linq;
 using Umbraco.Core.Logging;
 using Umbraco.Core.Models;
+using Umbraco.Core.Models.Membership;
 using Umbraco.Core.Models.Rdbms;
+using Umbraco.Core.Persistence.DatabaseModelDefinitions;
 using Umbraco.Core.Persistence.Querying;
 using Umbraco.Core.Persistence.SqlSyntax;
 using Umbraco.Core.Persistence.UnitOfWork;
 
 namespace Umbraco.Core.Persistence.Repositories
 {
-    internal class AuditRepository : PetaPocoRepositoryBase<int, AuditItem>, IAuditRepository
+    internal class AuditRepository : PetaPocoRepositoryBase<int, IAuditItem>, IAuditRepository
     {
         public AuditRepository(IScopeUnitOfWork work, CacheHelper cache, ILogger logger, ISqlSyntaxProvider sqlSyntax)
             : base(work, cache, logger, sqlSyntax)
         {
         }
 
-        protected override void PersistNewItem(AuditItem entity)
+        /// <summary>
+        /// Return the audit items as paged result
+        /// </summary>
+        /// <param name="query">
+        /// The query coming from the service
+        /// </param>
+        /// <param name="pageIndex"></param>
+        /// <param name="pageSize"></param>
+        /// <param name="totalRecords"></param>
+        /// <param name="orderDirection"></param>
+        /// <param name="auditTypeFilter">
+        /// Since we currently do not have enum support with our expression parser, we cannot query on AuditType in the query or the custom filter
+        /// so we need to do that here
+        /// </param>
+        /// <param name="customFilter">
+        /// A user supplied custom filter
+        /// </param>
+        /// <returns></returns>
+        public IEnumerable<IAuditItem> GetPagedResultsByQuery(IQuery<IAuditItem> query, long pageIndex, int pageSize,
+            out long totalRecords, Direction orderDirection,
+            AuditType[] auditTypeFilter,
+            IQuery<IAuditItem> customFilter)
         {
-            throw new NotImplementedException();
+            if (auditTypeFilter == null) auditTypeFilter = new AuditType[0];
+
+            var sql = GetBaseQuery(false);
+
+            if (query == null) query = new Query<IAuditItem>();
+            var translatorIds = new SqlTranslator<IAuditItem>(sql, query);
+            var translatedQuery = translatorIds.Translate();
+
+            var customFilterWheres = customFilter != null ? customFilter.GetWhereClauses().ToArray() : null;
+            var hasCustomFilter = customFilterWheres != null && customFilterWheres.Length > 0;
+            if (hasCustomFilter)
+            {
+                var filterSql = new Sql();
+                var first = true;
+                foreach (var filterClaus in customFilterWheres)
+                {
+                    if (first == false)
+                    {
+                        filterSql.Append(" AND ");
+                    }
+                    filterSql.Append(string.Format("({0})", filterClaus.Item1), filterClaus.Item2);
+                    first = false;
+                }
+
+                translatedQuery = GetFilteredSqlForPagedResults(translatedQuery, filterSql);
+            }
+
+            if (auditTypeFilter.Length > 0)
+            {
+                var filterSql = new Sql();
+                var first = true;
+                foreach (var filterClaus in auditTypeFilter)
+                {
+                    if (first == false || hasCustomFilter)
+                    {
+                        filterSql.Append(" AND ");
+                    }
+                    filterSql.Append("(logHeader = @logHeader)", new {logHeader = filterClaus.ToString() });
+                    first = false;
+                }
+
+                translatedQuery = GetFilteredSqlForPagedResults(translatedQuery, filterSql);
+            }
+
+            if (orderDirection == Direction.Descending)
+                translatedQuery.OrderByDescending("Datestamp");
+            else
+                translatedQuery.OrderBy("Datestamp");            
+
+            // Get page of results and total count
+            var pagedResult = Database.Page<LogDto>(pageIndex + 1, pageSize, translatedQuery);
+            totalRecords = pagedResult.TotalItems;
+
+            var pages = pagedResult.Items.Select(
+                dto => new AuditItem(dto.Id, dto.Comment, Enum<AuditType>.Parse(dto.Header), dto.UserId)).ToArray();
+
+            //Mapping the DateStamp
+            for (int i = 0; i < pages.Length; i++)
+            {
+                pages[i].CreateDate = pagedResult.Items[i].Datestamp;
+            }
+
+            return pages;
         }
 
-        #region Not Implemented - not needed
-
-        protected override void PersistUpdatedItem(AuditItem entity)
+        protected override void PersistUpdatedItem(IAuditItem entity)
         {
             Database.Insert(new LogDto
             {
@@ -35,26 +119,40 @@ namespace Umbraco.Core.Persistence.Repositories
             });
         }
 
-        protected override AuditItem PerformGet(int id)
-        {
-            throw new NotImplementedException();
-        }
-
-        protected override IEnumerable<AuditItem> PerformGetAll(params int[] ids)
-        {
-            throw new NotImplementedException();
-        }
-
-        protected override IEnumerable<AuditItem> PerformGetByQuery(IQuery<AuditItem> query)
-        {
-            throw new NotImplementedException();
-        }
-
         protected override Sql GetBaseQuery(bool isCount)
+        {
+            var sql = new Sql()
+                .Select(isCount ? "COUNT(*)" : "umbracoLog.id, umbracoLog.userId, umbracoLog.NodeId, umbracoLog.Datestamp, umbracoLog.logHeader, umbracoLog.logComment, umbracoUser.userName, umbracoUser.avatar as userAvatar")
+                .From<LogDto>(SqlSyntax);
+            if (isCount == false)
+            {
+                sql = sql.LeftJoin<UserDto>(SqlSyntax).On<UserDto, LogDto>(SqlSyntax, dto => dto.Id, dto => dto.UserId);
+            }
+            return sql;
+        }
+
+        #region Not Implemented - not needed currently
+
+        protected override void PersistNewItem(IAuditItem entity)
         {
             throw new NotImplementedException();
         }
 
+        protected override IAuditItem PerformGet(int id)
+        {
+            throw new NotImplementedException();
+        }
+
+        protected override IEnumerable<IAuditItem> PerformGetAll(params int[] ids)
+        {
+            throw new NotImplementedException();
+        }
+
+        protected override IEnumerable<IAuditItem> PerformGetByQuery(IQuery<IAuditItem> query)
+        {
+            throw new NotImplementedException();
+        }        
+
         protected override string GetBaseWhereClause()
         {
             throw new NotImplementedException();
@@ -71,6 +169,33 @@ namespace Umbraco.Core.Persistence.Repositories
         }
         #endregion
 
+        private Sql GetFilteredSqlForPagedResults(Sql sql, Sql filterSql)
+        {
+            Sql filteredSql;
 
+            // Apply filter
+            if (filterSql != null)
+            {
+                var sqlFilter = " WHERE " + filterSql.SQL.TrimStart("AND ");
+
+                //NOTE: this is certainly strange - NPoco handles this much better but we need to re-create the sql
+                // instance a couple of times to get the parameter order correct, for some reason the first
+                // time the arguments don't show up correctly but the SQL argument parameter names are actually updated
+                // accordingly - so we re-create it again. In v8 we don't need to do this and it's already taken care of.
+
+                filteredSql = new Sql(sql.SQL, sql.Arguments);
+                var args = filteredSql.Arguments.Concat(filterSql.Arguments).ToArray();
+                filteredSql = new Sql(
+                    string.Format("{0} {1}", filteredSql.SQL, sqlFilter),
+                    args);
+                filteredSql = new Sql(filteredSql.SQL, args);
+            }
+            else
+            {
+                //copy to var so that the original isn't changed
+                filteredSql = new Sql(sql.SQL, sql.Arguments);
+            }
+            return filteredSql;
+        }
     }
 }

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

@@ -901,7 +901,7 @@ order by umbracoNode.{2}, umbracoNode.parentID, umbracoNode.sortOrder",
         public void AddOrUpdatePermissions(ContentPermissionSet permission)
         {
             _permissionRepository.AddOrUpdate(permission);
-        }
+        }
 
         /// <summary>
         /// Used to remove the content xml for a content item
@@ -1075,8 +1075,8 @@ order by umbracoNode.{2}, umbracoNode.parentID, umbracoNode.sortOrder",
             }
             #endregion
         }
-        #endregion
-
+        #endregion
+
         protected override string GetDatabaseFieldNameForOrderBy(string orderBy)
         {
             //Some custom ones

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

@@ -18,7 +18,7 @@ namespace Umbraco.Core.Persistence.Repositories
     /// <remarks>
     /// This is limited to objects that are based in the umbracoNode-table.
     /// </remarks>
-    internal class EntityRepository : DisposableObject, IEntityRepository
+    internal class EntityRepository : DisposableObjectSlim, IEntityRepository
     {
         private readonly IDatabaseUnitOfWork _work;
 

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

@@ -9,7 +9,7 @@ using Umbraco.Core.Persistence.UnitOfWork;
 
 namespace Umbraco.Core.Persistence.Repositories
 {
-    internal abstract class FileRepository<TId, TEntity> : DisposableObject, IUnitOfWorkRepository, IRepository<TId, TEntity> 
+    internal abstract class FileRepository<TId, TEntity> : DisposableObjectSlim, IUnitOfWorkRepository, IRepository<TId, TEntity> 
         where TEntity : IFile
     {
         private IUnitOfWork _work;

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

@@ -1,11 +1,37 @@
 using System.Collections;
+using System.Collections.Generic;
 using Umbraco.Core.Auditing;
 using Umbraco.Core.Models;
+using Umbraco.Core.Persistence.DatabaseModelDefinitions;
+using Umbraco.Core.Persistence.Querying;
 
 namespace Umbraco.Core.Persistence.Repositories
 {
-    public interface IAuditRepository : IRepository<int, AuditItem>
+    public interface IAuditRepository : IRepository<int, IAuditItem>
     {
-        
+        /// <summary>
+        /// Return the audit items as paged result
+        /// </summary>
+        /// <param name="query">
+        /// The query coming from the service
+        /// </param>
+        /// <param name="pageIndex"></param>
+        /// <param name="pageSize"></param>
+        /// <param name="totalRecords"></param>
+        /// <param name="orderDirection"></param>
+        /// <param name="auditTypeFilter">
+        /// Since we currently do not have enum support with our expression parser, we cannot query on AuditType in the query or the custom filter
+        /// so we need to do that here
+        /// </param>
+        /// <param name="customFilter">
+        /// A user supplied custom filter
+        /// </param>
+        /// <returns></returns>
+        IEnumerable<IAuditItem> GetPagedResultsByQuery(
+            IQuery<IAuditItem> query,
+            long pageIndex, int pageSize, out long totalRecords, 
+            Direction orderDirection,
+            AuditType[] auditTypeFilter,
+            IQuery<IAuditItem> customFilter);
     }
 }

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

@@ -9,6 +9,8 @@ namespace Umbraco.Core.Persistence.Repositories
 {
     public interface IMediaRepository : IRepositoryVersionable<int, IMedia>, IRecycleBinRepository<IMedia>, IReadRepository<Guid, IMedia>, IDeleteMediaFilesRepository
     {
+        IMedia GetMediaByPath(string mediaPath);
+
         /// <summary>
         /// Used to add/update published xml for the media item
         /// </summary>

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

@@ -91,7 +91,12 @@ namespace Umbraco.Core.Persistence.Repositories
 
         IProfile GetProfile(string username);
         IProfile GetProfile(int id);
-        IDictionary<UserState, int> GetUserStates();
-        
+        IDictionary<UserState, int> GetUserStates();
+
+        Guid CreateLoginSession(int userId, string requestingIpAddress, bool cleanStaleSessions = true);
+        bool ValidateLoginSession(int userId, Guid sessionId);
+        int ClearLoginSessions(int userId);
+        int ClearLoginSessions(TimeSpan timespan);
+        void ClearLoginSession(Guid sessionId);
     }
 }

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

@@ -2,7 +2,7 @@
 using System.Collections.Generic;
 using System.Globalization;
 using System.Linq;
-using System.Text;
+using System.Text.RegularExpressions;
 using System.Xml.Linq;
 using Umbraco.Core.Configuration.UmbracoSettings;
 using Umbraco.Core.Logging;
@@ -87,7 +87,7 @@ namespace Umbraco.Core.Persistence.Repositories
 
         #region Overrides of PetaPocoRepositoryBase<int,IMedia>
 
-        protected override Sql GetBaseQuery(BaseQueryType queryType)
+        private Sql GetBaseQuery(BaseQueryType queryType, bool includeFilePaths)
         {
             var sql = new Sql();
             sql.Select(queryType == BaseQueryType.Count ? "COUNT(*)" : (queryType == BaseQueryType.Ids ? "cmsContentVersion.contentId" : "*"))
@@ -95,14 +95,26 @@ namespace Umbraco.Core.Persistence.Repositories
                 .InnerJoin<ContentDto>(SqlSyntax)
                 .On<ContentVersionDto, ContentDto>(SqlSyntax, left => left.NodeId, right => right.NodeId)
                 .InnerJoin<NodeDto>(SqlSyntax)
-                .On<ContentDto, NodeDto>(SqlSyntax, left => left.NodeId, right => right.NodeId, SqlSyntax)
-                //TODO: IF we want to enable querying on content type information this will need to be joined
-                //.InnerJoin<ContentTypeDto>(SqlSyntax)
-                //.On<ContentDto, ContentTypeDto>(SqlSyntax, left => left.ContentTypeId, right => right.NodeId, SqlSyntax);
-                .Where<NodeDto>(x => x.NodeObjectType == NodeObjectTypeId, SqlSyntax);
+                .On<ContentDto, NodeDto>(SqlSyntax, left => left.NodeId, right => right.NodeId);
+
+            if (includeFilePaths)
+            {
+                sql.InnerJoin<MediaDto>(SqlSyntax)
+                    .On<MediaDto, ContentVersionDto>(SqlSyntax, left => left.VersionId, right => right.VersionId);
+            }
+            
+            //TODO: IF we want to enable querying on content type information this will need to be joined
+            //.InnerJoin<ContentTypeDto>(SqlSyntax)
+            //.On<ContentDto, ContentTypeDto>(SqlSyntax, left => left.ContentTypeId, right => right.NodeId, SqlSyntax);
+            sql.Where<NodeDto>(x => x.NodeObjectType == NodeObjectTypeId, SqlSyntax);
             return sql;
         }
 
+        protected override Sql GetBaseQuery(BaseQueryType queryType)
+        {
+            return GetBaseQuery(queryType, false);
+        }
+
         protected override Sql GetBaseQuery(bool isCount)
         {
             return GetBaseQuery(isCount ? BaseQueryType.Count : BaseQueryType.FullSingle);
@@ -128,6 +140,7 @@ namespace Umbraco.Core.Persistence.Repositories
                                "DELETE FROM cmsDocument WHERE nodeId = @Id",
                                "DELETE FROM cmsPropertyData WHERE contentNodeId = @Id",
                                "DELETE FROM cmsPreviewXml WHERE nodeId = @Id",
+                               "DELETE FROM cmsMedia WHERE nodeId = @Id",
                                "DELETE FROM cmsContentVersion WHERE ContentId = @Id",
                                "DELETE FROM cmsContentXml WHERE nodeId = @Id",
                                "DELETE FROM cmsContent WHERE nodeId = @Id",
@@ -367,7 +380,7 @@ namespace Umbraco.Core.Persistence.Repositories
             //Ensure that strings don't contain characters that are invalid in XML
             entity.SanitizeEntityPropertiesForXmlStorage();
 
-            var factory = new MediaFactory(NodeObjectTypeId, entity.Id);
+            var factory = new MediaFactory(NodeObjectTypeId);
             var dto = factory.BuildDto(entity);
 
             //NOTE Should the logic below have some kind of fallback for empty parent ids ?
@@ -380,7 +393,7 @@ namespace Umbraco.Core.Persistence.Repositories
             var sortOrder = maxSortOrder + 1;
 
             //Create the (base) node data - umbracoNode
-            var nodeDto = dto.ContentDto.NodeDto;
+            var nodeDto = dto.ContentVersionDto.ContentDto.NodeDto;
             nodeDto.Path = parent.Path;
             nodeDto.Level = short.Parse(level.ToString(CultureInfo.InvariantCulture));
             nodeDto.SortOrder = sortOrder;
@@ -415,15 +428,21 @@ namespace Umbraco.Core.Persistence.Repositories
             entity.Level = level;
 
             //Create the Content specific data - cmsContent
-            var contentDto = dto.ContentDto;
+            var contentDto = dto.ContentVersionDto.ContentDto;
             contentDto.NodeId = nodeDto.NodeId;
             Database.Insert(contentDto);
 
             //Create the first version - cmsContentVersion
             //Assumes a new Version guid and Version date (modified date) has been set
+            var contentVersionDto = dto.ContentVersionDto;
+            contentVersionDto.NodeId = nodeDto.NodeId;
+            Database.Insert(contentVersionDto);
+
+            //Create the Media specific data for this version - cmsMedia
+            //Assumes a new Version guid has been generated
             dto.NodeId = nodeDto.NodeId;
             Database.Insert(dto);
-
+            
             //Create the PropertyData for this version - cmsPropertyData
             var propertyFactory = new PropertyFactory(entity.ContentType.CompositionPropertyTypes.ToArray(), entity.Version, entity.Id);
             var propertyDataDtos = propertyFactory.BuildDto(entity.Properties);
@@ -471,14 +490,14 @@ namespace Umbraco.Core.Persistence.Repositories
                 entity.SortOrder = maxSortOrder + 1;
             }
 
-            var factory = new MediaFactory(NodeObjectTypeId, entity.Id);
+            var factory = new MediaFactory(NodeObjectTypeId);
             //Look up Content entry to get Primary for updating the DTO
-            var contentDto = Database.SingleOrDefault<ContentDto>("WHERE nodeId = @Id", new { Id = entity.Id });
+            var contentDto = Database.First<ContentDto>("WHERE nodeId = @Id", new { Id = entity.Id });
             factory.SetPrimaryKey(contentDto.PrimaryKey);
             var dto = factory.BuildDto(entity);
 
             //Updates the (base) node data - umbracoNode
-            var nodeDto = dto.ContentDto.NodeDto;
+            var nodeDto = dto.ContentVersionDto.ContentDto.NodeDto;
             nodeDto.ValidatePathWithException();
             var o = Database.Update(nodeDto);
 
@@ -486,15 +505,18 @@ namespace Umbraco.Core.Persistence.Repositories
             if (contentDto.ContentTypeId != entity.ContentTypeId)
             {
                 //Create the Content specific data - cmsContent
-                var newContentDto = dto.ContentDto;
+                var newContentDto = dto.ContentVersionDto.ContentDto;
                 Database.Update(newContentDto);
             }
 
             //In order to update the ContentVersion we need to retrieve its primary key id
-            var contentVerDto = Database.SingleOrDefault<ContentVersionDto>("WHERE VersionId = @Version", new { Version = entity.Version });
-            dto.Id = contentVerDto.Id;
+            var contentVerDto = Database.First<ContentVersionDto>("WHERE VersionId = @Version", new { Version = entity.Version });
+            dto.ContentVersionDto.Id = contentVerDto.Id;
             //Updates the current version - cmsContentVersion
             //Assumes a Version guid exists and Version date (modified date) has been set/updated
+            Database.Update(dto.ContentVersionDto);
+
+            //now update the media entry
             Database.Update(dto);
 
             //Create the PropertyData for this version - cmsPropertyData
@@ -639,7 +661,39 @@ namespace Umbraco.Core.Persistence.Repositories
             }
             #endregion
         }
-        #endregion
+        #endregion
+
+        /// <summary>
+        /// Gets an <see cref="IMedia"/> object from the path stored in the for the media item.
+        /// </summary>
+        /// <param name="mediaPath">Path of the media item to retrieve (for example: /media/1024/koala_403x328.jpg)</param>
+        /// <returns><see cref="IMedia"/></returns>
+        public IMedia GetMediaByPath(string mediaPath)
+        {
+            var umbracoFileValue = mediaPath;
+
+            const string pattern = ".*[_][0-9]+[x][0-9]+[.].*";
+            var isResized = Regex.IsMatch(mediaPath, pattern);
+
+            // If the image has been resized we strip the "_403x328" of the original "/media/1024/koala_403x328.jpg" url.
+            if (isResized)
+            {
+                var underscoreIndex = mediaPath.LastIndexOf('_');
+                var dotIndex = mediaPath.LastIndexOf('.');
+                umbracoFileValue = string.Concat(mediaPath.Substring(0, underscoreIndex), mediaPath.Substring(dotIndex));
+            }
+
+            var sql = GetBaseQuery(BaseQueryType.FullSingle, true);
+            sql.Where<MediaDto>(mediaDto => mediaDto.MediaPath == umbracoFileValue, SqlSyntax);
+            sql.OrderByDescending<ContentVersionDto>(x => x.VersionDate, SqlSyntax);
+            var dto = Database.Fetch<ContentVersionDto, ContentDto, NodeDto>(SqlSyntax.SelectTop(sql, 1)).FirstOrDefault();
+            if (dto == null)
+                return null;
+
+            var content = CreateMediaFromDto(dto, sql);
+
+            return content;
+        }
 
         /// <summary>
         /// Gets paged media results
@@ -703,8 +757,8 @@ namespace Umbraco.Core.Persistence.Repositories
             if (EnsureUniqueNaming == false)
                 return nodeName;
 
-            var names = Database.Fetch<SimilarNodeName>("SELECT id, text AS name FROM umbracoNode WHERE nodeObjectType=@objectType AND parentId=@parentId",
-                new { objectType = NodeObjectTypeId, parentId });
+            var names = Database.Fetch<SimilarNodeName>("SELECT id, text AS name FROM umbracoNode WHERE nodeObjectType=@objectType AND parentId=@parentId",
+                new { objectType = NodeObjectTypeId, parentId });
 
             return SimilarNodeName.GetUniqueName(names, id, nodeName);
         }

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

@@ -183,17 +183,17 @@ namespace Umbraco.Core.Persistence.Repositories
         }
 
         public IEnumerable<IMemberGroup> GetMemberGroupsForMember(string username)
-        {
-            var sql = new Sql()
+        {
+            var sql = new Sql()
                 .Select("un.*")
                 .From("umbracoNode AS un")
                 .InnerJoin("cmsMember2MemberGroup")
-                .On("un.id = cmsMember2MemberGroup.MemberGroup")
-                .LeftJoin("(SELECT umbracoNode.id, cmsMember.LoginName FROM umbracoNode INNER JOIN cmsMember ON umbracoNode.id = cmsMember.nodeId) AS member")
-                .On("member.id = cmsMember2MemberGroup.Member")
-                .Where("un.nodeObjectType=@objectType", new {objectType = NodeObjectTypeId })
-                .Where("member.LoginName=@loginName", new {loginName = username});
-            
+                .On("cmsMember2MemberGroup.MemberGroup = un.id")
+                .InnerJoin("cmsMember")
+                .On("cmsMember.nodeId = cmsMember2MemberGroup.Member")
+                .Where("un.nodeObjectType=@objectType", new { objectType = NodeObjectTypeId })
+                .Where("cmsMember.LoginName=@loginName", new { loginName = username });
+            
             return Database.Fetch<NodeDto>(sql)
                 .DistinctBy(dto => dto.NodeId)
                 .Select(x => _modelFactory.BuildEntity(x));

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

@@ -1,14 +1,9 @@
 using System;
 using System.Collections.Generic;
-using System.Linq;
-using System.Threading.Tasks;
-using Umbraco.Core.Configuration;
 using Umbraco.Core.Configuration.UmbracoSettings;
-using Umbraco.Core.IO;
 using Umbraco.Core.Logging;
 using Umbraco.Core.Models.EntityBase;
 using Umbraco.Core.Models.Rdbms;
-
 using Umbraco.Core.Persistence.Querying;
 using Umbraco.Core.Persistence.SqlSyntax;
 using Umbraco.Core.Persistence.UnitOfWork;
@@ -53,15 +48,16 @@ namespace Umbraco.Core.Persistence.Repositories
                 @"DELETE FROM umbracoRedirectUrl WHERE umbracoRedirectUrl.id IN(
                     SELECT TB1.id FROM umbracoRedirectUrl as TB1
                     INNER JOIN umbracoNode as TB2 ON TB1.contentKey = TB2.uniqueId
-                    WHERE TB2.trashed = '1' AND TB2.nodeObjectType = @NodeObjectType)",
+                    WHERE TB2.trashed = '1' AND TB2.nodeObjectType = @NodeObjectType)",
                 FormatDeleteStatement("umbracoUserStartNode", "startNode"),
                 FormatUpdateStatement("umbracoUserGroup", "startContentId"),
-                FormatUpdateStatement("umbracoUserGroup", "startMediaId"),
+                FormatUpdateStatement("umbracoUserGroup", "startMediaId"),
                 FormatDeleteStatement("umbracoRelation", "parentId"),
                 FormatDeleteStatement("umbracoRelation", "childId"),
                 FormatDeleteStatement("cmsTagRelationship", "nodeId"),
                 FormatDeleteStatement("umbracoDomains", "domainRootStructureID"),
                 FormatDeleteStatement("cmsDocument", "nodeId"),
+                FormatDeleteStatement("cmsMedia", "nodeId"),
                 FormatDeleteStatement("cmsPropertyData", "contentNodeId"),
                 FormatDeleteStatement("cmsPreviewXml", "nodeId"),
                 FormatDeleteStatement("cmsContentVersion", "ContentId"),

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

@@ -4,14 +4,13 @@ using System.Linq;
 using Umbraco.Core.Cache;
 using Umbraco.Core.Logging;
 using Umbraco.Core.Models.EntityBase;
-
 using Umbraco.Core.Persistence.Querying;
 using Umbraco.Core.Persistence.UnitOfWork;
 using Umbraco.Core.Scoping;
 
 namespace Umbraco.Core.Persistence.Repositories
 {
-    internal abstract class RepositoryBase : DisposableObject
+    internal abstract class RepositoryBase : DisposableObjectSlim
     {
         private readonly IScopeUnitOfWork _work;
         private readonly CacheHelper _globalCache;

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

@@ -20,6 +20,12 @@ namespace Umbraco.Core.Persistence.Repositories
 
                 var name = Name;
 
+				// cater for instances where node has no name.
+				if(string.IsNullOrWhiteSpace(name))
+				{
+					return _numPos;
+ 				}
+
                 if (name[name.Length - 1] != ')')
                     return _numPos = -1;
 
@@ -106,7 +112,7 @@ namespace Umbraco.Core.Persistence.Repositories
                 }
             }
 
-            return uniqueing ? string.Concat(nodeName, " (", uniqueNumber.ToString(), ")") : nodeName;
+            return uniqueing || string.IsNullOrWhiteSpace(nodeName) ? string.Concat(nodeName, " (", uniqueNumber.ToString(), ")") : nodeName;
         }
     }
 }

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

@@ -6,6 +6,7 @@ using System.Linq.Expressions;
 using System.Text;
 using System.Web.Security;
 using Newtonsoft.Json;
+using Umbraco.Core.Configuration;
 using Umbraco.Core.Logging;
 using Umbraco.Core.Models.EntityBase;
 using Umbraco.Core.Models.Membership;
@@ -187,8 +188,8 @@ UNION
 SELECT '5CountOfInvited' AS colName, COUNT(id) AS num FROM umbracoUser WHERE lastLoginDate IS NULL AND userDisabled = 1 AND invitedDate IS NOT NULL
 ORDER BY colName";
 
-            var result = Database.Fetch<dynamic>(sql);
-
+            var result = Database.Fetch<dynamic>(sql);
+
             return new Dictionary<UserState, int>
             {
                 {UserState.All, (int)result[0].num},
@@ -199,6 +200,83 @@ ORDER BY colName";
             };
         }
 
+        public Guid CreateLoginSession(int userId, string requestingIpAddress, bool cleanStaleSessions = true)
+        {
+            //TODO: I know this doesn't follow the normal repository conventions which would require us to crete a UserSessionRepository
+            //and also business logic models for these objects but that's just so overkill for what we are doing
+            //and now that everything is properly in a transaction (Scope) there doesn't seem to be much reason for using that anymore
+            var now = DateTime.UtcNow;
+            var dto = new UserLoginDto
+            {
+                UserId = userId,
+                IpAddress = requestingIpAddress,
+                LoggedInUtc = now,
+                LastValidatedUtc = now,
+                LoggedOutUtc = null,
+                SessionId = Guid.NewGuid()
+            };
+            Database.Insert(dto);
+
+            if (cleanStaleSessions)
+            {
+                ClearLoginSessions(TimeSpan.FromDays(15));
+            }
+
+            return dto.SessionId;
+        }
+
+        public bool ValidateLoginSession(int userId, Guid sessionId)
+        {
+            var found = Database.FirstOrDefault<UserLoginDto>("WHERE sessionId=@sessionId", new {sessionId = sessionId});
+            if (found == null || found.UserId != userId || found.LoggedOutUtc.HasValue)
+                return false;
+
+            //now detect if there's been a timeout
+            if (DateTime.UtcNow - found.LastValidatedUtc > TimeSpan.FromMinutes(GlobalSettings.TimeOutInMinutes))
+            {
+                //timeout detected, update the record
+                ClearLoginSession(sessionId);
+                return false;
+            }
+
+            //update the validate date
+            found.LastValidatedUtc = DateTime.UtcNow;
+            Database.Update(found);
+            return true;
+        }
+
+        public int ClearLoginSessions(int userId)
+        {
+            //TODO: I know this doesn't follow the normal repository conventions which would require us to crete a UserSessionRepository
+            //and also business logic models for these objects but that's just so overkill for what we are doing
+            //and now that everything is properly in a transaction (Scope) there doesn't seem to be much reason for using that anymore
+            var count = Database.ExecuteScalar<int>("SELECT COUNT(*) FROM umbracoUserLogin WHERE userId=@userId", new { userId = userId });
+            Database.Execute("DELETE FROM umbracoUserLogin WHERE userId=@userId", new {userId = userId});
+            return count;
+        }
+
+        public int ClearLoginSessions(TimeSpan timespan)
+        {
+            //TODO: I know this doesn't follow the normal repository conventions which would require us to crete a UserSessionRepository
+            //and also business logic models for these objects but that's just so overkill for what we are doing
+            //and now that everything is properly in a transaction (Scope) there doesn't seem to be much reason for using that anymore
+
+            var fromDate = DateTime.UtcNow - timespan;
+
+            var count = Database.ExecuteScalar<int>("SELECT COUNT(*) FROM umbracoUserLogin WHERE lastValidatedUtc=@fromDate", new { fromDate = fromDate });
+            Database.Execute("DELETE FROM umbracoUserLogin WHERE lastValidatedUtc=@fromDate", new { fromDate = fromDate });
+            return count;
+        }
+
+        public void ClearLoginSession(Guid sessionId)
+        {
+            //TODO: I know this doesn't follow the normal repository conventions which would require us to crete a UserSessionRepository
+            //and also business logic models for these objects but that's just so overkill for what we are doing
+            //and now that everything is properly in a transaction (Scope) there doesn't seem to be much reason for using that anymore
+            Database.Execute("UPDATE umbracoUserLogin SET loggedOutUtc=@now WHERE sessionId=@sessionId",
+                new { now = DateTime.UtcNow, sessionId = sessionId });
+        }
+
         protected override IEnumerable<IUser> PerformGetAll(params int[] ids)
         {
             var sql = GetQueryWithGroups();
@@ -401,7 +479,8 @@ ORDER BY colName";
                 {"updateDate", "UpdateDate"},
                 {"avatar", "Avatar"},
                 {"emailConfirmedDate", "EmailConfirmedDate"},
-                {"invitedDate", "InvitedDate"}
+                {"invitedDate", "InvitedDate"},
+                {"tourData", "TourData"}
             };
 
             //create list of properties that have changed
@@ -834,14 +913,6 @@ ORDER BY colName";
         {
             return dtos.Select(UserFactory.BuildEntity);
         }
-
-        //private IEnumerable<IUserGroup> ConvertFromDtos(IEnumerable<UserGroupDto> dtos)
-        //{
-        //    return dtos.Select(dto =>
-        //    {
-        //        var userGroupFactory = new UserGroupFactory();
-        //        return userGroupFactory.BuildEntity(dto);
-        //    });
-        //}
+        
     }
 }

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

@@ -10,7 +10,7 @@ namespace Umbraco.Core.Persistence.UnitOfWork
 	/// <summary>
 	/// Represents a scoped unit of work.
 	/// </summary>
-	internal class ScopeUnitOfWork : DisposableObject, IScopeUnitOfWork
+	internal class ScopeUnitOfWork : DisposableObjectSlim, IScopeUnitOfWork
     {
         private readonly Queue<Operation> _operations = new Queue<Operation>();
 	    private readonly IsolationLevel _isolationLevel;

src/Umbraco.Core/Properties/AssemblyInfo.cs

@@ -1,10 +1,8 @@
 using System.Reflection;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
-using System.Security;
-using System.Security.Permissions;
 
-// General Information about an assembly is controlled through the following 
+// General Information about an assembly is controlled through the following
 // set of attributes. Change these attribute values to modify the information
 // associated with an assembly.
 [assembly: AssemblyTitle("Umbraco.Core")]
@@ -12,8 +10,8 @@ using System.Security.Permissions;
 [assembly: AssemblyConfiguration("")]
 [assembly: AssemblyProduct("Umbraco CMS")]
 
-// Setting ComVisible to false makes the types in this assembly not visible 
-// to COM components.  If you need to access a type in this assembly from 
+// Setting ComVisible to false makes the types in this assembly not visible
+// to COM components.  If you need to access a type in this assembly from
 // COM, set the ComVisible attribute to true on that type.
 [assembly: ComVisible(false)]
 
@@ -50,6 +48,8 @@ using System.Security.Permissions;
 [assembly: InternalsVisibleTo("Umbraco.Forms.Core.Providers")]
 [assembly: InternalsVisibleTo("Umbraco.Forms.Web")]
 
+[assembly: InternalsVisibleTo("Umbraco.Headless")]
+
 //allow this to be mocked in our unit tests
 [assembly: InternalsVisibleTo("DynamicProxyGenAssembly2")]
 

src/Umbraco.Core/PropertyEditors/PropertyValueEditor.cs

@@ -1,9 +1,9 @@
 using System;
 using System.Collections.Generic;
 using System.Globalization;
-using System.Linq;
 using System.Xml.Linq;
 using Newtonsoft.Json;
+using Newtonsoft.Json.Linq;
 using Umbraco.Core.Logging;
 using Umbraco.Core.Manifest;
 using Umbraco.Core.Models;
@@ -176,6 +176,12 @@ namespace Umbraco.Core.PropertyEditors
         /// <returns></returns>
         internal Attempt<object> TryConvertValueToCrlType(object value)
         {
+            var jv = value as JValue;
+            if (jv != null)
+            {
+                value = value.ToString();
+            }
+
             //this is a custom check to avoid any errors, if it's a string and it's empty just make it null
             var s = value as string;
             if (s != null)
@@ -391,4 +397,4 @@ namespace Umbraco.Core.PropertyEditors
             }
         }
     }
-}
+}

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

@@ -18,6 +18,8 @@ namespace Umbraco.Core.PropertyEditors.ValueConverters
             return Constants.PropertyEditors.MultipleTextstringAlias.Equals(propertyType.PropertyEditorAlias);
         }
 
+        private static readonly string[] NewLineDelimiters = { "\r\n", "\r", "\n" };
+
         public override object ConvertDataToSource(PublishedPropertyType propertyType, object source, bool preview)
         {
             // data is (both in database and xml):
@@ -53,7 +55,7 @@ namespace Umbraco.Core.PropertyEditors.ValueConverters
             // Fall back on normal behaviour
             if (values.Any() == false)
             {
-                return sourceString.Split(new string[] { Environment.NewLine }, StringSplitOptions.None);
+                return sourceString.Split(NewLineDelimiters, StringSplitOptions.None);
             }
 
             return values.ToArray();

src/Umbraco.Core/Publishing/PublishingStrategy.cs

@@ -401,9 +401,10 @@ namespace Umbraco.Core.Publishing
                                   content.Name, content.Id));
             }
 
-            // if newest is published, unpublish
-            if (content.Published)
-                content.ChangePublishedState(PublishedState.Unpublished);
+            // make sure we dirty .Published and always unpublish
+            // the version we have here could be the newest, !Published
+            content.ChangePublishedState(PublishedState.Published);
+            content.ChangePublishedState(PublishedState.Unpublished);
 
             _logger.Info<PublishingStrategy>(
                 string.Format("Content '{0}' with Id '{1}' has been unpublished.",

src/Umbraco.Core/Scoping/NoScope.cs

@@ -20,6 +20,7 @@ namespace Umbraco.Core.Scoping
         public NoScope(ScopeProvider scopeProvider)
         {
             _scopeProvider = scopeProvider;
+            Timestamp = DateTime.Now;
 #if DEBUG_SCOPES
             _scopeProvider.RegisterScope(this);
 #endif
@@ -28,6 +29,8 @@ namespace Umbraco.Core.Scoping
         private readonly Guid _instanceId = Guid.NewGuid();
         public Guid InstanceId { get { return _instanceId; } }
 
+        public DateTime Timestamp { get; }
+
         /// <inheritdoc />
         public bool CallContext { get { return false; } }
 

src/Umbraco.Core/Scoping/Scope.cs

@@ -374,7 +374,7 @@ namespace Umbraco.Core.Scoping
             }
 
             var parent = ParentScope;
-            _scopeProvider.AmbientScope = parent;
+            _scopeProvider.AmbientScope = parent; // might be null = this is how scopes are removed from context objects
 
 #if DEBUG_SCOPES
             _scopeProvider.Disposed(this);

src/Umbraco.Core/Scoping/ScopeContext.cs

@@ -116,5 +116,19 @@ namespace Umbraco.Core.Scoping
             Enlisted[key] = enlistedOfT;
             return enlistedOfT.Item;
         }
+
+        public T GetEnlisted<T>(string key)
+        {
+            var enlistedObjects = _enlisted;
+            if (enlistedObjects == null) return default (T);
+
+            IEnlistedObject enlisted;
+            if (enlistedObjects.TryGetValue(key, out enlisted) == false)
+                return default (T);
+
+            var enlistedAs = enlisted as EnlistedObject<T>;
+            if (enlistedAs == null) throw new InvalidOperationException("An item with the key exists, but with a different type.");
+            return enlistedAs.Item;
+        }
     }
 }

src/Umbraco.Core/Scoping/ScopeProvider.cs

@@ -2,10 +2,12 @@
 using System.Collections;
 using System.Collections.Generic;
 using System.Data;
+using System.Linq;
 using System.Runtime.Remoting.Messaging;
 using System.Text;
 using System.Web;
 using Umbraco.Core.Events;
+using Umbraco.Core.Logging;
 using Umbraco.Core.Persistence;
 #if DEBUG_SCOPES
 using System.Linq;
@@ -66,22 +68,38 @@ namespace Umbraco.Core.Scoping
         // tests, any other things (see https://msdn.microsoft.com/en-us/library/dn458353(v=vs.110).aspx),
         // but we don't want to make all of our objects serializable since they are *not* meant to be
         // used in cross-AppDomain scenario anyways.
+        //
         // in addition, whatever goes into the logical call context is serialized back and forth any
-        // time cross-AppDomain code executes, so if we put an "object" there, we'll can *another*
-        // "object" instance - and so we cannot use a random object as a key.
+        // time cross-AppDomain code executes, so if we put an "object" there, we'll get *another*
+        // "object" instance back - and so we cannot use a random object as a key.
+        //
         // so what we do is: we register a guid in the call context, and we keep a table mapping those
         // guids to the actual objects. the guid serializes back and forth without causing any issue,
         // and we can retrieve the actual objects from the table.
-        // only issue: how are we supposed to clear the table? we can't, really. objects should take
-        // care of de-registering themselves from context.
-        // everything we use does, except the NoScope scope, which just stays there
         //
-        // during tests, NoScope can to into call context... nothing much we can do about it
+        // so far, the only objects that go into this table are scopes (using ScopeItemKey) and
+        // scope contexts (using ContextItemKey).
 
         private static readonly object StaticCallContextObjectsLock = new object();
         private static readonly Dictionary<Guid, object> StaticCallContextObjects
              = new Dictionary<Guid, object>();
 
+        // normal scopes and scope contexts take greate care removing themselves when disposed, so it
+        // is all safe. OTOH the NoScope *CANNOT* remove itself, this is by design, it *WILL* leak and
+        // there is little (nothing) we can do about it - NoScope exists for backward compatibility
+        // reasons and relying on it is greatly discouraged.
+        //
+        // however... we can *try* at protecting the app against memory leaks, by collecting NoScope
+        // instances that are too old. if anything actually *need* to retain a NoScope instance for
+        // a long time, it will break. but that's probably ok. so: the constants below define how
+        // long a NoScope instance can stay in the table before being removed, and how often we should
+        // collect the table - and collecting happens anytime SetCallContextObject is invoked
+
+        private static readonly TimeSpan StaticCallContextNoScopeLifeSpan = TimeSpan.FromMinutes(30);
+        private static readonly TimeSpan StaticCallContextCollectPeriod = TimeSpan.FromMinutes(4);
+        private static DateTime _staticCallContextLastCollect = DateTime.MinValue;
+
+
 #if DEBUG_SCOPES
         public Dictionary<Guid, object> CallContextObjects
         {
@@ -156,6 +174,7 @@ namespace Umbraco.Core.Scoping
                     //Logging.LogHelper.Debug<ScopeProvider>("At:\r\n" + Head(Environment.StackTrace, 24));
 #endif
                     StaticCallContextObjects.Remove(objectKey);
+                    CollectStaticCallContextObjectsLocked();
                 }
             }
             else
@@ -171,11 +190,37 @@ namespace Umbraco.Core.Scoping
                     //Logging.LogHelper.Debug<ScopeProvider>("At:\r\n" + Head(Environment.StackTrace, 24));
 #endif
                     StaticCallContextObjects.Add(objectKey, value);
+                    CollectStaticCallContextObjectsLocked();
                 }
                 CallContext.LogicalSetData(key, objectKey);
             }
         }
 
+        private static void CollectStaticCallContextObjectsLocked()
+        {
+            // is it time to collect?
+            var now = DateTime.Now;
+            if (now - _staticCallContextLastCollect <= StaticCallContextCollectPeriod)
+                return;
+
+            // disable warning: this method is invoked from within a lock
+            // ReSharper disable InconsistentlySynchronizedField
+            var threshold = now.Add(-StaticCallContextNoScopeLifeSpan);
+            var guids = StaticCallContextObjects
+                .Where(x => x.Value is NoScope noScope && noScope.Timestamp < threshold)
+                .Select(x => x.Key)
+                .ToList();
+            if (guids.Count > 0)
+            {
+                LogHelper.Warn<ScopeProvider>($"Collected {guids.Count} NoScope instances from StaticCallContextObjects.");
+                foreach (var guid in guids)
+                    StaticCallContextObjects.Remove(guid);
+            }
+            // ReSharper restore InconsistentlySynchronizedField
+
+            _staticCallContextLastCollect = now;
+        }
+
         // this is for tests exclusively until we have a proper accessor in v8
         internal static Func<IDictionary> HttpContextItemsGetter { get; set; }
 

src/Umbraco.Core/Security/AuthenticationExtensions.cs

@@ -11,12 +11,14 @@ using System.Security.Principal;
 using System.Threading;
 using System.Web;
 using System.Web.Security;
+using Microsoft.AspNet.Identity;
 using AutoMapper;
 using Microsoft.Owin;
 using Newtonsoft.Json;
 using Umbraco.Core.Configuration;
 using Umbraco.Core.Models.Membership;
 using Umbraco.Core.Logging;
+using IUser = Umbraco.Core.Models.Membership.IUser;
 
 namespace Umbraco.Core.Security
 {
@@ -241,8 +243,11 @@ namespace Umbraco.Core.Security
         /// <param name="userdata"></param>
         public static FormsAuthenticationTicket CreateUmbracoAuthTicket(this HttpContextBase http, UserData userdata)
         {
+            //ONLY used by BasePage.doLogin!
+
             if (http == null) throw new ArgumentNullException("http");
-            if (userdata == null) throw new ArgumentNullException("userdata");
+            if (userdata == null) throw new ArgumentNullException("userdata");
+            
             var userDataString = JsonConvert.SerializeObject(userdata);
             return CreateAuthTicketAndCookie(
                 http, 
@@ -254,14 +259,7 @@ namespace Umbraco.Core.Security
                 1440, 
                 UmbracoConfig.For.UmbracoSettings().Security.AuthCookieName,
                 UmbracoConfig.For.UmbracoSettings().Security.AuthCookieDomain);
-        }
-
-        internal static FormsAuthenticationTicket CreateUmbracoAuthTicket(this HttpContext http, UserData userdata)
-        {
-            if (http == null) throw new ArgumentNullException("http");
-            if (userdata == null) throw new ArgumentNullException("userdata");
-            return new HttpContextWrapper(http).CreateUmbracoAuthTicket(userdata);
-        }
+        }        
 
         /// <summary>
         /// returns the number of seconds the user has until their auth session times out
@@ -331,7 +329,23 @@ namespace Umbraco.Core.Security
         /// <param name="http"></param>
         /// <param name="cookieName"></param>
         private static void Logout(this HttpContextBase http, string cookieName)
-        {
+        {
+            //We need to clear the sessionId from the database. This is legacy code to do any logging out and shouldn't really be used at all but in any case
+            //we need to make sure the session is cleared. Due to the legacy nature of this it means we need to use singletons
+            if (http.User != null)
+            {
+                var claimsIdentity = http.User.Identity as ClaimsIdentity;
+                if (claimsIdentity != null)
+                {
+                    var sessionId = claimsIdentity.FindFirstValue(Constants.Security.SessionIdClaimType);
+                    Guid guidSession;
+                    if (sessionId.IsNullOrWhiteSpace() == false && Guid.TryParse(sessionId, out guidSession))
+                    {
+                        ApplicationContext.Current.Services.UserService.ClearLoginSession(guidSession);
+                    }
+                }
+            }
+
             if (http == null) throw new ArgumentNullException("http");
             //clear the preview cookie and external login
             var cookies = new[] { cookieName, Constants.Web.PreviewCookieName, Constants.Security.BackOfficeExternalCookieName };

src/Umbraco.Core/Security/BackOfficeClaimsIdentityFactory.cs

@@ -2,16 +2,29 @@
 using System.Linq;
 using System.Security.Claims;
 using System.Threading.Tasks;
+using System.Web;
 using Microsoft.AspNet.Identity;
 using Umbraco.Core.Models.Identity;
+using Umbraco.Core.Services;
 
 namespace Umbraco.Core.Security
 {
     public class BackOfficeClaimsIdentityFactory<T> : ClaimsIdentityFactory<T, int>
         where T: BackOfficeIdentityUser
     {
+        private readonly ApplicationContext _appCtx;
+
+        [Obsolete("Use the overload specifying all dependencies instead")]
         public BackOfficeClaimsIdentityFactory()
+            :this(ApplicationContext.Current)
         {
+        }
+
+        public BackOfficeClaimsIdentityFactory(ApplicationContext appCtx)
+        {
+            if (appCtx == null) throw new ArgumentNullException("appCtx");
+            _appCtx = appCtx;
+
             SecurityStampClaimType = Constants.Security.SessionIdClaimType;
             UserNameClaimType = ClaimTypes.Name;
         }
@@ -24,9 +37,9 @@ namespace Umbraco.Core.Security
         public override async Task<ClaimsIdentity> CreateAsync(UserManager<T, int> manager, T user, string authenticationType)
         {
             var baseIdentity = await base.CreateAsync(manager, user, authenticationType);
-
+            
             var umbracoIdentity = new UmbracoBackOfficeIdentity(baseIdentity,
-                //set a new session id
+                //NOTE - there is no session id assigned here, this is just creating the identity, a session id will be generated when the cookie is written
                 new UserData
                 {
                     Id = user.Id,
@@ -37,15 +50,22 @@ namespace Umbraco.Core.Security
                     Roles = user.Roles.Select(x => x.RoleId).ToArray(),
                     StartContentNodes = user.CalculatedContentStartNodeIds,
                     StartMediaNodes = user.CalculatedMediaStartNodeIds,
-                    SessionId = user.SecurityStamp
+                    SecurityStamp = user.SecurityStamp
                 });
 
             return umbracoIdentity;
-        }
+        }        
     }
 
     public class BackOfficeClaimsIdentityFactory : BackOfficeClaimsIdentityFactory<BackOfficeIdentityUser>
-    {       
+    {
+        [Obsolete("Use the overload specifying all dependencies instead")]
+        public BackOfficeClaimsIdentityFactory()
+        {
+        }
 
+        public BackOfficeClaimsIdentityFactory(ApplicationContext appCtx) : base(appCtx)
+        {
+        }
     }
 }

src/Umbraco.Core/Security/BackOfficeCookieAuthenticationProvider.cs

@@ -1,21 +1,83 @@
 using System;
+using System.Collections.Concurrent;
+using System.ComponentModel;
 using System.Globalization;
 using System.Net.Http.Headers;
+using System.Security.Claims;
 using System.Threading;
 using System.Threading.Tasks;
+using Microsoft.AspNet.Identity;
 using Microsoft.Owin;
 using Microsoft.Owin.Security.Cookies;
+using Semver;
 using Umbraco.Core.Configuration;
+using Umbraco.Core.Models.Identity;
 
 namespace Umbraco.Core.Security
 {
     public class BackOfficeCookieAuthenticationProvider : CookieAuthenticationProvider
     {
+        private readonly ApplicationContext _appCtx;
+
+        [Obsolete("Use the ctor specifying all dependencies")]
+        [EditorBrowsable(EditorBrowsableState.Never)]
+        public BackOfficeCookieAuthenticationProvider()
+            : this(ApplicationContext.Current)
+        {
+        }
+
+        public BackOfficeCookieAuthenticationProvider(ApplicationContext appCtx)
+        {
+            if (appCtx == null) throw new ArgumentNullException("appCtx");
+            _appCtx = appCtx;
+        }
+
+        private static readonly SemVersion MinUmbracoVersionSupportingLoginSessions = new SemVersion(7, 8);
+
+        public override void ResponseSignIn(CookieResponseSignInContext context)
+        {
+            var backOfficeIdentity = context.Identity as UmbracoBackOfficeIdentity;
+            if (backOfficeIdentity != null)
+            {
+                //generate a session id and assign it
+                //create a session token - if we are configured and not in an upgrade state then use the db, otherwise just generate one
+
+                //NOTE - special check because when we are upgrading to 7.8 we cannot create a session since the db isn't ready and we'll get exceptions
+                var canAcquireSession = _appCtx.IsUpgrading == false || _appCtx.CurrentVersion() >= MinUmbracoVersionSupportingLoginSessions;
+
+                var session = canAcquireSession
+                    ? _appCtx.Services.UserService.CreateLoginSession((int)backOfficeIdentity.Id, context.OwinContext.GetCurrentRequestIpAddress())
+                    : Guid.NewGuid();
+
+                backOfficeIdentity.UserData.SessionId = session.ToString();
+            }            
+
+            base.ResponseSignIn(context);
+        }
+
         public override void ResponseSignOut(CookieResponseSignOutContext context)
         {
+            //Clear the user's session on sign out
+            if (context != null && context.OwinContext != null && context.OwinContext.Authentication != null
+                && context.OwinContext.Authentication.User != null && context.OwinContext.Authentication.User.Identity != null)
+            {
+                var claimsIdentity = context.OwinContext.Authentication.User.Identity as ClaimsIdentity;
+                var sessionId = claimsIdentity.FindFirstValue(Constants.Security.SessionIdClaimType);
+                Guid guidSession;
+                if (sessionId.IsNullOrWhiteSpace() == false && Guid.TryParse(sessionId, out guidSession))
+                {
+                    _appCtx.Services.UserService.ClearLoginSession(guidSession);
+                }
+            }
+
             base.ResponseSignOut(context);
 
             //Make sure the definitely all of these cookies are cleared when signing out with cookies
+            context.Response.Cookies.Append(SessionIdValidator.CookieName, "", new CookieOptions
+            {
+                Expires = DateTime.Now.AddYears(-1),
+                Path = "/"
+            });
             context.Response.Cookies.Append(UmbracoConfig.For.UmbracoSettings().Security.AuthCookieName, "", new CookieOptions
             {
                 Expires = DateTime.Now.AddYears(-1),
@@ -34,21 +96,45 @@ namespace Umbraco.Core.Security
         }
 
         /// <summary>
-        /// Ensures that the culture is set correctly for the current back office user
+        /// Ensures that the culture is set correctly for the current back office user and that the user's session token is valid
         /// </summary>
         /// <param name="context"/>
         /// <returns/>
-        public override Task ValidateIdentity(CookieValidateIdentityContext context)
+        public override async Task ValidateIdentity(CookieValidateIdentityContext context)
+        {
+            EnsureCulture(context);
+
+            await EnsureValidSessionId(context);
+
+            await base.ValidateIdentity(context);
+        }        
+
+        /// <summary>
+        /// Ensures that the user has a valid session id
+        /// </summary>
+        /// <remarks>
+        /// So that we are not overloading the database this throttles it's check to every minute
+        /// </remarks>
+        protected  virtual async Task EnsureValidSessionId(CookieValidateIdentityContext context)
+        {
+            if (_appCtx.IsConfigured && _appCtx.IsUpgrading == false)
+                await SessionIdValidator.ValidateSessionAsync(TimeSpan.FromMinutes(1), context);
+        }
+
+        private void EnsureCulture(CookieValidateIdentityContext context)
         {
             var umbIdentity = context.Identity as UmbracoBackOfficeIdentity;
             if (umbIdentity != null && umbIdentity.IsAuthenticated)
             {
                 Thread.CurrentThread.CurrentCulture =
                     Thread.CurrentThread.CurrentUICulture =
-                        new CultureInfo(umbIdentity.Culture);
+                        UserCultures.GetOrAdd(umbIdentity.Culture, s => new CultureInfo(s));
             }
-
-            return base.ValidateIdentity(context);
         }
+
+        /// <summary>
+        /// Used so that we aren't creating a new CultureInfo object for every single request
+        /// </summary>
+        private static readonly ConcurrentDictionary<string, CultureInfo> UserCultures = new ConcurrentDictionary<string, CultureInfo>();
     }
 }

src/Umbraco.Core/Security/BackOfficeSignInManager.cs

@@ -223,6 +223,9 @@ namespace Umbraco.Core.Security
                 user.AccessFailedCount = 0;
             await UserManager.UpdateAsync(user);
 
+            //set the current request's principal to the identity just signed in!
+            _request.User = new ClaimsPrincipal(userIdentity);
+
             _logger.WriteCore(TraceEventType.Information, 0,
                 string.Format(
                     "Login attempt succeeded for username {0} from IP address {1}",

src/Umbraco.Core/Security/BackOfficeUserManager.cs

@@ -152,7 +152,6 @@ namespace Umbraco.Core.Security
             //NOTE: This method is mostly here for backwards compat
             base.InitUserManager(manager, membershipProvider, options.DataProtectionProvider, contentSectionConfig);
         }
-       
     }
 
     /// <summary>
@@ -169,7 +168,7 @@ namespace Umbraco.Core.Security
 
         #region What we support do not currently
 
-        //NOTE: Not sure if we really want/need to ever support this 
+        //TODO: We could support this - but a user claims will mostly just be what is in the auth cookie
         public override bool SupportsUserClaim
         {
             get { return false; }
@@ -271,6 +270,22 @@ namespace Umbraco.Core.Security
             //manager.SmsService = new SmsService();            
         }
 
+        /// <summary>
+        /// Used to validate a user's session
+        /// </summary>
+        /// <param name="userId"></param>
+        /// <param name="sessionId"></param>
+        /// <returns></returns>
+        public virtual async Task<bool> ValidateSessionIdAsync(int userId, string sessionId)
+        {
+            var userSessionStore = Store as IUserSessionStore<BackOfficeIdentityUser, int>;
+            //if this is not set, for backwards compat (which would be super rare), we'll just approve it
+            if (userSessionStore == null)
+                return true;
+
+            return await userSessionStore.ValidateSessionIdAsync(userId, sessionId);
+        }
+
         /// <summary>
         /// This will determine which password hasher to use based on what is defined in config
         /// </summary>
@@ -674,4 +689,5 @@ namespace Umbraco.Core.Security
             return httpContext.GetCurrentRequestIpAddress();
         }
     }
+
 }

src/Umbraco.Core/Security/BackOfficeUserStore.cs

@@ -18,7 +18,7 @@ using Task = System.Threading.Tasks.Task;
 
 namespace Umbraco.Core.Security
 {
-    public class BackOfficeUserStore : DisposableObject, 
+    public class BackOfficeUserStore : DisposableObjectSlim, 
         IUserStore<BackOfficeIdentityUser, int>, 
         IUserPasswordStore<BackOfficeIdentityUser, int>, 
         IUserEmailStore<BackOfficeIdentityUser, int>, 
@@ -26,12 +26,13 @@ namespace Umbraco.Core.Security
         IUserRoleStore<BackOfficeIdentityUser, int>,
         IUserSecurityStampStore<BackOfficeIdentityUser, int>,
         IUserLockoutStore<BackOfficeIdentityUser, int>,
-        IUserTwoFactorStore<BackOfficeIdentityUser, int>
+        IUserTwoFactorStore<BackOfficeIdentityUser, int>,
+        IUserSessionStore<BackOfficeIdentityUser, int>
 
-        //TODO: This would require additional columns/tables for now people will need to implement this on their own
-        //IUserPhoneNumberStore<BackOfficeIdentityUser, int>,
-        //TODO: To do this we need to implement IQueryable -  we'll have an IQuerable implementation soon with the UmbracoLinqPadDriver implementation
-        //IQueryableUserStore<BackOfficeIdentityUser, int>
+    //TODO: This would require additional columns/tables for now people will need to implement this on their own
+    //IUserPhoneNumberStore<BackOfficeIdentityUser, int>,
+    //TODO: To do this we need to implement IQueryable -  we'll have an IQuerable implementation soon with the UmbracoLinqPadDriver implementation
+    //IQueryableUserStore<BackOfficeIdentityUser, int>
     {
         private readonly IUserService _userService;
         private readonly IEntityService _entityService;
@@ -57,7 +58,7 @@ namespace Umbraco.Core.Security
         }
 
         /// <summary>
-        /// Handles the disposal of resources. Derived from abstract class <see cref="DisposableObject"/> which handles common required locking logic.
+        /// Handles the disposal of resources. Derived from abstract class <see cref="DisposableObjectSlim"/> which handles common required locking logic.
         /// </summary>
         protected override void DisposeResources()
         {
@@ -753,6 +754,15 @@ namespace Umbraco.Core.Security
             if (_disposed)
                 throw new ObjectDisposedException(GetType().Name);
         }
-        
+
+        public Task<bool> ValidateSessionIdAsync(int userId, string sessionId)
+        {
+            Guid guidSessionId;
+            if (Guid.TryParse(sessionId, out guidSessionId))
+            {
+                return Task.FromResult(_userService.ValidateLoginSession(userId, guidSessionId));
+            }
+            return Task.FromResult(false);
+        }
     }
 }

src/Umbraco.Core/Security/IUserSessionStore.cs

@@ -0,0 +1,17 @@
+using System;
+using System.Threading.Tasks;
+using Microsoft.AspNet.Identity;
+
+namespace Umbraco.Core.Security
+{
+    /// <summary>
+    /// An IUserStore interface part to implement if the store supports validating user session Ids
+    /// </summary>
+    /// <typeparam name="TUser"></typeparam>
+    /// <typeparam name="TKey"></typeparam>
+    public interface IUserSessionStore<TUser, in TKey> : IUserStore<TUser, TKey>, IDisposable
+        where TUser : class, IUser<TKey>
+    {
+        Task<bool> ValidateSessionIdAsync(int userId, string sessionId);
+    }
+}