Fix formatting

Makes methods on IConsentService more explicit to allow mo

.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 

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/NuSpecs/UmbracoCms.Core.nuspec

@@ -28,7 +28,7 @@
       <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="MySql.Data" version="[6.9.9, 7.0.0)" />
-      <dependency id="ClientDependency" version="[1.9.4, 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)" />

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.8, 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>

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"

src/NuGet.Config

@@ -2,6 +2,6 @@
 <configuration>
   <packageSources>
     <add key="nuget.org" value="https://www.nuget.org/api/v2/" />
-    <add key="umbracocore" value="http://www.myget.org/f/umbracocore/" />
+    <add key="umbracocore" value="https://www.myget.org/F/umbracocore/api/v3/index.json" />
   </packageSources>
 </configuration>

src/SolutionInfo.cs

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

src/Umbraco.Core/Auditing/AuditEventHandler.cs

@@ -0,0 +1,351 @@
+using System;
+using System.Linq;
+using System.Text;
+using System.Threading;
+using System.Web;
+using Umbraco.Core.Events;
+using Umbraco.Core.Models;
+using Umbraco.Core.Models.Membership;
+using Umbraco.Core.Security;
+using Umbraco.Core.Services;
+
+namespace Umbraco.Core.Auditing
+{
+    public sealed class AuditEventHandler : ApplicationEventHandler
+    {
+        private IAuditService _auditServiceInstance;
+        private IUserService _userServiceInstance;
+        private IEntityService _entityServiceInstance;
+
+        private IUser CurrentPerformingUser
+        {
+            get
+            {
+                var identity = Thread.CurrentPrincipal?.GetUmbracoIdentity();
+                return identity == null
+                    ? new User { Id = 0, Name = "SYSTEM", Email = "" }
+                    : _userServiceInstance.GetUserById(Convert.ToInt32(identity.Id));
+            }
+        }
+
+        private IUser GetPerformingUser(int userId)
+        {
+            var found = userId >= 0 ? _userServiceInstance.GetUserById(userId) : null;
+            return found ?? new User {Id = 0, Name = "SYSTEM", Email = ""};
+        }
+
+        private string PerformingIp
+        {
+            get
+            {
+                var httpContext = HttpContext.Current == null ? (HttpContextBase) null : new HttpContextWrapper(HttpContext.Current);
+                var ip = httpContext.GetCurrentRequestIpAddress();
+                if (ip.ToLowerInvariant().StartsWith("unknown")) ip = "";
+                return ip;
+            }
+        }
+
+        protected override void ApplicationStarted(UmbracoApplicationBase umbracoApplication, ApplicationContext applicationContext)
+        {
+            _auditServiceInstance = applicationContext.Services.AuditService;
+            _userServiceInstance = applicationContext.Services.UserService;
+            _entityServiceInstance = applicationContext.Services.EntityService;
+
+            //BackOfficeUserManager.AccountLocked += ;
+            //BackOfficeUserManager.AccountUnlocked += ;
+            BackOfficeUserManager.ForgotPasswordRequested += OnForgotPasswordRequest;
+            BackOfficeUserManager.ForgotPasswordChangedSuccess += OnForgotPasswordChange;
+            BackOfficeUserManager.LoginFailed += OnLoginFailed;
+            //BackOfficeUserManager.LoginRequiresVerification += ;
+            BackOfficeUserManager.LoginSuccess += OnLoginSuccess;
+            BackOfficeUserManager.LogoutSuccess += OnLogoutSuccess;
+            BackOfficeUserManager.PasswordChanged += OnPasswordChanged;
+            BackOfficeUserManager.PasswordReset += OnPasswordReset;
+            //BackOfficeUserManager.ResetAccessFailedCount += ;
+
+            UserService.SavedUserGroup2 += OnSavedUserGroupWithUsers;
+
+            UserService.SavedUser += OnSavedUser;
+            UserService.DeletedUser += OnDeletedUser;
+            UserService.UserGroupPermissionsAssigned += UserGroupPermissionAssigned;
+
+            MemberService.Saved += OnSavedMember;
+            MemberService.Deleted += OnDeletedMember;
+            MemberService.AssignedRoles += OnAssignedRoles;
+            MemberService.RemovedRoles += OnRemovedRoles;
+            MemberService.Exported += OnMemberExported;
+        }
+
+        private string FormatEmail(IMember member)
+        {
+            return member == null ? string.Empty : member.Email.IsNullOrWhiteSpace() ? "" : $"<{member.Email}>";
+        }
+
+        private string FormatEmail(IUser user)
+        {
+            return user == null ? string.Empty : user.Email.IsNullOrWhiteSpace() ? "" : $"<{user.Email}>";
+        }
+
+        private void OnRemovedRoles(IMemberService sender, RolesEventArgs args)
+        {
+            var performingUser = CurrentPerformingUser;
+            var roles = string.Join(", ", args.Roles);
+            var members = sender.GetAllMembers(args.MemberIds).ToDictionary(x => x.Id, x => x);
+            foreach (var id in args.MemberIds)
+            {
+                members.TryGetValue(id, out var member);
+                _auditServiceInstance.Write(performingUser.Id, $"User \"{performingUser.Name}\" {FormatEmail(performingUser)}", PerformingIp,
+                    DateTime.UtcNow,
+                    -1, $"Member {id} \"{member?.Name ?? "(unknown)"}\" {FormatEmail(member)}",
+                    "umbraco/member/roles/removed", $"roles modified, removed {roles}");
+            }
+        }
+
+        private void OnAssignedRoles(IMemberService sender, RolesEventArgs args)
+        {
+            var performingUser = CurrentPerformingUser;
+            var roles = string.Join(", ", args.Roles);
+            var members = sender.GetAllMembers(args.MemberIds).ToDictionary(x => x.Id, x => x);
+            foreach (var id in args.MemberIds)
+            {
+                members.TryGetValue(id, out var member);
+                _auditServiceInstance.Write(performingUser.Id, $"User \"{performingUser.Name}\" {FormatEmail(performingUser)}", PerformingIp,
+                    DateTime.UtcNow,
+                    -1, $"Member {id} \"{member?.Name ?? "(unknown)"}\" {FormatEmail(member)}",
+                    "umbraco/member/roles/assigned", $"roles modified, assigned {roles}");
+            }
+        }
+
+        private void OnMemberExported(IMemberService sender, ExportedMemberEventArgs exportedMemberEventArgs)
+        {
+            var performingUser = CurrentPerformingUser;
+            var member = exportedMemberEventArgs.Member;
+
+            _auditServiceInstance.Write(performingUser.Id, $"User \"{performingUser.Name}\" {FormatEmail(performingUser)}", PerformingIp,
+                DateTime.UtcNow,
+                -1, $"Member {member.Id} \"{member.Name}\" {FormatEmail(member)}",
+                "umbraco/member/exported", "exported member data");
+        }
+
+        private void OnSavedUserGroupWithUsers(IUserService sender, SaveEventArgs<UserGroupWithUsers> saveEventArgs)
+        {
+            var performingUser = CurrentPerformingUser;
+            foreach (var groupWithUser in saveEventArgs.SavedEntities)
+            {
+                var group = groupWithUser.UserGroup;
+
+                var dp = string.Join(", ", ((UserGroup)group).GetPreviouslyDirtyProperties());
+                var sections = ((UserGroup)group).WasPropertyDirty("AllowedSections")
+                    ? string.Join(", ", group.AllowedSections)
+                    : null;
+                var perms = ((UserGroup)group).WasPropertyDirty("Permissions")
+                    ? string.Join(", ", group.Permissions)
+                    : null;
+
+                var sb = new StringBuilder();
+                sb.Append($"updating {(string.IsNullOrWhiteSpace(dp) ? "(nothing)" : dp)};");
+                if (sections != null)
+                    sb.Append($", assigned sections: {sections}");
+                if (perms != null)
+                {
+                    if (sections != null)
+                        sb.Append(", ");
+                    sb.Append($"default perms: {perms}");
+                }
+
+                _auditServiceInstance.Write(performingUser.Id, $"User \"{performingUser.Name}\" {FormatEmail(performingUser)}", PerformingIp,
+                    DateTime.UtcNow,
+                    -1, $"User Group {group.Id} \"{group.Name}\" ({group.Alias})",
+                    "umbraco/user-group/save", $"{sb}");
+
+                // now audit the users that have changed
+
+                foreach (var user in groupWithUser.RemovedUsers)
+                {
+                    _auditServiceInstance.Write(performingUser.Id, $"User \"{performingUser.Name}\" {FormatEmail(performingUser)}", PerformingIp,
+                        DateTime.UtcNow,
+                        user.Id, $"User \"{user.Name}\" {FormatEmail(user)}",
+                        "umbraco/user-group/save", $"Removed user \"{user.Name}\" {FormatEmail(user)} from group {group.Id} \"{group.Name}\" ({group.Alias})");
+                }
+
+                foreach (var user in groupWithUser.AddedUsers)
+                {
+                    _auditServiceInstance.Write(performingUser.Id, $"User \"{performingUser.Name}\" {FormatEmail(performingUser)}", PerformingIp,
+                        DateTime.UtcNow,
+                        user.Id, $"User \"{user.Name}\" {FormatEmail(user)}",
+                        "umbraco/user-group/save", $"Added user \"{user.Name}\" {FormatEmail(user)} to group {group.Id} \"{group.Name}\" ({group.Alias})");
+                }
+            }
+        }
+
+        private void UserGroupPermissionAssigned(IUserService sender, SaveEventArgs<EntityPermission> saveEventArgs)
+        {
+            var performingUser = CurrentPerformingUser;
+            var perms = saveEventArgs.SavedEntities;
+            foreach (var perm in perms)
+            {
+                var group = sender.GetUserGroupById(perm.UserGroupId);
+                var assigned = string.Join(", ", perm.AssignedPermissions);
+                var entity = _entityServiceInstance.Get(perm.EntityId);
+
+                _auditServiceInstance.Write(performingUser.Id, $"User \"{performingUser.Name}\" {FormatEmail(performingUser)}", PerformingIp,
+                    DateTime.UtcNow,
+                    -1, $"User Group {group.Id} \"{group.Name}\" ({group.Alias})",
+                    "umbraco/user-group/permissions-change", $"assigning {(string.IsNullOrWhiteSpace(assigned) ? "(nothing)" : assigned)} on id:{perm.EntityId} \"{entity.Name}\"");
+            }
+        }
+
+        private void OnSavedMember(IMemberService sender, SaveEventArgs<IMember> saveEventArgs)
+        {
+            var performingUser = CurrentPerformingUser;
+            var members = saveEventArgs.SavedEntities;
+            foreach (var member in members)
+            {
+                var dp = string.Join(", ", ((Member) member).GetPreviouslyDirtyProperties());
+
+                _auditServiceInstance.Write(performingUser.Id, $"User \"{performingUser.Name}\" {FormatEmail(performingUser)}", PerformingIp,
+                    DateTime.UtcNow,
+                    -1, $"Member {member.Id} \"{member.Name}\" {FormatEmail(member)}",
+                    "umbraco/member/save", $"updating {(string.IsNullOrWhiteSpace(dp) ? "(nothing)" : dp)}");
+            }
+        }
+
+        private void OnDeletedMember(IMemberService sender, DeleteEventArgs<IMember> deleteEventArgs)
+        {
+            var performingUser = CurrentPerformingUser;
+            var members = deleteEventArgs.DeletedEntities;
+            foreach (var member in members)
+            {
+                _auditServiceInstance.Write(performingUser.Id, $"User \"{performingUser.Name}\" {FormatEmail(performingUser)}", PerformingIp,
+                    DateTime.UtcNow,
+                    -1, $"Member {member.Id} \"{member.Name}\" {FormatEmail(member)}",
+                    "umbraco/member/delete", $"delete member id:{member.Id} \"{member.Name}\" {FormatEmail(member)}");
+            }
+        }
+
+        private void OnSavedUser(IUserService sender, SaveEventArgs<IUser> saveEventArgs)
+        {
+            var performingUser = CurrentPerformingUser;
+            var affectedUsers = saveEventArgs.SavedEntities;
+            foreach (var affectedUser in affectedUsers)
+            {
+                var groups = affectedUser.WasPropertyDirty("Groups")
+                    ? string.Join(", ", affectedUser.Groups.Select(x => x.Alias))
+                    : null;
+
+                var dp = string.Join(", ", ((User)affectedUser).GetPreviouslyDirtyProperties());
+
+                _auditServiceInstance.Write(performingUser.Id, $"User \"{performingUser.Name}\" {FormatEmail(performingUser)}", PerformingIp,
+                    DateTime.UtcNow,
+                    affectedUser.Id, $"User \"{affectedUser.Name}\" {FormatEmail(affectedUser)}",
+                    "umbraco/user/save", $"updating {(string.IsNullOrWhiteSpace(dp) ? "(nothing)" : dp)}{(groups == null ? "" : "; groups assigned: " + groups)}");
+            }
+        }
+
+        private void OnDeletedUser(IUserService sender, DeleteEventArgs<IUser> deleteEventArgs)
+        {
+            var performingUser = CurrentPerformingUser;
+            var affectedUsers = deleteEventArgs.DeletedEntities;
+            foreach (var affectedUser in affectedUsers)
+                _auditServiceInstance.Write(performingUser.Id, $"User \"{performingUser.Name}\" {FormatEmail(performingUser)}", PerformingIp,
+                    DateTime.UtcNow,
+                    affectedUser.Id, $"User \"{affectedUser.Name}\" {FormatEmail(affectedUser)}",
+                    "umbraco/user/delete", "delete user");
+        }
+
+        private void OnLoginSuccess(object sender, EventArgs args)
+        {
+            if (args is IdentityAuditEventArgs identityArgs)
+            {
+                var performingUser = GetPerformingUser(identityArgs.PerformingUser);
+                WriteAudit(performingUser, identityArgs.AffectedUser, identityArgs.IpAddress, "umbraco/user/sign-in/login", "login success");
+            }
+        }
+
+        private void OnLogoutSuccess(object sender, EventArgs args)
+        {
+            if (args is IdentityAuditEventArgs identityArgs)
+            {
+                var performingUser = GetPerformingUser(identityArgs.PerformingUser);
+                WriteAudit(performingUser, identityArgs.AffectedUser, identityArgs.IpAddress, "umbraco/user/sign-in/logout", "logout success");
+            }
+        }
+
+        private void OnPasswordReset(object sender, EventArgs args)
+        {
+            if (args is IdentityAuditEventArgs identityArgs && identityArgs.PerformingUser >= 0)
+            {
+                WriteAudit(identityArgs.PerformingUser, identityArgs.AffectedUser, identityArgs.IpAddress, "umbraco/user/password/reset", "password reset");
+            }
+        }
+
+        private void OnPasswordChanged(object sender, EventArgs args)
+        {
+            if (args is IdentityAuditEventArgs identityArgs && identityArgs.PerformingUser >= 0)
+            {
+                WriteAudit(identityArgs.PerformingUser, identityArgs.AffectedUser, identityArgs.IpAddress, "umbraco/user/password/change", "password change");
+            }
+        }
+
+        private void OnLoginFailed(object sender, EventArgs args)
+        {
+            if (args is IdentityAuditEventArgs identityArgs && identityArgs.PerformingUser >= 0)
+            {
+                WriteAudit(identityArgs.PerformingUser, 0, identityArgs.IpAddress, "umbraco/user/sign-in/failed", "login failed", affectedDetails: "");
+            }
+        }
+
+        private void OnForgotPasswordChange(object sender, EventArgs args)
+        {
+            if (args is IdentityAuditEventArgs identityArgs && identityArgs.PerformingUser >= 0)
+            {
+                WriteAudit(identityArgs.PerformingUser, identityArgs.AffectedUser, identityArgs.IpAddress, "umbraco/user/password/forgot/change", "password forgot/change");
+            }
+        }
+
+        private void OnForgotPasswordRequest(object sender, EventArgs args)
+        {
+            if (args is IdentityAuditEventArgs identityArgs && identityArgs.PerformingUser >= 0)
+            {
+                WriteAudit(identityArgs.PerformingUser, identityArgs.AffectedUser, identityArgs.IpAddress, "umbraco/user/password/forgot/request", "password forgot/request");
+            }
+        }
+
+        private void WriteAudit(int performingId, int affectedId, string ipAddress, string eventType, string eventDetails, string affectedDetails = null)
+        {
+            var performingUser = _userServiceInstance.GetUserById(performingId);
+
+            var performingDetails = performingUser == null
+                ? $"User UNKNOWN:{performingId}"
+                : $"User \"{performingUser.Name}\" {FormatEmail(performingUser)}";
+
+            WriteAudit(performingId, performingDetails, affectedId, ipAddress, eventType, eventDetails, affectedDetails);
+        }
+
+        private void WriteAudit(IUser performingUser, int affectedId, string ipAddress, string eventType, string eventDetails)
+        {
+            var performingDetails = performingUser == null
+                ? $"User UNKNOWN"
+                : $"User \"{performingUser.Name}\" {FormatEmail(performingUser)}";
+
+            WriteAudit(performingUser?.Id ?? 0, performingDetails, affectedId, ipAddress, eventType, eventDetails);
+        }
+
+        private void WriteAudit(int performingId, string performingDetails, int affectedId, string ipAddress, string eventType, string eventDetails, string affectedDetails = null)
+        {
+            if (affectedDetails == null)
+            {
+                var affectedUser = _userServiceInstance.GetUserById(affectedId);
+                affectedDetails = affectedUser == null
+                    ? $"User UNKNOWN:{affectedId}"
+                    : $"User \"{affectedUser.Name}\" {FormatEmail(affectedUser)}";
+            }
+
+            _auditServiceInstance.Write(performingId, performingDetails,
+                ipAddress,
+                DateTime.UtcNow,
+                affectedId, affectedDetails,
+                eventType, eventDetails);
+        }
+    }
+}

src/Umbraco.Core/Auditing/IdentityAuditEventArgs.cs

@@ -1,4 +1,5 @@
 using System;
+using System.ComponentModel;
 using System.Threading;
 using System.Web;
 using Umbraco.Core.Security;
@@ -45,12 +46,8 @@ namespace Umbraco.Core.Auditing
         /// </summary>
         public string Username { get; private set; }
 
-        /// <summary>
-        /// Sets the properties on the event being raised, all parameters are optional except for the action being performed
-        /// </summary>
-        /// <param name="action">An action based on the AuditEvent enum</param>
-        /// <param name="ipAddress">The client's IP address. This is usually automatically set but could be overridden if necessary</param>
-        /// <param name="performingUser">The Id of the user performing the action (if different from the user affected by the action)</param>
+        [Obsolete("Use the method that has the affectedUser parameter instead")]
+        [EditorBrowsable(EditorBrowsableState.Never)]
         public IdentityAuditEventArgs(AuditEvent action, string ipAddress, int performingUser = -1)
         {
             DateTimeUtc = DateTime.UtcNow;
@@ -63,6 +60,35 @@ namespace Umbraco.Core.Auditing
                 : performingUser;
         }
 
+        /// <summary>
+        /// Default constructor
+        /// </summary>
+        /// <param name="action"></param>
+        /// <param name="ipAddress"></param>
+        /// <param name="comment"></param>
+        /// <param name="performingUser"></param>
+        /// <param name="affectedUser"></param>
+        public IdentityAuditEventArgs(AuditEvent action, string ipAddress, string comment = null, int performingUser = -1, int affectedUser = -1)
+        {
+            DateTimeUtc = DateTime.UtcNow;
+            Action = action;
+
+            IpAddress = ipAddress;
+            Comment = comment;
+            AffectedUser = affectedUser;
+
+            PerformingUser = performingUser == -1
+                ? GetCurrentRequestBackofficeUserId()
+                : performingUser;
+        }
+
+        /// <summary>
+        /// Creates an instance without a performing or affected user (the id will be set to -1)
+        /// </summary>
+        /// <param name="action"></param>
+        /// <param name="ipAddress"></param>
+        /// <param name="username"></param>
+        /// <param name="comment"></param>
         public IdentityAuditEventArgs(AuditEvent action, string ipAddress, string username, string comment)
         {
             DateTimeUtc = DateTime.UtcNow;
@@ -71,6 +97,22 @@ namespace Umbraco.Core.Auditing
             IpAddress = ipAddress;
             Username = username;
             Comment = comment;
+
+            PerformingUser = -1;
+        }
+
+        public IdentityAuditEventArgs(AuditEvent action, string ipAddress, string username, string comment, int performingUser)
+        {
+            DateTimeUtc = DateTime.UtcNow;
+            Action = action;
+
+            IpAddress = ipAddress;
+            Username = username;
+            Comment = comment;
+
+            PerformingUser = performingUser == -1
+                ? GetCurrentRequestBackofficeUserId()
+                : performingUser;
         }
 
         /// <summary>

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/Configuration/ClientDependencyConfiguration.cs

@@ -1,10 +1,14 @@
 using System;
 using System.Collections.Generic;
 using System.IO;
+using System.Linq;
+using System.Security.Cryptography;
+using System.Text;
 using System.Web;
 using System.Xml.Linq;
 using ClientDependency.Core.CompositeFiles.Providers;
 using ClientDependency.Core.Config;
+using Semver;
 using Umbraco.Core.IO;
 using Umbraco.Core.Logging;
 
@@ -24,10 +28,74 @@ namespace Umbraco.Core.Configuration
             _logger = logger;
             _fileName = IOHelper.MapPath(string.Format("{0}/ClientDependency.config", SystemDirectories.Config));
         }
+        
+        /// <summary>
+        /// Changes the version number in ClientDependency.config to a hashed value for the version and the DateTime.Day
+        /// </summary>
+        /// <param name="version">The <see cref="SemVersion">version</see> of Umbraco we're upgrading to</param>
+        /// <param name="date">A <see cref="DateTime">date</see> value to use in the hash to prevent this method from updating the version on each startup</param>
+        /// <param name="dateFormat">Allows the developer to specify the <see cref="string">date precision</see> for the hash (i.e. "yyyyMMdd" would be a precision for the day)</param>
+        /// <returns>Boolean to indicate succesful update of the ClientDependency.config file</returns>
+        public bool UpdateVersionNumber(SemVersion version, DateTime date, string dateFormat)
+        {
+            var byteContents = Encoding.Unicode.GetBytes(version + date.ToString(dateFormat));
+            
+            //This is a way to convert a string to a long
+            //see https://www.codeproject.com/Articles/34309/Convert-String-to-bit-Integer
+            //We could much more easily use MD5 which would create us an INT but since that is not compliant with
+            //hashing standards we have to use SHA
+            int intHash;
+            using (var hash = SHA256.Create())
+            {
+                var bytes = hash.ComputeHash(byteContents);
+
+                var longResult = new[] { 0, 8, 16, 24 }
+                    .Select(i => BitConverter.ToInt64(bytes, i))
+                    .Aggregate((x, y) => x ^ y);
+
+                //CDF requires an INT, and although this isn't fail safe, it will work for our purposes. We are not hashing for crypto purposes
+                //so there could be some collisions with this conversion but it's not a problem for our purposes
+                //It's also important to note that the long.GetHashCode() implementation in .NET is this: return (int) this ^ (int) (this >> 32);
+                //which means that this value will not change per appdomain like some GetHashCode implementations.
+                intHash = longResult.GetHashCode();
+            }
+
+            try
+            {
+                var clientDependencyConfigXml = XDocument.Load(_fileName, LoadOptions.PreserveWhitespace);
+                if (clientDependencyConfigXml.Root != null)
+                {
+
+                    var versionAttribute = clientDependencyConfigXml.Root.Attribute("version");
+
+                    //Set the new version to the hashcode of now
+                    var oldVersion = versionAttribute.Value;
+                    var newVersion = Math.Abs(intHash).ToString();
+
+                    //don't update if it's the same version
+                    if (oldVersion == newVersion)
+                        return false;
+
+                    versionAttribute.SetValue(newVersion);
+                    clientDependencyConfigXml.Save(_fileName, SaveOptions.DisableFormatting);
+
+                    _logger.Info<ClientDependencyConfiguration>(string.Format("Updated version number from {0} to {1}", oldVersion, newVersion));
+                    return true;
+                }
+            }
+            catch (Exception ex)
+            {
+                _logger.Error<ClientDependencyConfiguration>("Couldn't update ClientDependency version number", ex);
+            }
+
+            return false;
+        }
 
         /// <summary>
         /// Changes the version number in ClientDependency.config to a random value to avoid stale caches
         /// </summary>
+        /// <seealso cref="UpdateVersionNumber(SemVersion, DateTime, string)" />
+        [Obsolete("Use the UpdateVersionNumber method specifying the version, date and dateFormat instead")]
         public bool IncreaseVersionNumber()
         {
             try
@@ -107,4 +175,4 @@ namespace Umbraco.Core.Configuration
             return success;
         }
     }
-}
+}

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.8.0");
+        private static readonly Version Version = new Version("7.9.0");
 
         /// <summary>
         /// Gets the current version of Umbraco.

src/Umbraco.Core/Constants-Security.cs

@@ -9,6 +9,7 @@ namespace Umbraco.Core
         {
 
             public const string AdminGroupAlias = "admin";
+            public const string SensitiveDataGroupAlias = "sensitiveData";
             public const string TranslatorGroupAlias = "translator";
 
             public const string BackOfficeAuthenticationType = "UmbracoBackOffice";
@@ -36,4 +37,4 @@ namespace Umbraco.Core
 
         }
     }
-}
+}

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/Events/ExportedMemberEventArgs.cs

@@ -0,0 +1,18 @@
+using System;
+using Umbraco.Core.Models;
+using Umbraco.Core.Models.Membership;
+
+namespace Umbraco.Core.Events
+{
+    internal class ExportedMemberEventArgs : EventArgs
+    {
+        public IMember Member { get; }
+        public MemberExportModel Exported { get; }
+
+        public ExportedMemberEventArgs(IMember member, MemberExportModel exported)
+        {
+            Member = member;
+            Exported = exported;
+        }
+    }
+}

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/RolesEventArgs.cs

@@ -0,0 +1,16 @@
+using System;
+
+namespace Umbraco.Core.Events
+{
+    public class RolesEventArgs : EventArgs
+    {
+        public RolesEventArgs(int[] memberIds, string[] roles)
+        {
+            MemberIds = memberIds;
+            Roles = roles;
+        }
+
+        public int[] MemberIds { get; set; }
+        public string[] Roles { get; set; }
+    }
+}

src/Umbraco.Core/Events/UserGroupWithUsers.cs

@@ -0,0 +1,19 @@
+using System;
+using Umbraco.Core.Models.Membership;
+
+namespace Umbraco.Core.Events
+{
+    internal class UserGroupWithUsers
+    {
+        public UserGroupWithUsers(IUserGroup userGroup, IUser[] addedUsers, IUser[] removedUsers)
+        {
+            UserGroup = userGroup;
+            AddedUsers = addedUsers;
+            RemovedUsers = removedUsers;
+        }
+
+        public IUserGroup UserGroup { get; }
+        public IUser[] AddedUsers { get; }
+        public IUser[] RemovedUsers { get; }
+    }
+}

src/Umbraco.Core/Models/AuditEntry.cs

@@ -0,0 +1,94 @@
+using System;
+using System.Reflection;
+using System.Runtime.Serialization;
+using Umbraco.Core.Models.EntityBase;
+
+namespace Umbraco.Core.Models
+{
+    /// <summary>
+    /// Represents an audited event.
+    /// </summary>
+    [Serializable]
+    [DataContract(IsReference = true)]
+    internal class AuditEntry : Entity, IAuditEntry
+    {
+        private static PropertySelectors _selectors;
+
+        private int _performingUserId;
+        private string _performingDetails;
+        private string _performingIp;
+        private int _affectedUserId;
+        private string _affectedDetails;
+        private string _eventType;
+        private string _eventDetails;
+
+        private static PropertySelectors Selectors => _selectors ?? (_selectors = new PropertySelectors());
+
+        private class PropertySelectors
+        {
+            public readonly PropertyInfo PerformingUserId = ExpressionHelper.GetPropertyInfo<AuditEntry, int>(x => x.PerformingUserId);
+            public readonly PropertyInfo PerformingDetails = ExpressionHelper.GetPropertyInfo<AuditEntry, string>(x => x.PerformingDetails);
+            public readonly PropertyInfo PerformingIp = ExpressionHelper.GetPropertyInfo<AuditEntry, string>(x => x.PerformingIp);
+            public readonly PropertyInfo AffectedUserId = ExpressionHelper.GetPropertyInfo<AuditEntry, int>(x => x.AffectedUserId);
+            public readonly PropertyInfo AffectedDetails = ExpressionHelper.GetPropertyInfo<AuditEntry, string>(x => x.AffectedDetails);
+            public readonly PropertyInfo EventType = ExpressionHelper.GetPropertyInfo<AuditEntry, string>(x => x.EventType);
+            public readonly PropertyInfo EventDetails = ExpressionHelper.GetPropertyInfo<AuditEntry, string>(x => x.EventDetails);
+        }
+
+        /// <inheritdoc />
+        public int PerformingUserId
+        {
+            get => _performingUserId;
+            set => SetPropertyValueAndDetectChanges(value, ref _performingUserId, Selectors.PerformingUserId);
+        }
+
+        /// <inheritdoc />
+        public string PerformingDetails
+        {
+            get => _performingDetails;
+            set => SetPropertyValueAndDetectChanges(value, ref _performingDetails, Selectors.PerformingDetails);
+        }
+
+        /// <inheritdoc />
+        public string PerformingIp
+        {
+            get => _performingIp;
+            set => SetPropertyValueAndDetectChanges(value, ref _performingIp, Selectors.PerformingIp);
+        }
+
+        /// <inheritdoc />
+        public DateTime EventDateUtc
+        {
+            get => CreateDate;
+            set => CreateDate = value;
+        }
+
+        /// <inheritdoc />
+        public int AffectedUserId 
+        {
+            get => _affectedUserId;
+            set => SetPropertyValueAndDetectChanges(value, ref _affectedUserId, Selectors.AffectedUserId);
+        }
+
+        /// <inheritdoc />
+        public string AffectedDetails 
+        {
+            get => _affectedDetails;
+            set => SetPropertyValueAndDetectChanges(value, ref _affectedDetails, Selectors.AffectedDetails);
+        }
+
+        /// <inheritdoc />
+        public string EventType 
+        {
+            get => _eventType;
+            set => SetPropertyValueAndDetectChanges(value, ref _eventType, Selectors.EventType);
+        }
+
+        /// <inheritdoc />
+        public string EventDetails 
+        {
+            get => _eventDetails;
+            set => SetPropertyValueAndDetectChanges(value, ref _eventDetails, Selectors.EventDetails);
+        }
+    }
+}

src/Umbraco.Core/Models/Consent.cs

@@ -0,0 +1,102 @@
+using System;
+using System.Collections.Generic;
+using System.Reflection;
+using System.Runtime.Serialization;
+using Umbraco.Core.Models.EntityBase;
+
+namespace Umbraco.Core.Models
+{
+    /// <summary>
+    /// Represents a consent.
+    /// </summary>
+    [Serializable]
+    [DataContract(IsReference = true)]
+    internal class Consent : Entity, IConsent
+    {
+        private static PropertySelectors _selector;
+
+        private bool _current;
+        private string _source;
+        private string _context;
+        private string _action;
+        private ConsentState _state;
+        private string _comment;
+
+        // ReSharper disable once ClassNeverInstantiated.Local
+        private class PropertySelectors
+        {
+            public readonly PropertyInfo Current = ExpressionHelper.GetPropertyInfo<Consent, bool>(x => x.Current);
+            public readonly PropertyInfo Source = ExpressionHelper.GetPropertyInfo<Consent, string>(x => x.Source);
+            public readonly PropertyInfo Context = ExpressionHelper.GetPropertyInfo<Consent, string>(x => x.Context);
+            public readonly PropertyInfo Action = ExpressionHelper.GetPropertyInfo<Consent, string>(x => x.Action);
+            public readonly PropertyInfo State = ExpressionHelper.GetPropertyInfo<Consent, ConsentState>(x => x.State);
+            public readonly PropertyInfo Comment = ExpressionHelper.GetPropertyInfo<Consent, string>(x => x.Comment);
+        }
+
+        private static PropertySelectors Selectors => _selector ?? (_selector = new PropertySelectors());
+
+        /// <inheritdoc />
+        public bool Current
+        {
+            get => _current;
+            set => SetPropertyValueAndDetectChanges(value, ref _current, Selectors.Current);
+        }
+
+        /// <inheritdoc />
+        public string Source
+        {
+            get => _source;
+            set
+            {
+                if (string.IsNullOrWhiteSpace(value)) throw new ArgumentException(nameof(value));
+                SetPropertyValueAndDetectChanges(value, ref _source, Selectors.Source);
+            }
+        }
+
+        /// <inheritdoc />
+        public string Context
+        {
+            get => _context;
+            set
+            {
+                if (string.IsNullOrWhiteSpace(value)) throw new ArgumentException(nameof(value));
+                SetPropertyValueAndDetectChanges(value, ref _context, Selectors.Context);
+            }
+        }
+
+        /// <inheritdoc />
+        public string Action
+        {
+            get => _action;
+            set
+            {
+                if (string.IsNullOrWhiteSpace(value)) throw new ArgumentException(nameof(value));
+                SetPropertyValueAndDetectChanges(value, ref _action, Selectors.Action);
+            }
+        }
+
+        /// <inheritdoc />
+        public ConsentState State
+        {
+            get => _state;
+            // note: we probably should validate the state here, but since the
+            //  enum is [Flags] with many combinations, this could be expensive
+            set => SetPropertyValueAndDetectChanges(value, ref _state, Selectors.State);
+        }
+
+        /// <inheritdoc />
+        public string Comment
+        {
+            get => _comment;
+            set => SetPropertyValueAndDetectChanges(value, ref _comment, Selectors.Comment);
+        }
+
+        /// <inheritdoc />
+        public IEnumerable<IConsent> History => HistoryInternal;
+
+        /// <summary>
+        /// Gets the previous states of this consent.
+        /// </summary>
+        internal List<IConsent> HistoryInternal { get; set; }
+    }
+}

src/Umbraco.Core/Models/ConsentExtensions.cs

@@ -0,0 +1,18 @@
+namespace Umbraco.Core.Models
+{
+    /// <summary>
+    /// Provides extension methods for the <see cref="IConsent"/> interface.
+    /// </summary>
+    public static class ConsentExtensions
+    {
+        /// <summary>
+        /// Determines whether the consent is granted.
+        /// </summary>
+        public static bool IsGranted(this IConsent consent) => (consent.State & ConsentState.Granted) > 0;
+
+        /// <summary>
+        /// Determines whether the consent is revoked.
+        /// </summary>
+        public static bool IsRevoked(this IConsent consent) => (consent.State & ConsentState.Revoked) > 0;
+    }
+}

src/Umbraco.Core/Models/ConsentState.cs

@@ -0,0 +1,38 @@
+using System;
+
+namespace Umbraco.Core.Models
+{
+    /// <summary>
+    /// Represents the state of a consent.
+    /// </summary>
+    [Flags]
+    public enum ConsentState // : int
+    {
+        // note - this is a [Flags] enumeration
+        // on can create detailed flags such as:
+        //GrantedOptIn = Granted | 0x0001
+        //GrandedByForce = Granted | 0x0002
+        //
+        // 16 situations for each Pending/Granted/Revoked should be ok
+
+        /// <summary>
+        /// There is no consent.
+        /// </summary>
+        None = 0,
+
+        /// <summary>
+        /// Consent is pending and has not been granted yet.
+        /// </summary>
+        Pending = 0x10000,
+
+        /// <summary>
+        /// Consent has been granted.
+        /// </summary>
+        Granted = 0x20000,
+
+        /// <summary>
+        /// Consent has been revoked.
+        /// </summary>
+        Revoked = 0x40000
+    }
+}

src/Umbraco.Core/Models/ContentBase.cs

@@ -544,6 +544,28 @@ namespace Umbraco.Core.Models
             return false;
         }
 
+        /// <summary>
+        /// Returns both instance dirty properties and property type properties
+        /// </summary>
+        /// <returns></returns>
+        public override IEnumerable<string> GetDirtyProperties()
+        {
+            var instanceProperties = base.GetDirtyProperties();
+            var propertyTypes = Properties.Where(x => x.IsDirty()).Select(x => x.Alias);
+            return instanceProperties.Concat(propertyTypes);
+        }
+
+        /// <summary>
+        /// Returns both instance dirty properties and property type properties
+        /// </summary>
+        /// <returns></returns>
+        internal override IEnumerable<string> GetPreviouslyDirtyProperties()
+        {
+            var instanceProperties = base.GetPreviouslyDirtyProperties();
+            var propertyTypes = Properties.Where(x => x.WasDirty()).Select(x => x.Alias);
+            return instanceProperties.Concat(propertyTypes);
+        }
+
         #endregion
     }
-}
+}

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/EntityBase/TracksChangesEntityBase.cs

@@ -23,6 +23,13 @@ namespace Umbraco.Core.Models.EntityBase
                 : _propertyChangedInfo.Where(x => x.Value).Select(x => x.Key);
         }
 
+        internal virtual IEnumerable<string> GetPreviouslyDirtyProperties()
+        {
+            return _lastPropertyChangedInfo == null
+                ? Enumerable.Empty<string>()
+                : _lastPropertyChangedInfo.Where(x => x.Value).Select(x => x.Key);
+        }
+
         private bool _changeTrackingEnabled = true;
 
         /// <summary>
@@ -221,4 +228,4 @@ namespace Umbraco.Core.Models.EntityBase
             }
         }
     }
-}
+}

src/Umbraco.Core/Models/IAuditEntry.cs

@@ -0,0 +1,60 @@
+using System;
+using Umbraco.Core.Models.EntityBase;
+
+namespace Umbraco.Core.Models
+{
+    /// <summary>
+    /// Represents an audited event.
+    /// </summary>
+    /// <remarks>
+    /// <para>The free-form details properties can be used to capture relevant infos (for example,
+    /// a user email and identifier) at the time of the audited event, even though they may change
+    /// later on - but we want to keep a track of their value at that time.</para>
+    /// <para>Depending on audit loggers, these properties can be purely free-form text, or
+    /// contain json serialized objects.</para>
+    /// </remarks>
+    public interface IAuditEntry : IAggregateRoot, IRememberBeingDirty
+    {
+        /// <summary>
+        /// Gets or sets the identifier of the user triggering the audited event.
+        /// </summary>
+        int PerformingUserId { get; set; }
+
+        /// <summary>
+        /// Gets or sets free-form details about the user triggering the audited event.
+        /// </summary>
+        string PerformingDetails { get; set; }
+
+        /// <summary>
+        /// Gets or sets the IP address or the request triggering the audited event.
+        /// </summary>
+        string PerformingIp { get; set; }
+
+        /// <summary>
+        /// Gets or sets the date and time of the audited event.
+        /// </summary>
+        DateTime EventDateUtc { get; set; }
+
+        /// <summary>
+        /// Gets or sets the identifier of the user affected by the audited event.
+        /// </summary>
+        /// <remarks>Not used when no single user is affected by the event.</remarks>
+        int AffectedUserId { get; set; }
+
+        /// <summary>
+        /// Gets or sets free-form details about the entity affected by the audited event.
+        /// </summary>
+        /// <remarks>The entity affected by the event can be another user, a member...</remarks>
+        string AffectedDetails { get; set; }
+
+        /// <summary>
+        /// Gets or sets the type of the audited event.
+        /// </summary>
+        string EventType { get; set; }
+
+        /// <summary>
+        /// Gets or sets free-form details about the audited event.
+        /// </summary>
+        string EventDetails { get; set; }
+    }
+}

src/Umbraco.Core/Models/IConsent.cs

@@ -0,0 +1,55 @@
+using System.Collections.Generic;
+using Umbraco.Core.Models.EntityBase;
+
+namespace Umbraco.Core.Models
+{
+    /// <summary>
+    /// Represents a consent state.
+    /// </summary>
+    /// <remarks>
+    /// <para>A consent is fully identified by a source (whoever is consenting), a context (for
+    /// example, an application), and an action (whatever is consented).</para>
+    /// <para>A consent state registers the state of the consent (granted, revoked...).</para>
+    /// </remarks>
+    public interface IConsent : IAggregateRoot, IRememberBeingDirty
+    {
+        /// <summary>
+        /// Determines whether the consent entity represents the current state.
+        /// </summary>
+        bool Current { get; }
+
+        /// <summary>
+        /// Gets the unique identifier of whoever is consenting.
+        /// </summary>
+        string Source { get; }
+
+        /// <summary>
+        /// Gets the unique identifier of the context of the consent.
+        /// </summary>
+        /// <remarks>
+        /// <para>Represents the domain, application, scope... of the action.</para>
+        /// <para>When the action is a Udi, this should be the Udi type.</para>
+        /// </remarks>
+        string Context { get; }
+
+        /// <summary>
+        /// Gets the unique identifier of the consented action.
+        /// </summary>
+        string Action { get; }
+
+        /// <summary>
+        /// Gets the state of the consent.
+        /// </summary>
+        ConsentState State { get; }
+
+        /// <summary>
+        /// Gets some additional free text.
+        /// </summary>
+        string Comment { get; }
+
+        /// <summary>
+        /// Gets the previous states of this consent.
+        /// </summary>
+        IEnumerable<IConsent> History { get; }
+    }
+}

src/Umbraco.Core/Models/IMemberType.cs

@@ -19,6 +19,13 @@
         /// <returns></returns>
         bool MemberCanViewProperty(string propertyTypeAlias);
 
+        /// <summary>
+        /// Gets a boolean indicating whether a Property is marked as storing sensitive values on the Members profile.
+        /// </summary>
+        /// <param name="propertyTypeAlias">PropertyType Alias of the Property to check</param>
+        /// <returns></returns>
+        bool IsSensitiveProperty(string propertyTypeAlias);
+
         /// <summary>
         /// Sets a boolean indicating whether a Property is editable by the Member.
         /// </summary>
@@ -32,5 +39,12 @@
         /// <param name="propertyTypeAlias">PropertyType Alias of the Property to set</param>
         /// <param name="value">Boolean value, true or false</param>
         void SetMemberCanViewProperty(string propertyTypeAlias, bool value);
+
+        /// <summary>
+        /// Sets a boolean indicating whether a Property is a sensitive value on the Members profile.
+        /// </summary>
+        /// <param name="propertyTypeAlias">PropertyType Alias of the Property to set</param>
+        /// <param name="value">Boolean value, true or false</param>
+        void SetIsSensitiveProperty(string propertyTypeAlias, bool value);
     }
-}
+}

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

@@ -34,6 +34,15 @@ namespace Umbraco.Core.Models.Identity
                 .ForMember(user => user.CalculatedContentStartNodeIds, expression => expression.MapFrom(user => user.CalculateContentStartNodeIds(applicationContext.Services.EntityService)))
                 .ForMember(user => user.CalculatedMediaStartNodeIds, expression => expression.MapFrom(user => user.CalculateMediaStartNodeIds(applicationContext.Services.EntityService)))
                 .ForMember(user => user.AllowedSections, expression => expression.MapFrom(user => user.AllowedSections.ToArray()))
+
+                .ForMember(user => user.LockoutEnabled, expression => expression.Ignore())
+                .ForMember(user => user.Logins, expression => expression.Ignore())
+                .ForMember(user => user.Roles, expression => expression.Ignore())
+                .ForMember(user => user.PhoneNumber, expression => expression.Ignore())
+                .ForMember(user => user.PhoneNumberConfirmed, expression => expression.Ignore())
+                .ForMember(user => user.TwoFactorEnabled, expression => expression.Ignore())
+                .ForMember(user => user.Claims, expression => expression.Ignore())
+
                 .AfterMap((user, identityUser) =>
                 {
                     identityUser.ResetDirtyProperties(true);
@@ -47,4 +56,4 @@ namespace Umbraco.Core.Models.Identity
             return storedPass.StartsWith(Constants.Security.EmptyPasswordPrefix) ? null : storedPass;
         }
     }
-}
+}

src/Umbraco.Core/Models/Member.cs

@@ -170,7 +170,19 @@ namespace Umbraco.Core.Models
         public string RawPasswordValue
         {
             get { return _rawPasswordValue; }
-            set { SetPropertyValueAndDetectChanges(value, ref _rawPasswordValue, Ps.Value.PasswordSelector); }
+            set
+            {
+                if (value == null)
+                {
+                    //special case, this is used to ensure that the password is not updated when persisting, in this case
+                    //we don't want to track changes either
+                    _rawPasswordValue = null;
+                }
+                else
+                {
+                    SetPropertyValueAndDetectChanges(value, ref _rawPasswordValue, Ps.Value.PasswordSelector);
+                }
+            }
         }
 
         /// <summary>
@@ -628,4 +640,4 @@ namespace Umbraco.Core.Models
 
         }
     }
-}
+}

src/Umbraco.Core/Models/MemberType.cs

@@ -64,7 +64,7 @@ namespace Umbraco.Core.Models
         }
 
         /// <summary>
-        /// Gets or Sets a Dictionary of Tuples (MemberCanEdit, VisibleOnProfile) by the PropertyTypes' alias.
+        /// Gets or Sets a Dictionary of Tuples (MemberCanEdit, VisibleOnProfile, IsSensitive) by the PropertyTypes' alias.
         /// </summary>
         [DataMember]
         internal IDictionary<string, MemberTypePropertyProfileAccess> MemberTypePropertyTypes { get; private set; }
@@ -76,11 +76,11 @@ namespace Umbraco.Core.Models
         /// <returns></returns>
         public bool MemberCanEditProperty(string propertyTypeAlias)
         {
-            if (MemberTypePropertyTypes.ContainsKey(propertyTypeAlias))
+            MemberTypePropertyProfileAccess propertyProfile;
+            if (MemberTypePropertyTypes.TryGetValue(propertyTypeAlias, out propertyProfile))
             {
-                return MemberTypePropertyTypes[propertyTypeAlias].IsEditable;
+                return propertyProfile.IsEditable;
             }
-
             return false;
         }
 
@@ -91,11 +91,26 @@ namespace Umbraco.Core.Models
         /// <returns></returns>
         public bool MemberCanViewProperty(string propertyTypeAlias)
         {
-            if (MemberTypePropertyTypes.ContainsKey(propertyTypeAlias))
+            MemberTypePropertyProfileAccess propertyProfile;
+            if (MemberTypePropertyTypes.TryGetValue(propertyTypeAlias, out propertyProfile))
             {
-                return MemberTypePropertyTypes[propertyTypeAlias].IsVisible;
+                return propertyProfile.IsVisible;
             }
+            return false;
+        }
 
+        /// <summary>
+        /// Gets a boolean indicating whether a Property is marked as storing sensitive values on the Members profile.
+        /// </summary>
+        /// <param name="propertyTypeAlias">PropertyType Alias of the Property to check</param>
+        /// <returns></returns>
+        public bool IsSensitiveProperty(string propertyTypeAlias)
+        {
+            MemberTypePropertyProfileAccess propertyProfile;
+            if (MemberTypePropertyTypes.TryGetValue(propertyTypeAlias, out propertyProfile))
+            {
+                return propertyProfile.IsSensitive;
+            }
             return false;
         }
 
@@ -106,13 +121,14 @@ namespace Umbraco.Core.Models
         /// <param name="value">Boolean value, true or false</param>
         public void SetMemberCanEditProperty(string propertyTypeAlias, bool value)
         {
-            if (MemberTypePropertyTypes.ContainsKey(propertyTypeAlias))
+            MemberTypePropertyProfileAccess propertyProfile;
+            if (MemberTypePropertyTypes.TryGetValue(propertyTypeAlias, out propertyProfile))
             {
-                MemberTypePropertyTypes[propertyTypeAlias].IsEditable = value;
+                propertyProfile.IsEditable = value;
             }
             else
             {
-                var tuple = new MemberTypePropertyProfileAccess(false, value);
+                var tuple = new MemberTypePropertyProfileAccess(false, value, false);
                 MemberTypePropertyTypes.Add(propertyTypeAlias, tuple);
             }
         }
@@ -124,15 +140,35 @@ namespace Umbraco.Core.Models
         /// <param name="value">Boolean value, true or false</param>
         public void SetMemberCanViewProperty(string propertyTypeAlias, bool value)
         {
-            if (MemberTypePropertyTypes.ContainsKey(propertyTypeAlias))
+            MemberTypePropertyProfileAccess propertyProfile;
+            if (MemberTypePropertyTypes.TryGetValue(propertyTypeAlias, out propertyProfile))
             {
-                MemberTypePropertyTypes[propertyTypeAlias].IsVisible = value;
+                propertyProfile.IsVisible = value;
             }
             else
             {
-                var tuple = new MemberTypePropertyProfileAccess(value, false);
+                var tuple = new MemberTypePropertyProfileAccess(value, false, false);
+                MemberTypePropertyTypes.Add(propertyTypeAlias, tuple);
+            }
+        }
+
+        /// <summary>
+        /// Sets a boolean indicating whether a Property is a sensitive value on the Members profile.
+        /// </summary>
+        /// <param name="propertyTypeAlias">PropertyType Alias of the Property to set</param>
+        /// <param name="value">Boolean value, true or false</param>
+        public void SetIsSensitiveProperty(string propertyTypeAlias, bool value)
+        {
+            MemberTypePropertyProfileAccess propertyProfile;
+            if (MemberTypePropertyTypes.TryGetValue(propertyTypeAlias, out propertyProfile))
+            {
+                propertyProfile.IsSensitive = value;
+            }
+            else
+            {
+                var tuple = new MemberTypePropertyProfileAccess(false, false, true);
                 MemberTypePropertyTypes.Add(propertyTypeAlias, tuple);
             }
         }
     }
-}
+}

src/Umbraco.Core/Models/MemberTypePropertyProfileAccess.cs

@@ -5,13 +5,15 @@ namespace Umbraco.Core.Models
     /// </summary>
     internal class MemberTypePropertyProfileAccess
     {
-        public MemberTypePropertyProfileAccess(bool isVisible, bool isEditable)
+        public MemberTypePropertyProfileAccess(bool isVisible, bool isEditable, bool isSenstive)
         {
             IsVisible = isVisible;
             IsEditable = isEditable;
+            IsSensitive = isSenstive;
         }
 
         public bool IsVisible { get; set; }
         public bool IsEditable { get; set; }
+        public bool IsSensitive { get; set; }
     }
-}
+}

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

@@ -63,4 +63,4 @@ namespace Umbraco.Core.Models.Membership
         }
     }
 
-}
+}

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

@@ -3,7 +3,7 @@ using Umbraco.Core.Models.EntityBase;
 
 namespace Umbraco.Core.Models.Membership
 {
-    public interface IUserGroup : IAggregateRoot
+    public interface IUserGroup : IAggregateRoot, IRememberBeingDirty, ICanBeDirty
     {
         string Alias { get; set; }
 
@@ -41,4 +41,4 @@ namespace Umbraco.Core.Models.Membership
         /// </summary>
         int UserCount { get; }
     }
-}
+}

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

@@ -0,0 +1,22 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Umbraco.Core.Models.Membership
+{
+    internal class MemberExportModel
+    {
+        public int Id { get; set; }
+        public Guid Key { get; set; }
+        public string Name { get; set; }
+        public string Username { get; set; }
+        public string Email { get; set; }
+        public List<string> Groups { get; set; }
+        public string ContentTypeAlias { get; set; }
+        public DateTime CreateDate { get; set; }
+        public DateTime UpdateDate { get; set; }
+        public List<MemberExportProperty> Properties { get; set; }
+    }
+}

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

@@ -0,0 +1,14 @@
+using System;
+
+namespace Umbraco.Core.Models.Membership
+{
+    internal class MemberExportProperty
+    {
+        public int Id { get; set; }
+        public string Alias { get; set; }
+        public string Name { get; set; }
+        public object Value { get; set; }
+        public DateTime? CreateDate { get; set; }
+        public DateTime? UpdateDate { get; set; }
+    }
+}

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

@@ -706,5 +706,6 @@ namespace Umbraco.Core.Models.Membership
                 return _user.GetHashCode();
             }
         }
+
     }
-}
+}

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

@@ -152,4 +152,4 @@ namespace Umbraco.Core.Models.Membership
 
         public int UserCount { get; private set; }
     }
-}
+}

src/Umbraco.Core/Models/PropertyType.cs

@@ -1,6 +1,5 @@
 using System;
 using System.Diagnostics;
-using System.Linq;
 using System.Reflection;
 using System.Runtime.Serialization;
 using System.Text.RegularExpressions;
@@ -436,4 +435,4 @@ namespace Umbraco.Core.Models
             return clone;
         }
     }
-}
+}

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

@@ -42,7 +42,7 @@ namespace Umbraco.Core.Models.PublishedContent
                 var typeName = attribute == null ? type.Name : attribute.ContentTypeAlias;
 
                 if (constructors.ContainsKey(typeName))
-                    throw new InvalidOperationException(string.Format("More that one type want to be a model for content type {0}.", typeName));
+                    throw new InvalidOperationException(string.Format("More than one type wants to be a model for content type {0}.", typeName));
 
                 // should work everywhere, but slow
                 //_constructors[typeName] = constructor;

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

@@ -0,0 +1,60 @@
+using System;
+using Umbraco.Core.Persistence;
+using Umbraco.Core.Persistence.DatabaseAnnotations;
+using Umbraco.Core.Persistence.DatabaseModelDefinitions;
+
+namespace Umbraco.Core.Models.Rdbms
+{
+    [TableName(TableName)]
+    [PrimaryKey("id")]
+    [ExplicitColumns]
+    internal class AuditEntryDto
+    {
+        public const string TableName = "umbracoAudit";
+        public const int IpLength = 64;
+        public const int EventTypeLength = 256;
+        public const int DetailsLength = 1024;
+
+        [Column("id")]
+        [PrimaryKeyColumn]
+        public int Id { get; set; }
+
+        // there is NO foreign key to the users table here, neither for performing user nor for
+        // affected user, so we can delete users and NOT delete the associated audit trails, and
+        // users can still be identified via the details free-form text fields.
+
+        [Column("performingUserId")]
+        public int PerformingUserId { get; set; }
+
+        [Column("performingDetails")]
+        [NullSetting(NullSetting = NullSettings.Null)]
+        [Length(DetailsLength)]
+        public string PerformingDetails { get; set; }
+
+        [Column("performingIp")]
+        [NullSetting(NullSetting = NullSettings.Null)]
+        [Length(IpLength)]
+        public string PerformingIp { get; set; }
+
+        [Column("eventDateUtc")]
+        [Constraint(Default = SystemMethods.CurrentDateTime)]
+        public DateTime EventDateUtc { get; set; }
+
+        [Column("affectedUserId")]
+        public int AffectedUserId { get; set; }
+
+        [Column("affectedDetails")]
+        [NullSetting(NullSetting = NullSettings.Null)]
+        [Length(DetailsLength)]
+        public string AffectedDetails { get; set; }
+
+        [Column("eventType")]
+        [Length(EventTypeLength)]
+        public string EventType { get; set; }
+
+        [Column("eventDetails")]
+        [NullSetting(NullSetting = NullSettings.Null)]
+        [Length(DetailsLength)]
+        public string EventDetails { get; set; }
+    }
+}

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

@@ -0,0 +1,44 @@
+using System;
+using Umbraco.Core.Persistence;
+using Umbraco.Core.Persistence.DatabaseAnnotations;
+using Umbraco.Core.Persistence.DatabaseModelDefinitions;
+
+namespace Umbraco.Core.Models.Rdbms
+{
+    [TableName(TableName)]
+    [PrimaryKey("id")]
+    [ExplicitColumns]
+    public class ConsentDto
+    {
+        internal const string TableName = "umbracoConsent";
+
+        [Column("id")]
+        [PrimaryKeyColumn]
+        public int Id { get; set; }
+
+        [Column("current")]
+        public bool Current { get; set; }
+
+        [Column("source")]
+        [Length(512)]
+        public string Source { get; set; }
+
+        [Column("context")]
+        [Length(128)]
+        public string Context { get; set; }
+
+        [Column("action")]
+        [Length(512)]
+        public string Action { get; set; }
+
+        [Column("createDate")]
+        [Constraint(Default = SystemMethods.CurrentDateTime)]
+        public DateTime CreateDate { get; set; }
+
+        [Column("state")]
+        public int State { get; set; }
+
+        [Column("comment")]
+        public string Comment { get; set; }
+    }
+}

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

@@ -27,5 +27,9 @@ namespace Umbraco.Core.Models.Rdbms
         [Column("viewOnProfile")]
         [Constraint(Default = "0")]
         public bool ViewOnProfile { get; set; }
+
+        [Column("isSensitive")]
+        [Constraint(Default = "0")]
+        public bool IsSensitive { get; set; }
     }
-}
+}

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

@@ -45,6 +45,9 @@ namespace Umbraco.Core.Models.Rdbms
         [Column("viewOnProfile")]
         public bool ViewOnProfile { get; set; }
 
+        [Column("isSensitive")]
+        public bool IsSensitive { get; set; }
+
         /* cmsDataType */
         [Column("propertyEditorAlias")]
         public string PropertyEditorAlias { get; set; }
@@ -52,7 +55,8 @@ namespace Umbraco.Core.Models.Rdbms
         [Column("dbType")]
         public string DbType { get; set; }
 
-        [Column("UniqueID")]        
+        [Column("UniqueID")]
         public Guid UniqueId { get; set; }
+
     }
-}
+}

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

@@ -17,7 +17,7 @@ namespace Umbraco.Core.Models.Rdbms
         }
 
         [Column("id")]
-        [PrimaryKeyColumn(IdentitySeed = 5)]
+        [PrimaryKeyColumn(IdentitySeed = 6)]
         public int Id { get; set; }
 
         [Column("userGroupAlias")]
@@ -68,4 +68,4 @@ namespace Umbraco.Core.Models.Rdbms
         [ResultColumn]
         public int UserCount { get; set; }
     }
-}
+}

src/Umbraco.Core/Models/UserExtensions.cs

@@ -261,6 +261,16 @@ namespace Umbraco.Core.Models
             return user.Groups != null && user.Groups.Any(x => x.Alias == Constants.Security.AdminGroupAlias);
         }
 
+        /// <summary>
+        /// Determines whether this user has access to view sensitive data
+        /// </summary>
+        /// <param name="user"></param>
+        public static bool HasAccessToSensitiveData(this IUser user)
+        {
+            if (user == null) throw new ArgumentNullException("user");
+            return user.Groups != null && user.Groups.Any(x => x.Alias == Constants.Security.SensitiveDataGroupAlias);
+        }
+
         // calc. start nodes, combining groups' and user's, and excluding what's in the bin
         public static int[] CalculateContentStartNodeIds(this IUser user, IEntityService entityService)
         {
@@ -413,4 +423,4 @@ namespace Umbraco.Core.Models
             return lsn.ToArray();
         }
     }
-}
+}

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

@@ -0,0 +1,52 @@
+using System.Collections.Generic;
+using System.Linq;
+using Umbraco.Core.Models;
+using Umbraco.Core.Models.Rdbms;
+
+namespace Umbraco.Core.Persistence.Factories
+{
+    internal static class AuditEntryFactory
+    {
+        public static IEnumerable<IAuditEntry> BuildEntities(IEnumerable<AuditEntryDto> dtos)
+        {
+            return dtos.Select(BuildEntity).ToList();
+        }
+
+        public static IAuditEntry BuildEntity(AuditEntryDto dto)
+        {
+            var entity = new AuditEntry
+            {
+                Id = dto.Id,
+                PerformingUserId = dto.PerformingUserId,
+                PerformingDetails = dto.PerformingDetails,
+                PerformingIp = dto.PerformingIp,
+                EventDateUtc = dto.EventDateUtc,
+                AffectedUserId = dto.AffectedUserId,
+                AffectedDetails = dto.AffectedDetails,
+                EventType = dto.EventType,
+                EventDetails = dto.EventDetails
+            };
+
+            //on initial construction we don't want to have dirty properties tracked
+            // http://issues.umbraco.org/issue/U4-1946
+            entity.ResetDirtyProperties(false);
+            return entity;
+        }
+
+        public static AuditEntryDto BuildDto(IAuditEntry entity)
+        {
+            return new AuditEntryDto
+            {
+                Id = entity.Id,
+                PerformingUserId = entity.PerformingUserId,
+                PerformingDetails = entity.PerformingDetails,
+                PerformingIp = entity.PerformingIp,
+                EventDateUtc = entity.EventDateUtc,
+                AffectedUserId = entity.AffectedUserId,
+                AffectedDetails = entity.AffectedDetails,
+                EventType = entity.EventType,
+                EventDetails = entity.EventDetails
+            };
+        }
+    }
+}

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

@@ -0,0 +1,65 @@
+using System.Collections.Generic;
+using Umbraco.Core.Models;
+using Umbraco.Core.Models.Rdbms;
+
+namespace Umbraco.Core.Persistence.Factories
+{
+    internal static class ConsentFactory
+    {
+        public static IEnumerable<IConsent> BuildEntities(IEnumerable<ConsentDto> dtos)
+        {
+            var ix = new Dictionary<string, Consent>();
+            var output = new List<Consent>();
+
+            foreach (var dto in dtos)
+            {
+                var k = dto.Source + "::" + dto.Context + "::" + dto.Action;
+
+                var consent = new Consent
+                {
+                    Id = dto.Id,
+                    Current = dto.Current,
+                    CreateDate = dto.CreateDate,
+                    Source = dto.Source,
+                    Context = dto.Context,
+                    Action = dto.Action,
+                    State = (ConsentState) dto.State, // assume value is valid
+                    Comment = dto.Comment
+                };
+
+                //on initial construction we don't want to have dirty properties tracked
+                // http://issues.umbraco.org/issue/U4-1946
+                consent.ResetDirtyProperties(false);
+
+                if (ix.TryGetValue(k, out var current))
+                {
+                    if (current.HistoryInternal == null)
+                        current.HistoryInternal = new List<IConsent>();
+                    current.HistoryInternal.Add(consent);
+                }
+                else
+                {
+                    ix[k] = consent;
+                    output.Add(consent);
+                }
+            }
+
+            return output;
+        }
+
+        public static ConsentDto BuildDto(IConsent entity)
+        {
+            return new ConsentDto
+            {
+                Id = entity.Id,
+                Current = entity.Current,
+                CreateDate = entity.CreateDate,
+                Source = entity.Source,
+                Context = entity.Context,
+                Action = entity.Action,
+                State = (int) entity.State,
+                Comment = entity.Comment
+            };
+        }
+    }
+}

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

@@ -84,7 +84,8 @@ namespace Umbraco.Core.Persistence.Factories
                 NodeId = entity.Id,
                 PropertyTypeId = x.Id,
                 CanEdit = memberType.MemberCanEditProperty(x.Alias),
-                ViewOnProfile = memberType.MemberCanViewProperty(x.Alias)
+                ViewOnProfile = memberType.MemberCanViewProperty(x.Alias),
+                IsSensitive = memberType.IsSensitiveProperty(x.Alias)
             }).ToList();
             return dtos;
         }
@@ -159,4 +160,4 @@ namespace Umbraco.Core.Persistence.Factories
 
         #endregion
     }
-}
+}

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

@@ -56,10 +56,10 @@ namespace Umbraco.Core.Persistence.Factories
 
                     //Add the standard PropertyType to the current list
                     propertyTypes.Add(standardPropertyType.Value);
-
-                    //Internal dictionary for adding "MemberCanEdit" and "VisibleOnProfile" properties to each PropertyType
+                    
+                    //Internal dictionary for adding "MemberCanEdit", "VisibleOnProfile", "IsSensitive" properties to each PropertyType
                     memberType.MemberTypePropertyTypes.Add(standardPropertyType.Key,
-                        new MemberTypePropertyProfileAccess(false, false));
+                        new MemberTypePropertyProfileAccess(false, false, false));
                 }
                 memberType.NoGroupPropertyTypes = propertyTypes;
 
@@ -102,7 +102,7 @@ namespace Umbraco.Core.Persistence.Factories
                 {
                     //Internal dictionary for adding "MemberCanEdit" and "VisibleOnProfile" properties to each PropertyType
                     memberType.MemberTypePropertyTypes.Add(typeDto.Alias,
-                        new MemberTypePropertyProfileAccess(typeDto.ViewOnProfile, typeDto.CanEdit));
+                        new MemberTypePropertyProfileAccess(typeDto.ViewOnProfile, typeDto.CanEdit, typeDto.IsSensitive));
 
                     var tempGroupDto = groupDto;
 
@@ -157,7 +157,7 @@ namespace Umbraco.Core.Persistence.Factories
             {
                 //Internal dictionary for adding "MemberCanEdit" and "VisibleOnProfile" properties to each PropertyType
                 memberType.MemberTypePropertyTypes.Add(typeDto.Alias,
-                    new MemberTypePropertyProfileAccess(typeDto.ViewOnProfile, typeDto.CanEdit));
+                    new MemberTypePropertyProfileAccess(typeDto.ViewOnProfile, typeDto.CanEdit, typeDto.IsSensitive));
 
                 //ensures that any built-in membership properties have their correct dbtype assigned no matter
                 //what the underlying data type is
@@ -198,4 +198,4 @@ namespace Umbraco.Core.Persistence.Factories
         }
         
     }
-}
+}

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

@@ -0,0 +1,41 @@
+using System.Collections.Concurrent;
+using Umbraco.Core.Models;
+using Umbraco.Core.Models.Rdbms;
+
+namespace Umbraco.Core.Persistence.Mappers
+{
+    /// <summary>
+    /// Represents a mapper for audit entry entities.
+    /// </summary>
+    [MapperFor(typeof(IAuditEntry))]
+    [MapperFor(typeof(AuditEntry))]
+    public sealed class AuditEntryMapper : BaseMapper
+    {
+        private static readonly ConcurrentDictionary<string, DtoMapModel> PropertyInfoCacheInstance
+            = new ConcurrentDictionary<string, DtoMapModel>();
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="AuditEntryMapper"/> class.
+        /// </summary>
+        public AuditEntryMapper()
+        {
+            // note: why the base ctor does not invoke BuildMap is a mystery to me
+            BuildMap();
+        }
+
+        internal override ConcurrentDictionary<string, DtoMapModel> PropertyInfoCache => PropertyInfoCacheInstance;
+
+        internal override void BuildMap()
+        {
+            CacheMap<AuditEntry, AuditEntryDto>(entity => entity.Id, dto => dto.Id);
+            CacheMap<AuditEntry, AuditEntryDto>(entity => entity.PerformingUserId, dto => dto.PerformingUserId);
+            CacheMap<AuditEntry, AuditEntryDto>(entity => entity.PerformingDetails, dto => dto.PerformingDetails);
+            CacheMap<AuditEntry, AuditEntryDto>(entity => entity.PerformingIp, dto => dto.PerformingIp);
+            CacheMap<AuditEntry, AuditEntryDto>(entity => entity.EventDateUtc, dto => dto.EventDateUtc);
+            CacheMap<AuditEntry, AuditEntryDto>(entity => entity.AffectedUserId, dto => dto.AffectedUserId);
+            CacheMap<AuditEntry, AuditEntryDto>(entity => entity.AffectedDetails, dto => dto.AffectedDetails);
+            CacheMap<AuditEntry, AuditEntryDto>(entity => entity.EventType, dto => dto.EventType);
+            CacheMap<AuditEntry, AuditEntryDto>(entity => entity.EventDetails, dto => dto.EventDetails);
+        }
+    }
+}

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

@@ -0,0 +1,40 @@
+using System.Collections.Concurrent;
+using Umbraco.Core.Models;
+using Umbraco.Core.Models.Rdbms;
+
+namespace Umbraco.Core.Persistence.Mappers
+{
+    /// <summary>
+    /// Represents a mapper for consent entities.
+    /// </summary>
+    [MapperFor(typeof(IConsent))]
+    [MapperFor(typeof(Consent))]
+    public sealed class ConsentMapper : BaseMapper
+    {
+        private static readonly ConcurrentDictionary<string, DtoMapModel> PropertyInfoCacheInstance
+            = new ConcurrentDictionary<string, DtoMapModel>();
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="ConsentMapper"/> class.
+        /// </summary>
+        public ConsentMapper()
+        {
+            // note: why the base ctor does not invoke BuildMap is a mystery to me
+            BuildMap();
+        }
+
+        internal override ConcurrentDictionary<string, DtoMapModel> PropertyInfoCache => PropertyInfoCacheInstance;
+
+        internal override void BuildMap()
+        {
+            CacheMap<Consent, ConsentDto>(entity => entity.Id, dto => dto.Id);
+            CacheMap<Consent, ConsentDto>(entity => entity.Current, dto => dto.Current);
+            CacheMap<Consent, ConsentDto>(entity => entity.CreateDate, dto => dto.CreateDate);
+            CacheMap<Consent, ConsentDto>(entity => entity.Source, dto => dto.Source);
+            CacheMap<Consent, ConsentDto>(entity => entity.Context, dto => dto.Context);
+            CacheMap<Consent, ConsentDto>(entity => entity.Action, dto => dto.Action);
+            CacheMap<Consent, ConsentDto>(entity => entity.State, dto => dto.State);
+            CacheMap<Consent, ConsentDto>(entity => entity.Comment, dto => dto.Comment);
+        }
+    }
+}

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

@@ -178,11 +178,13 @@ namespace Umbraco.Core.Persistence.Migrations.Initial
             _database.Insert("umbracoUserGroup", "id", false, new UserGroupDto { Id = 2, StartMediaId = -1, StartContentId = -1, Alias = "writer", Name = "Writers", DefaultPermissions = "CAH:F", CreateDate = DateTime.Now, UpdateDate = DateTime.Now, Icon = "icon-edit" });
             _database.Insert("umbracoUserGroup", "id", false, new UserGroupDto { Id = 3, StartMediaId = -1, StartContentId = -1, Alias = "editor", Name = "Editors", DefaultPermissions = "CADMOSKTPUZ:5Fï", CreateDate = DateTime.Now, UpdateDate = DateTime.Now, Icon = "icon-tools" });
             _database.Insert("umbracoUserGroup", "id", false, new UserGroupDto { Id = 4, StartMediaId = -1, StartContentId = -1, Alias = Constants.Security.TranslatorGroupAlias, Name = "Translators", DefaultPermissions = "AF", CreateDate = DateTime.Now, UpdateDate = DateTime.Now, Icon = "icon-globe" });
+            _database.Insert("umbracoUserGroup", "id", false, new UserGroupDto { Id = 5, StartMediaId = -1, StartContentId = -1, Alias = Constants.Security.SensitiveDataGroupAlias, Name = "Sensitive data", DefaultPermissions = "", CreateDate = DateTime.Now, UpdateDate = DateTime.Now, Icon = "icon-lock" });
         }
 
         private void CreateUmbracoUser2UserGroupData()
         {
-            _database.Insert(new User2UserGroupDto { UserGroupId = 1, UserId = 0 });
+            _database.Insert(new User2UserGroupDto { UserGroupId = 1, UserId = 0 }); //add admin to admins
+            _database.Insert(new User2UserGroupDto { UserGroupId = 5, UserId = 0 }); //add admin to sensitive data
         }
 
         private void CreateUmbracoUserGroup2AppData()
@@ -337,4 +339,4 @@ namespace Umbraco.Core.Persistence.Migrations.Initial
             _database.Insert("umbracoMigration", "pk", false, dto);
         }
     }
-}
+}

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

@@ -92,7 +92,9 @@ namespace Umbraco.Core.Persistence.Migrations.Initial
                                                                               {52, typeof (UserGroup2NodePermissionDto) },
                                                                               {53, typeof (UserGroup2AppDto) },
                                                                               {54, typeof (UserStartNodeDto) },
-                                                                              {55, typeof (UserLoginDto)}
+                                                                              {55, typeof (UserLoginDto)},
+                                                                              {56, typeof (ConsentDto)},
+                                                                              {57, typeof (AuditEntryDto)}
                                                                           };
         #endregion
         
@@ -378,4 +380,4 @@ namespace Umbraco.Core.Persistence.Migrations.Initial
 
         #endregion
     }
-}
+}

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

@@ -154,6 +154,12 @@ namespace Umbraco.Core.Persistence.Migrations.Initial
                 return new Version(7, 7, 0);
             }
 
+            //if the error is for isSensitive column it must be the previous version to 7.9 since that is when it is added
+            if (Errors.Any(x => x.Item1.Equals("Column") && (x.Item2.InvariantEquals("cmsMemberType,isSensitive"))))
+            {
+                return new Version(7, 8, 0);
+            }
+
             return UmbracoVersion.Current;
         }
 
@@ -214,4 +220,4 @@ namespace Umbraco.Core.Persistence.Migrations.Initial
             return sb.ToString();
         }
     }
-}
+}

src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSevenNineZero/AddIsSensitiveMemberTypeColumn.cs

@@ -0,0 +1,35 @@
+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.9.0", 1, Constants.System.UmbracoMigrationName)]
+    public class AddIsSensitiveMemberTypeColumn : MigrationBase
+    {
+        public AddIsSensitiveMemberTypeColumn(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("cmsMemberType") && x.ColumnName.InvariantEquals("isSensitive")) == false)
+            {
+                Create.Column("isSensitive").OnTable("cmsMemberType").AsBoolean().WithDefaultValue(0).NotNullable();
+            }
+        }
+
+        public override void Down()
+        {
+        }
+    }
+}

src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSevenNineZero/AddUmbracoAuditTable.cs

@@ -0,0 +1,29 @@
+using System;
+using System.Linq;
+using Umbraco.Core.Logging;
+using Umbraco.Core.Models.Rdbms;
+using Umbraco.Core.Persistence.SqlSyntax;
+
+namespace Umbraco.Core.Persistence.Migrations.Upgrades.TargetVersionSevenNineZero
+{
+    [Migration("7.9.0", 1, Constants.System.UmbracoMigrationName)]
+    public class AddUmbracoAuditTable : MigrationBase
+    {
+        public AddUmbracoAuditTable(ISqlSyntaxProvider sqlSyntax, ILogger logger)
+            : base(sqlSyntax, logger)
+        { }
+
+        public override void Up()
+        {
+            var tables = SqlSyntax.GetTablesInSchema(Context.Database).ToArray();
+            if (tables.InvariantContains(AuditEntryDto.TableName))
+                return;
+            Create.Table<AuditEntryDto>();
+        }
+
+        public override void Down()
+        {
+            throw new NotSupportedException();
+        }
+    }
+}

src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSevenNineZero/AddUmbracoConsentTable.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.TargetVersionSevenNineZero
+{
+    [Migration("7.9.0", 1, Constants.System.UmbracoMigrationName)]
+    public class AddUmbracoConsentTable : MigrationBase
+    {
+        public AddUmbracoConsentTable(ISqlSyntaxProvider sqlSyntax, ILogger logger) : base(sqlSyntax, logger)
+        {
+        }
+
+        public override void Up()
+        {
+            var tables = SqlSyntax.GetTablesInSchema(Context.Database).ToArray();
+
+            if (tables.InvariantContains(ConsentDto.TableName))
+                return;
+
+            Create.Table<ConsentDto>();
+        }
+
+        public override void Down()
+        {
+        }
+    }
+}

src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSevenNineZero/CreateSensitiveDataUserGroup.cs

@@ -0,0 +1,37 @@
+using System;
+using Umbraco.Core.Logging;
+using Umbraco.Core.Models.Rdbms;
+using Umbraco.Core.Persistence.SqlSyntax;
+
+namespace Umbraco.Core.Persistence.Migrations.Upgrades.TargetVersionSevenNineZero
+{
+    [Migration("7.9.0", 2, Constants.System.UmbracoMigrationName)]
+    public class CreateSensitiveDataUserGroup : MigrationBase
+    {
+        public CreateSensitiveDataUserGroup(ISqlSyntaxProvider sqlSyntax, ILogger logger)
+            : base(sqlSyntax, logger)
+        {
+        }
+
+        public override void Up()
+        {
+            Execute.Code(database =>
+            {
+                //Don't exeucte if the group is already there
+                var exists = database.ExecuteScalar<int>("SELECT COUNT(*) FROM umbracoUserGroup WHERE userGroupAlias = @userGroupAlias",
+                    new {userGroupAlias = Constants.Security.SensitiveDataGroupAlias });
+                if (exists == 0)
+                {
+                    var resultId = database.Insert("umbracoUserGroup", "id", new UserGroupDto { StartMediaId = -1, StartContentId = -1, Alias = Constants.Security.SensitiveDataGroupAlias, Name = "Sensitive data", DefaultPermissions = "", CreateDate = DateTime.Now, UpdateDate = DateTime.Now, Icon = "icon-lock" });
+                    database.Insert(new User2UserGroupDto { UserGroupId = Convert.ToInt32(resultId), UserId = 0 }); //add admin to sensitive data
+                }
+
+                return string.Empty;
+            });
+        }
+
+        public override void Down()
+        {
+        }
+    }
+}

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

@@ -0,0 +1,131 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using Umbraco.Core.Logging;
+using Umbraco.Core.Models;
+using Umbraco.Core.Models.EntityBase;
+using Umbraco.Core.Models.Rdbms;
+using Umbraco.Core.Persistence.Factories;
+using Umbraco.Core.Persistence.Querying;
+using Umbraco.Core.Persistence.SqlSyntax;
+using Umbraco.Core.Persistence.UnitOfWork;
+
+namespace Umbraco.Core.Persistence.Repositories
+{
+    /// <summary>
+    /// Represents the PetaPoco implementatino of <see cref="IAuditEntryRepository"/>.
+    /// </summary>
+    internal class AuditEntryRepository : PetaPocoRepositoryBase<int, IAuditEntry>, IAuditEntryRepository
+    {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="AuditEntryRepository"/> class.
+        /// </summary>
+        public AuditEntryRepository(IScopeUnitOfWork work, CacheHelper cache, ILogger logger, ISqlSyntaxProvider sqlSyntax)
+            : base(work, cache, logger, sqlSyntax)
+        { }
+
+        protected override Guid NodeObjectTypeId => throw new NotSupportedException();
+
+        /// <inheritdoc />
+        protected override IAuditEntry PerformGet(int id)
+        {
+            var sql = new Sql()
+                .Select("*")
+                .From<AuditEntryDto>(SqlSyntax)
+                .Where<AuditEntryDto>(x => x.Id == id, SqlSyntax);
+
+            var dto = Database.FirstOrDefault<AuditEntryDto>(sql);
+            return dto == null ? null : AuditEntryFactory.BuildEntity(dto);        }
+
+        /// <inheritdoc />
+        protected override IEnumerable<IAuditEntry> PerformGetAll(params int[] ids)
+        {
+            if (ids.Length == 0)
+            {
+                var sql = new Sql()
+                    .Select("*")
+                    .From<AuditEntryDto>(SqlSyntax);
+
+                return Database.Fetch<AuditEntryDto>(sql).Select(AuditEntryFactory.BuildEntity);
+            }
+
+            var entries = new List<IAuditEntry>();
+
+            foreach (var group in ids.InGroupsOf(2000))
+            {
+                var sql = new Sql()
+                    .Select("*")
+                    .From<AuditEntryDto>(SqlSyntax)
+                    .WhereIn<AuditEntryDto>(x => x.Id, group, SqlSyntax);
+
+                entries.AddRange(Database.Fetch<AuditEntryDto>(sql).Select(AuditEntryFactory.BuildEntity));
+            }
+
+            return entries;
+        }
+
+        /// <inheritdoc />
+        protected override IEnumerable<IAuditEntry> PerformGetByQuery(IQuery<IAuditEntry> query)
+        {
+            var sqlClause = GetBaseQuery(false);
+            var translator = new SqlTranslator<IAuditEntry>(sqlClause, query);
+            var sql = translator.Translate();
+            return Database.Fetch<AuditEntryDto>(sql).Select(AuditEntryFactory.BuildEntity);
+        }
+
+        /// <inheritdoc />
+        protected override Sql GetBaseQuery(bool isCount)
+        {
+            return new Sql().Select(isCount ? "COUNT(*)" : "*").From<AuditEntryDto>(SqlSyntax);
+        }
+
+        /// <inheritdoc />
+        protected override string GetBaseWhereClause()
+        {
+            return $"{AuditEntryDto.TableName}.id = @Id";
+        }
+
+        /// <inheritdoc />
+        protected override IEnumerable<string> GetDeleteClauses()
+        {
+            throw new NotSupportedException("Audit entries cannot be deleted.");
+        }
+
+        /// <inheritdoc />
+        protected override void PersistNewItem(IAuditEntry entity)
+        {
+            ((Entity) entity).AddingEntity();
+
+            var dto = AuditEntryFactory.BuildDto(entity);
+            Database.Insert(dto);
+            entity.Id = dto.Id;
+            entity.ResetDirtyProperties();
+        }
+
+        /// <inheritdoc />
+        protected override void PersistUpdatedItem(IAuditEntry entity)
+        {
+            throw new NotSupportedException("Audit entries cannot be updated.");
+        }
+
+        /// <inheritdoc />
+        public IEnumerable<IAuditEntry> GetPage(long pageIndex, int pageCount, out long records)
+        {
+            var sql = new Sql()
+                .Select("*")
+                .From<AuditEntryDto>(SqlSyntax)
+                .OrderByDescending<AuditEntryDto>(x => x.EventDateUtc, SqlSyntax);
+
+            var page = Database.Page<AuditEntryDto>(pageIndex + 1, pageCount, sql);
+            records = page.TotalItems;
+            return page.Items.Select(AuditEntryFactory.BuildEntity);
+        }
+
+        /// <inheritdoc />
+        public bool IsAvailable()
+        {
+            var tables = SqlSyntax.GetTablesInSchema(Database).ToArray();
+            return tables.InvariantContains(AuditEntryDto.TableName);
+        }
+    }
+}

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

@@ -0,0 +1,103 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using Umbraco.Core.Logging;
+using Umbraco.Core.Models;
+using Umbraco.Core.Models.EntityBase;
+using Umbraco.Core.Models.Rdbms;
+using Umbraco.Core.Persistence.Factories;
+using Umbraco.Core.Persistence.Querying;
+using Umbraco.Core.Persistence.SqlSyntax;
+using Umbraco.Core.Persistence.UnitOfWork;
+
+namespace Umbraco.Core.Persistence.Repositories
+{
+    /// <summary>
+    /// Represents the PetaPoco implementation of <see cref="IConsentRepository"/>.
+    /// </summary>
+    internal class ConsentRepository : PetaPocoRepositoryBase<int, IConsent>, IConsentRepository
+    {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="ConsentRepository"/> class.
+        /// </summary>
+        public ConsentRepository(IScopeUnitOfWork work, CacheHelper cache, ILogger logger, ISqlSyntaxProvider sqlSyntax)
+            : base(work, cache, logger, sqlSyntax)
+        { }
+
+        /// <inheritdoc />
+        protected override Guid NodeObjectTypeId => throw new NotSupportedException();
+
+        /// <inheritdoc />
+        public void ClearCurrent(string source, string context, string action)
+        {
+            var sql = new Sql($@"UPDATE {SqlSyntax.GetQuotedTableName(ConsentDto.TableName)}
+SET {SqlSyntax.GetQuotedColumnName("current")} = @0
+WHERE {SqlSyntax.GetQuotedColumnName("source")} = @1 AND {SqlSyntax.GetQuotedColumnName("context")} = @2 AND {SqlSyntax.GetQuotedColumnName("action")} = @3
+AND {SqlSyntax.GetQuotedColumnName("current")} <> @0 ", false, source, context, action);
+
+            Database.Execute(sql);
+        }
+
+        /// <inheritdoc />
+        protected override IConsent PerformGet(int id)
+        {
+            throw new NotImplementedException();
+        }
+
+        /// <inheritdoc />
+        protected override IEnumerable<IConsent> PerformGetAll(params int[] ids)
+        {
+            throw new NotImplementedException();
+        }
+
+        /// <inheritdoc />
+        protected override IEnumerable<IConsent> PerformGetByQuery(IQuery<IConsent> query)
+        {
+            var sqlClause = new Sql().Select("*").From<ConsentDto>(SqlSyntax);
+            var translator = new SqlTranslator<IConsent>(sqlClause, query);
+            var sql = translator.Translate().OrderByDescending<ConsentDto>(x => x.CreateDate, SqlSyntax);
+            return ConsentFactory.BuildEntities(Database.Fetch<ConsentDto>(sql));
+        }
+
+        /// <inheritdoc />
+        protected override Sql GetBaseQuery(bool isCount)
+        {
+            throw new NotImplementedException();
+        }
+
+        /// <inheritdoc />
+        protected override string GetBaseWhereClause()
+        {
+            throw new NotImplementedException();
+        }
+
+        /// <inheritdoc />
+        protected override IEnumerable<string> GetDeleteClauses()
+        {
+            throw new NotImplementedException();
+        }
+
+        /// <inheritdoc />
+        protected override void PersistNewItem(IConsent entity)
+        {
+            ((Entity) entity).AddingEntity();
+
+            var dto = ConsentFactory.BuildDto(entity);
+            Database.Insert(dto);
+            entity.Id = dto.Id;
+            entity.ResetDirtyProperties();
+        }
+
+        /// <inheritdoc />
+        protected override void PersistUpdatedItem(IConsent entity)
+        {
+            ((Entity) entity).UpdatingEntity();
+
+            var dto = ConsentFactory.BuildDto(entity);
+            Database.Update(dto);
+            entity.ResetDirtyProperties();
+
+            IsolatedCache.ClearCacheItem(GetCacheIdKey<IConsent>(entity.Id));
+        }
+    }
+}

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

@@ -0,0 +1,22 @@
+using System.Collections.Generic;
+using Umbraco.Core.Models;
+
+namespace Umbraco.Core.Persistence.Repositories
+{
+    /// <summary>
+    /// Represents a repository for <see cref="IAuditEntry"/> entities.
+    /// </summary>
+    public interface IAuditEntryRepository : IRepositoryQueryable<int, IAuditEntry>
+    {
+        /// <summary>
+        /// Gets a page of entries.
+        /// </summary>
+        IEnumerable<IAuditEntry> GetPage(long pageIndex, int pageCount, out long records);
+
+        /// <summary>
+        /// Determines whether the repository is available.
+        /// </summary>
+        /// <remarks>During an upgrade, the repository may not be available, until the table has been created.</remarks>
+        bool IsAvailable();
+    }
+}

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

@@ -0,0 +1,15 @@
+using Umbraco.Core.Models;
+
+namespace Umbraco.Core.Persistence.Repositories
+{
+    /// <summary>
+    /// Represents a repository for <see cref="IConsent"/> entities.
+    /// </summary>
+    public interface IConsentRepository : IRepositoryQueryable<int, IConsent>
+    {
+        /// <summary>
+        /// Clears the current flag.
+        /// </summary>
+        void ClearCurrent(string source, string context, string action);
+    }
+}

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

@@ -39,5 +39,7 @@ namespace Umbraco.Core.Persistence.Repositories
         void AssignRoles(int[] memberIds, string[] roleNames);
 
         void DissociateRoles(int[] memberIds, string[] roleNames);
+
+        int[] GetMemberIds(string[] names);
     }
-}
+}

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

@@ -183,7 +183,7 @@ namespace Umbraco.Core.Persistence.Repositories
         }
 
         public IEnumerable<IMemberGroup> GetMemberGroupsForMember(string username)
-        {
+        {
             var sql = new Sql()
                 .Select("un.*")
                 .From("umbracoNode AS un")
@@ -192,16 +192,15 @@ namespace Umbraco.Core.Persistence.Repositories
                 .InnerJoin("cmsMember")
                 .On("cmsMember.nodeId = cmsMember2MemberGroup.Member")
                 .Where("un.nodeObjectType=@objectType", new { objectType = NodeObjectTypeId })
-                .Where("cmsMember.LoginName=@loginName", new { loginName = username });
-            
+                .Where("cmsMember.LoginName=@loginName", new { loginName = username });
+            
             return Database.Fetch<NodeDto>(sql)
                 .DistinctBy(dto => dto.NodeId)
                 .Select(x => _modelFactory.BuildEntity(x));
         }
 
-        public void AssignRoles(string[] usernames, string[] roleNames)
+        public int[] GetMemberIds(string[] names)
         {
-            //first get the member ids based on the usernames
             var memberSql = new Sql();
             var memberObjectType = new Guid(Constants.ObjectTypes.Member);
             memberSql.Select("umbracoNode.id")
@@ -209,25 +208,19 @@ namespace Umbraco.Core.Persistence.Repositories
                 .InnerJoin<MemberDto>()
                 .On<NodeDto, MemberDto>(dto => dto.NodeId, dto => dto.NodeId)
                 .Where<NodeDto>(x => x.NodeObjectType == memberObjectType)
-                .Where("cmsMember.LoginName in (@usernames)", new { usernames = usernames });
-            var memberIds = Database.Fetch<int>(memberSql).ToArray();
+                .Where("cmsMember.LoginName in (@names)", new { names });
+            return Database.Fetch<int>(memberSql).ToArray();
+        }
 
+        public void AssignRoles(string[] usernames, string[] roleNames)
+        {
+            var memberIds = GetMemberIds(usernames);
             AssignRolesInternal(memberIds, roleNames);            
         }
 
         public void DissociateRoles(string[] usernames, string[] roleNames)
         {
-            //first get the member ids based on the usernames
-            var memberSql = new Sql();
-            var memberObjectType = new Guid(Constants.ObjectTypes.Member);
-            memberSql.Select("umbracoNode.id")
-                .From<NodeDto>()
-                .InnerJoin<MemberDto>()
-                .On<NodeDto, MemberDto>(dto => dto.NodeId, dto => dto.NodeId)
-                .Where<NodeDto>(x => x.NodeObjectType == memberObjectType)
-                .Where("cmsMember.LoginName in (@usernames)", new { usernames = usernames });
-            var memberIds = Database.Fetch<int>(memberSql).ToArray();
-
+            var memberIds = GetMemberIds(usernames);
             DissociateRolesInternal(memberIds, roleNames);
         }
 
@@ -337,4 +330,4 @@ namespace Umbraco.Core.Persistence.Repositories
         /// </summary>
         internal static event TypedEventHandler<IMemberGroupRepository, SaveEventArgs<IMemberGroup>> SavedMemberGroup;
     }
-}
+}

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

@@ -90,7 +90,8 @@ namespace Umbraco.Core.Persistence.Repositories
             sql.Select("umbracoNode.*", "cmsContentType.*", "cmsPropertyType.id AS PropertyTypeId", "cmsPropertyType.Alias",
                 "cmsPropertyType.Name", "cmsPropertyType.Description", "cmsPropertyType.mandatory", "cmsPropertyType.UniqueID",
                 "cmsPropertyType.validationRegExp", "cmsPropertyType.dataTypeId", "cmsPropertyType.sortOrder AS PropertyTypeSortOrder",
-                "cmsPropertyType.propertyTypeGroupId AS PropertyTypesGroupId", "cmsMemberType.memberCanEdit", "cmsMemberType.viewOnProfile",
+                "cmsPropertyType.propertyTypeGroupId AS PropertyTypesGroupId",
+                "cmsMemberType.memberCanEdit", "cmsMemberType.viewOnProfile", "cmsMemberType.isSensitive",
                 "cmsDataType.propertyEditorAlias", "cmsDataType.dbType", "cmsPropertyTypeGroup.id AS PropertyTypeGroupId", 
                 "cmsPropertyTypeGroup.text AS PropertyGroupName", "cmsPropertyTypeGroup.uniqueID AS PropertyGroupUniqueID",
                 "cmsPropertyTypeGroup.sortorder AS PropertyGroupSortOrder", "cmsPropertyTypeGroup.contenttypeNodeId")
@@ -362,4 +363,4 @@ namespace Umbraco.Core.Persistence.Repositories
             return Attempt<Guid>.Fail(propertyEditor);
         }
     }
-}
+}

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

@@ -308,6 +308,9 @@ namespace Umbraco.Core.Persistence.Repositories
         public virtual void PersistNewItem(IEntity entity)
         {
             CachePolicy.Create((TEntity) entity, PersistNewItem);
+
+            //TODO: In v8 we should automatically reset dirty properties so they don't have to be manually reset in all of the implemented repositories
+            //if (entity is ICanBeDirty dirty) dirty.ResetDirtyProperties();
         }
 
         /// <summary>
@@ -317,6 +320,8 @@ namespace Umbraco.Core.Persistence.Repositories
         public virtual void PersistUpdatedItem(IEntity entity)
         {
             CachePolicy.Update((TEntity) entity, PersistUpdatedItem);
+            //TODO: In v8 we should automatically reset dirty properties so they don't have to be manually reset in all of the implemented repositories
+            //if (entity is ICanBeDirty dirty) dirty.ResetDirtyProperties();
         }
 
         /// <summary>
@@ -343,4 +348,4 @@ namespace Umbraco.Core.Persistence.Repositories
             UnitOfWork.DisposeIfDisposable();
         }
     }
-}
+}

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/UserGroupRepository.cs

@@ -285,7 +285,7 @@ umbracoUserGroup.userGroupName, umbracoUserGroup2App.app, umbracoUserGroup2App.u
 
         protected override void PersistNewItem(IUserGroup entity)
         {
-            ((UserGroup)entity).AddingEntity();            
+            ((UserGroup)entity).AddingEntity();
 
             var userGroupDto = UserGroupFactory.BuildDto(entity);
 
@@ -293,6 +293,8 @@ umbracoUserGroup.userGroupName, umbracoUserGroup2App.app, umbracoUserGroup2App.u
             entity.Id = id;
 
             PersistAllowedSections(entity);
+
+            entity.ResetDirtyProperties();
         }
 
         protected override void PersistUpdatedItem(IUserGroup entity)
@@ -304,6 +306,8 @@ umbracoUserGroup.userGroupName, umbracoUserGroup2App.app, umbracoUserGroup2App.u
             Database.Update(userGroupDto);
 
             PersistAllowedSections(entity);
+
+            entity.ResetDirtyProperties();
         }
 
         private void PersistAllowedSections(IUserGroup entity)
@@ -456,4 +460,4 @@ umbracoUserGroup.userGroupName, umbracoUserGroup2App.app, umbracoUserGroup2App.u
             }
         }
     }
-}
+}

src/Umbraco.Core/Persistence/RepositoryFactory.cs

@@ -54,8 +54,8 @@ namespace Umbraco.Core.Persistence
 
                     //if the result is already a DeepCloneRuntimeCacheProvider then return it, otherwise
                     //wrap the result with a DeepCloneRuntimeCacheProvider
-                    return cache is DeepCloneRuntimeCacheProvider 
-                        ? cache 
+                    return cache is DeepCloneRuntimeCacheProvider
+                        ? cache
                         : new DeepCloneRuntimeCacheProvider(cache);
                 };
             }
@@ -158,11 +158,11 @@ namespace Umbraco.Core.Persistence
                 CreateTemplateRepository(uow),
                 CreateTagRepository(uow),
                 _settings.Content)
-            {
+            {
                 //duplicates are allowed
                 EnsureUniqueNaming = false
             };
-        }
+        }
 
         public virtual IContentTypeRepository CreateContentTypeRepository(IScopeUnitOfWork uow)
         {
@@ -319,13 +319,13 @@ namespace Umbraco.Core.Persistence
             var userMembershipProvider = MembershipProviderExtensions.GetUsersMembershipProvider();
             var passwordConfig = userMembershipProvider == null || userMembershipProvider.PasswordFormat != MembershipPasswordFormat.Hashed
                 ? null
-                : new System.Collections.Generic.Dictionary<string, string> {{"hashAlgorithm", Membership.HashAlgorithmType}};
+                : new System.Collections.Generic.Dictionary<string, string> {{"hashAlgorithm", Membership.HashAlgorithmType}};
 
             return new UserRepository(
                 uow,
                 //Need to cache users - we look up user information more than anything in the back office!
                 _cacheHelper,
-                _logger, 
+                _logger,
                 _sqlSyntax,
                 passwordConfig);
         }
@@ -397,5 +397,15 @@ namespace Umbraco.Core.Persistence
                 _logger,
                 _sqlSyntax);
         }
+
+        public IConsentRepository CreateConsentRepository(IScopeUnitOfWork uow)
+        {
+            return new ConsentRepository(uow, _cacheHelper, _logger, _sqlSyntax);
+        }
+
+        public IAuditEntryRepository CreateAuditEntryRepository(IScopeUnitOfWork uow)
+        {
+            return new AuditEntryRepository(uow, _cacheHelper, _logger, _sqlSyntax);
+        }
     }
 }

src/Umbraco.Core/PropertyEditors/PropertyEditorResolver.cs

@@ -21,7 +21,7 @@ namespace Umbraco.Core.PropertyEditors
         public PropertyEditorResolver(IServiceProvider serviceProvider, ILogger logger, Func<IEnumerable<Type>> typeListProducerList, IRuntimeCacheProvider runtimeCache)
             : base(serviceProvider, logger, typeListProducerList, ObjectLifetimeScope.Application)
         {
-        	var builder = new ManifestBuilder(
+            var builder = new ManifestBuilder(
                 runtimeCache,
                 new ManifestParser(new DirectoryInfo(IOHelper.MapPath("~/App_Plugins")), runtimeCache));
 
@@ -49,7 +49,10 @@ namespace Umbraco.Core.PropertyEditors
         {
             var nestedContentEditorFromPackage = editors.FirstOrDefault(x => x.Alias == "Our.Umbraco.NestedContent");
             if (nestedContentEditorFromPackage != null)
+            {
                 nestedContentEditorFromPackage.Name = "(Obsolete) " + nestedContentEditorFromPackage.Name;
+                nestedContentEditorFromPackage.IsDeprecated = true;
+            }
             return editors;
 
         }
@@ -74,4 +77,4 @@ namespace Umbraco.Core.PropertyEditors
             return PropertyEditors.SingleOrDefault(x => x.Alias == alias);
         }
     }
-}
+}

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/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/Security/BackOfficeUserManager.cs

@@ -420,6 +420,33 @@ namespace Umbraco.Core.Security
             return await base.CheckPasswordAsync(user, password);
         }
 
+        public override Task<IdentityResult> ResetPasswordAsync(int userId, string token, string newPassword)
+        {
+            var result = base.ResetPasswordAsync(userId, token, newPassword);
+            if (result.Result.Succeeded)
+                RaisePasswordResetEvent(userId);
+            return result;
+        }
+
+        /// <summary>
+        /// This is a special method that will reset the password but will raise the Password Changed event instead of the reset event
+        /// </summary>
+        /// <param name="userId"></param>
+        /// <param name="token"></param>
+        /// <param name="newPassword"></param>
+        /// <returns></returns>
+        /// <remarks>
+        /// We use this because in the back office the only way an admin can change another user's password without first knowing their password
+        /// is to generate a token and reset it, however, when we do this we want to track a password change, not a password reset
+        /// </remarks>
+        public Task<IdentityResult> ChangePasswordWithResetAsync(int userId, string token, string newPassword)
+        {
+            var result = base.ResetPasswordAsync(userId, token, newPassword);
+            if (result.Result.Succeeded)
+                RaisePasswordChangedEvent(userId);
+            return result;
+        }
+
         public override Task<IdentityResult> ChangePasswordAsync(int userId, string currentPassword, string newPassword)
         {
             var result = base.ChangePasswordAsync(userId, currentPassword, newPassword);
@@ -554,27 +581,27 @@ namespace Umbraco.Core.Security
 
         internal void RaiseAccountLockedEvent(int userId)
         {
-            OnAccountLocked(new IdentityAuditEventArgs(AuditEvent.AccountLocked, GetCurrentRequestIpAddress(), userId));
+            OnAccountLocked(new IdentityAuditEventArgs(AuditEvent.AccountLocked, GetCurrentRequestIpAddress(), affectedUser: userId));
         }
 
         internal void RaiseAccountUnlockedEvent(int userId)
         {
-            OnAccountUnlocked(new IdentityAuditEventArgs(AuditEvent.AccountUnlocked, GetCurrentRequestIpAddress(), userId));
+            OnAccountUnlocked(new IdentityAuditEventArgs(AuditEvent.AccountUnlocked, GetCurrentRequestIpAddress(), affectedUser: userId));
         }
 
         internal void RaiseForgotPasswordRequestedEvent(int userId)
         {
-            OnForgotPasswordRequested(new IdentityAuditEventArgs(AuditEvent.ForgotPasswordRequested, GetCurrentRequestIpAddress(), userId));
+            OnForgotPasswordRequested(new IdentityAuditEventArgs(AuditEvent.ForgotPasswordRequested, GetCurrentRequestIpAddress(), affectedUser: userId));
         }
 
         internal void RaiseForgotPasswordChangedSuccessEvent(int userId)
         {
-            OnForgotPasswordChangedSuccess(new IdentityAuditEventArgs(AuditEvent.ForgotPasswordChangedSuccess, GetCurrentRequestIpAddress(), userId));
+            OnForgotPasswordChangedSuccess(new IdentityAuditEventArgs(AuditEvent.ForgotPasswordChangedSuccess, GetCurrentRequestIpAddress(), affectedUser: userId));
         }
 
         internal void RaiseLoginFailedEvent(int userId)
         {
-            OnLoginFailed(new IdentityAuditEventArgs(AuditEvent.LoginFailed, GetCurrentRequestIpAddress(), userId));
+            OnLoginFailed(new IdentityAuditEventArgs(AuditEvent.LoginFailed, GetCurrentRequestIpAddress(), affectedUser: userId));
         }
 
         internal void RaiseInvalidLoginAttemptEvent(string username)
@@ -584,31 +611,33 @@ namespace Umbraco.Core.Security
 
         internal void RaiseLoginRequiresVerificationEvent(int userId)
         {
-            OnLoginRequiresVerification(new IdentityAuditEventArgs(AuditEvent.LoginRequiresVerification, GetCurrentRequestIpAddress(), userId));
+            OnLoginRequiresVerification(new IdentityAuditEventArgs(AuditEvent.LoginRequiresVerification, GetCurrentRequestIpAddress(), affectedUser: userId));
         }
 
         internal void RaiseLoginSuccessEvent(int userId)
         {
-            OnLoginSuccess(new IdentityAuditEventArgs(AuditEvent.LoginSucces, GetCurrentRequestIpAddress(), userId));
+            OnLoginSuccess(new IdentityAuditEventArgs(AuditEvent.LoginSucces, GetCurrentRequestIpAddress(), affectedUser: userId));
         }
 
         internal void RaiseLogoutSuccessEvent(int userId)
         {
-            OnLogoutSuccess(new IdentityAuditEventArgs(AuditEvent.LogoutSuccess, GetCurrentRequestIpAddress(), userId));
+            OnLogoutSuccess(new IdentityAuditEventArgs(AuditEvent.LogoutSuccess, GetCurrentRequestIpAddress(), affectedUser: userId));
         }
 
         internal void RaisePasswordChangedEvent(int userId)
         {
-            OnPasswordChanged(new IdentityAuditEventArgs(AuditEvent.PasswordChanged, GetCurrentRequestIpAddress(), userId));
+            OnPasswordChanged(new IdentityAuditEventArgs(AuditEvent.PasswordChanged, GetCurrentRequestIpAddress(), affectedUser: userId));
         }
 
+        //TODO: I don't think this is required anymore since from 7.7 we no longer display the reset password checkbox since that didn't make sense.
         internal void RaisePasswordResetEvent(int userId)
         {
-            OnPasswordReset(new IdentityAuditEventArgs(AuditEvent.PasswordReset, GetCurrentRequestIpAddress(), userId));
+            OnPasswordReset(new IdentityAuditEventArgs(AuditEvent.PasswordReset, GetCurrentRequestIpAddress(), affectedUser: userId));
         }
+
         internal void RaiseResetAccessFailedCountEvent(int userId)
         {
-            OnResetAccessFailedCount(new IdentityAuditEventArgs(AuditEvent.ResetAccessFailedCount, GetCurrentRequestIpAddress(), userId));
+            OnResetAccessFailedCount(new IdentityAuditEventArgs(AuditEvent.ResetAccessFailedCount, GetCurrentRequestIpAddress(), affectedUser: userId));
         }
 
         public static event EventHandler AccountLocked;

src/Umbraco.Core/Services/AuditService.cs

@@ -4,6 +4,7 @@ using System.Linq;
 using Umbraco.Core.Events;
 using Umbraco.Core.Logging;
 using Umbraco.Core.Models;
+using Umbraco.Core.Models.Rdbms;
 using Umbraco.Core.Persistence;
 using Umbraco.Core.Persistence.DatabaseModelDefinitions;
 using Umbraco.Core.Persistence.Querying;
@@ -13,9 +14,13 @@ namespace Umbraco.Core.Services
 {
     public sealed class AuditService : ScopeRepositoryService, IAuditService
     {
+        private readonly Lazy<bool> _isAvailable;
+
         public AuditService(IDatabaseUnitOfWorkProvider provider, RepositoryFactory repositoryFactory, ILogger logger, IEventMessagesFactory eventMessagesFactory)
             : base(provider, repositoryFactory, logger, eventMessagesFactory)
-        { }
+        {
+            _isAvailable = new Lazy<bool>(DetermineIsAvailable);
+        }
 
         public void Add(AuditType type, string comment, int userId, int objectId)
         {
@@ -107,5 +112,90 @@ namespace Umbraco.Core.Services
                 return repository.GetPagedResultsByQuery(query, pageIndex, pageSize, out totalRecords, orderDirection, auditTypeFilter, customFilter);
             }
         }
+
+        /// <inheritdoc />
+        public IAuditEntry Write(int performingUserId, string perfomingDetails, string performingIp, DateTime eventDateUtc, int affectedUserId, string affectedDetails, string eventType, string eventDetails)
+        {
+            if (performingUserId < 0) throw new ArgumentOutOfRangeException(nameof(performingUserId));
+            if (string.IsNullOrWhiteSpace(perfomingDetails)) throw new ArgumentException("Value cannot be null or whitespace.", nameof(perfomingDetails));
+            if (string.IsNullOrWhiteSpace(eventType)) throw new ArgumentException("Value cannot be null or whitespace.", nameof(eventType));
+            if (string.IsNullOrWhiteSpace(eventDetails)) throw new ArgumentException("Value cannot be null or whitespace.", nameof(eventDetails));
+
+            //we need to truncate the data else we'll get SQL errors
+            affectedDetails = affectedDetails?.Substring(0, Math.Min(affectedDetails.Length, AuditEntryDto.DetailsLength));
+            eventDetails = eventDetails.Substring(0, Math.Min(eventDetails.Length, AuditEntryDto.DetailsLength));
+
+            //validate the eventType - must contain a forward slash, no spaces, no special chars
+            var eventTypeParts = eventType.ToCharArray();
+            if (eventTypeParts.Contains('/') == false || eventTypeParts.All(c => char.IsLetterOrDigit(c) || c == '/' || c == '-') == false)
+                throw new ArgumentException(nameof(eventType) + " must contain only alphanumeric characters, hyphens and at least one '/' defining a category");
+            if (eventType.Length > AuditEntryDto.EventTypeLength)
+                throw new ArgumentException($"Must be max {AuditEntryDto.EventTypeLength} chars.", nameof(eventType));
+            if (performingIp != null && performingIp.Length > AuditEntryDto.IpLength)
+                throw new ArgumentException($"Must be max {AuditEntryDto.EventTypeLength} chars.", nameof(performingIp));
+
+            var entry = new AuditEntry
+            {
+                PerformingUserId = performingUserId,
+                PerformingDetails = perfomingDetails,
+                PerformingIp = performingIp,
+                EventDateUtc = eventDateUtc,
+                AffectedUserId = affectedUserId,
+                AffectedDetails = affectedDetails,
+                EventType = eventType,
+                EventDetails = eventDetails
+            };
+
+            if (_isAvailable.Value == false) return entry;
+
+            using (var uow = UowProvider.GetUnitOfWork())
+            {
+                var repository = RepositoryFactory.CreateAuditEntryRepository(uow);
+                repository.AddOrUpdate(entry);
+                uow.Commit();
+            }
+
+            return entry;
+        }
+
+        //TODO: Currently used in testing only, not part of the interface, need to add queryable methods to the interface instead
+        internal IEnumerable<IAuditEntry> GetAll()
+        {
+            if (_isAvailable.Value == false) return Enumerable.Empty<IAuditEntry>();
+
+            using (var uow = UowProvider.GetUnitOfWork(readOnly: true))
+            {
+                var repository = RepositoryFactory.CreateAuditEntryRepository(uow);
+                return repository.GetAll();
+            }
+        }
+
+        //TODO: Currently used in testing only, not part of the interface, need to add queryable methods to the interface instead
+        internal IEnumerable<IAuditEntry> GetPage(long pageIndex, int pageCount, out long records)
+        {
+            if (_isAvailable.Value == false)
+            {
+                records = 0;
+                return Enumerable.Empty<IAuditEntry>();
+            }
+
+            using (var uow = UowProvider.GetUnitOfWork(readOnly: true))
+            {
+                var repository = RepositoryFactory.CreateAuditEntryRepository(uow);
+                return repository.GetPage(pageIndex, pageCount, out records);
+            }
+        }
+
+        /// <summary>
+        /// Determines whether the repository is available.
+        /// </summary>
+        private bool DetermineIsAvailable()
+        {
+            using (var uow = UowProvider.GetUnitOfWork(readOnly: true))
+            {
+                var repository = RepositoryFactory.CreateAuditEntryRepository(uow);
+                return repository.IsAvailable();
+            }
+        }
     }
-}
+}

src/Umbraco.Core/Services/ConsentService.cs

@@ -0,0 +1,81 @@
+using System;
+using System.Collections.Generic;
+using Umbraco.Core.Events;
+using Umbraco.Core.Logging;
+using Umbraco.Core.Models;
+using Umbraco.Core.Persistence;
+using Umbraco.Core.Persistence.Querying;
+using Umbraco.Core.Persistence.UnitOfWork;
+
+namespace Umbraco.Core.Services
+{
+    /// <summary>
+    /// Implements <see cref="IContentService"/>.
+    /// </summary>
+    internal class ConsentService : ScopeRepositoryService, IConsentService
+    {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="ContentService"/> class.
+        /// </summary>
+        public ConsentService(IScopeUnitOfWorkProvider provider, RepositoryFactory repositoryFactory, ILogger logger, IEventMessagesFactory eventMessagesFactory)
+            : base(provider, repositoryFactory, logger, eventMessagesFactory)
+        { }
+
+        /// <inheritdoc />
+        public IConsent RegisterConsent(string source, string context, string action, ConsentState state, string comment = null)
+        {
+            // prevent stupid states
+            var v = 0;
+            if ((state & ConsentState.Pending) > 0) v++;
+            if ((state & ConsentState.Granted) > 0) v++;
+            if ((state & ConsentState.Revoked) > 0) v++;
+            if (v != 1)
+                throw new ArgumentException("Invalid state.", nameof(state));
+
+            var consent = new Consent
+            {
+                Current = true,
+                Source = source,
+                Context = context,
+                Action = action,
+                CreateDate = DateTime.Now,
+                State = state,
+                Comment = comment
+            };
+
+            using (var uow = UowProvider.GetUnitOfWork())
+            {
+                var repository = RepositoryFactory.CreateConsentRepository(uow);
+                repository.ClearCurrent(source, context, action);
+                repository.AddOrUpdate(consent);
+                uow.Commit();
+            }
+
+            return consent;
+        }
+
+        /// <inheritdoc />
+        public IEnumerable<IConsent> LookupConsent(string source = null, string context = null, string action = null,
+            bool sourceStartsWith = false, bool contextStartsWith = false, bool actionStartsWith = false,
+            bool includeHistory = false)
+        {
+            using (var uow = UowProvider.GetUnitOfWork(readOnly: true))
+            {
+                var repository = RepositoryFactory.CreateConsentRepository(uow);
+
+                IQuery<IConsent> query = new Query<IConsent>();
+
+                if (string.IsNullOrWhiteSpace(source) == false)
+                    query = sourceStartsWith ? query.Where(x => x.Source.StartsWith(source)) : query.Where(x => x.Source == source);
+                if (string.IsNullOrWhiteSpace(context) == false)
+                    query = contextStartsWith ? query.Where(x => x.Context.StartsWith(context)) : query.Where(x => x.Context == context);
+                if (string.IsNullOrWhiteSpace(action) == false)
+                    query = actionStartsWith ? query.Where(x => x.Action.StartsWith(action)) : query.Where(x => x.Action == action);
+                if (includeHistory == false)
+                    query = query.Where(x => x.Current);
+
+                return repository.GetByQuery(query);
+            }
+        }
+    }
+}

src/Umbraco.Core/Services/ContentService.cs

@@ -692,7 +692,7 @@ namespace Umbraco.Core.Services
                         totalChildren = 0;
                         return Enumerable.Empty<IContent>();
                     }
-                    query.Where(x => x.Path.SqlStartsWith(string.Format("{0},", contentPath[0]), TextColumnType.NVarchar));
+                    query.Where(x => x.Path.SqlStartsWith(string.Format("{0},", contentPath[0].Path), TextColumnType.NVarchar));
                 }
                     
 
@@ -737,7 +737,7 @@ namespace Umbraco.Core.Services
                         totalChildren = 0;
                         return Enumerable.Empty<IContent>();
                     }
-                    query.Where(x => x.Path.SqlStartsWith(string.Format("{0},", contentPath[0]), TextColumnType.NVarchar));
+                    query.Where(x => x.Path.SqlStartsWith(string.Format("{0},", contentPath[0].Path), TextColumnType.NVarchar));
                 }
 
                 return repository.GetPagedResultsByQuery(query, pageIndex, pageSize, out totalChildren, orderBy, orderDirection, orderBySystemField, filter);
@@ -884,8 +884,8 @@ namespace Umbraco.Core.Services
             using (var uow = UowProvider.GetUnitOfWork(readOnly: true))
             {
                 var repository = RepositoryFactory.CreateContentRepository(uow);
-                var query = Query<IContent>.Builder.Where(x => x.Published && x.ExpireDate <= DateTime.Now);
-                return repository.GetByQuery(query);
+                var query = Query<IContent>.Builder.Where(x => x.ExpireDate <= DateTime.Now);
+                return repository.GetByQuery(query).Where(x => x.HasPublishedVersion);
             }
         }
 
@@ -912,13 +912,11 @@ namespace Umbraco.Core.Services
             using (var uow = UowProvider.GetUnitOfWork(readOnly: true))
             {
                 var repository = RepositoryFactory.CreateContentRepository(uow);
-                var query = Query<IContent>.Builder.Where(x => x.Path.Contains(Constants.System.RecycleBinContent.ToInvariantString()));
+                var query = Query<IContent>.Builder.Where(x => x.Path.StartsWith(Constants.System.RecycleBinContentPathPrefix));
                 return repository.GetByQuery(query);
             }
         }
 
-
-
         /// <summary>
         /// Checks whether an <see cref="IContent"/> item has any children
         /// </summary>
@@ -1344,6 +1342,40 @@ namespace Umbraco.Core.Services
             return content;
         }
 
+        public void DeleteBlueprintsOfTypes(IEnumerable<int> contentTypeIds, int userId = 0)
+        {
+            using (new WriteLock(Locker))
+            using (var uow = UowProvider.GetUnitOfWork())
+            {
+                var repository = RepositoryFactory.CreateContentBlueprintRepository(uow);
+
+                var contentTypeIdsA = contentTypeIds.ToArray();
+                var query = new Query<IContent>();
+                if (contentTypeIdsA.Length > 0)
+                {
+                    query.Where(x => contentTypeIdsA.Contains(x.ContentTypeId));
+                }
+                var blueprints = repository.GetByQuery(query).Select(x =>
+                {
+                    ((Content) x).IsBlueprint = true;
+                    return x;
+                }).ToArray();
+
+                foreach (var blueprint in blueprints)
+                {
+                    repository.Delete(blueprint);
+                }
+
+                uow.Events.Dispatch(DeletedBlueprint, this, new DeleteEventArgs<IContent>(blueprints), "DeletedBlueprint");
+                uow.Commit();
+            }
+        }
+
+        public void DeleteBlueprintsOfType(int contentTypeId, int userId = 0)
+        {
+            DeleteBlueprintsOfTypes(new[] {contentTypeId}, userId);
+        }
+
         /// <summary>
         /// Saves a single <see cref="IContent"/> object
         /// </summary>

src/Umbraco.Core/Services/ContentTypeService.cs

@@ -920,7 +920,9 @@ namespace Umbraco.Core.Services
                     var deletedContentTypes = new List<IContentType> { contentType };
                     deletedContentTypes.AddRange(GetDescendants(contentType));
 
-                    _contentService.DeleteContentOfTypes(deletedContentTypes.Select(x => x.Id), userId);
+                    var ids = deletedContentTypes.Select(x => x.Id).ToArray();
+                    _contentService.DeleteContentOfTypes(ids, userId);
+                    _contentService.DeleteBlueprintsOfTypes(ids);
 
                     repository.Delete(contentType);
                     deleteEventArgs.DeletedEntities = deletedContentTypes.DistinctBy(x => x.Id);

src/Umbraco.Core/Services/IAuditService.cs

@@ -1,10 +1,15 @@
+using System;
 using System.Collections.Generic;
+using System.Linq;
 using Umbraco.Core.Models;
 using Umbraco.Core.Persistence.DatabaseModelDefinitions;
 using Umbraco.Core.Persistence.Querying;
 
 namespace Umbraco.Core.Services
 {
+    /// <summary>
+    /// Represents a service for handling audit.
+    /// </summary>
     public interface IAuditService : IService
     {
         void Add(AuditType type, string comment, int userId, int objectId);
@@ -54,5 +59,25 @@ namespace Umbraco.Core.Services
             Direction orderDirection = Direction.Descending,
             AuditType[] auditTypeFilter = null,
             IQuery<IAuditItem> customFilter = null);
+
+        /// <summary>
+        /// Writes an audit entry for an audited event.
+        /// </summary>
+        /// <param name="performingUserId">The identifier of the user triggering the audited event.</param>
+        /// <param name="perfomingDetails">Free-form details about the user triggering the audited event.</param>
+        /// <param name="performingIp">The IP address or the request triggering the audited event.</param>
+        /// <param name="eventDateUtc">The date and time of the audited event.</param>
+        /// <param name="affectedUserId">The identifier of the user affected by the audited event.</param>
+        /// <param name="affectedDetails">Free-form details about the entity affected by the audited event.</param>
+        /// <param name="eventType">
+        /// The type of the audited event - must contain only alphanumeric chars and hyphens with forward slashes separating categories.
+        /// <example>
+        /// The eventType will generally be formatted like: {application}/{entity-type}/{category}/{sub-category}
+        /// Example: umbraco/user/sign-in/failed
+        /// </example>
+        /// </param>
+        /// <param name="eventDetails">Free-form details about the audited event.</param>
+        IAuditEntry Write(int performingUserId, string perfomingDetails, string performingIp, DateTime eventDateUtc, int affectedUserId, string affectedDetails, string eventType, string eventDetails);
+        
     }
-}
+}

src/Umbraco.Core/Services/IConsentService.cs

@@ -0,0 +1,45 @@
+using System.Collections.Generic;
+using Umbraco.Core.Models;
+
+namespace Umbraco.Core.Services
+{
+    /// <summary>
+    /// A service for handling lawful data processing requirements
+    /// </summary>
+    /// <remarks>
+    /// <para>Consent can be given or revoked or changed via the <see cref="RegisterConsent"/> method, which
+    /// creates a new <see cref="IConsent"/> entity to track the consent. Revoking a consent is performed by
+    /// registering a revoked consent.</para>
+    /// <para>A consent can be revoked, by registering a revoked consent, but cannot be deleted.</para>
+    /// <para>Getter methods return the current state of a consent, i.e. the latest <see cref="IConsent"/>
+    /// entity that was created.</para>
+    /// </remarks>
+    public interface IConsentService : IService
+    {
+        /// <summary>
+        /// Registers consent.
+        /// </summary>
+        /// <param name="source">The source, i.e. whoever is consenting.</param>
+        /// <param name="context"></param>
+        /// <param name="action"></param>
+        /// <param name="state">The state of the consent.</param>
+        /// <param name="comment">Additional free text.</param>
+        /// <returns>The corresponding consent entity.</returns>
+        IConsent RegisterConsent(string source, string context, string action, ConsentState state, string comment = null);
+
+        /// <summary>
+        /// Retrieves consents.
+        /// </summary>
+        /// <param name="source">The optional source.</param>
+        /// <param name="context">The optional context.</param>
+        /// <param name="action">The optional action.</param>
+        /// <param name="sourceStartsWith">Determines whether <paramref name="source"/> is a start pattern.</param>
+        /// <param name="contextStartsWith">Determines whether <paramref name="context"/> is a start pattern.</param>
+        /// <param name="actionStartsWith">Determines whether <paramref name="action"/> is a start pattern.</param>
+        /// <param name="includeHistory">Determines whether to include the history of consents.</param>
+        /// <returns>Consents matching the paramters.</returns>
+        IEnumerable<IConsent> LookupConsent(string source = null, string context = null, string action = null,
+            bool sourceStartsWith = false, bool contextStartsWith = false, bool actionStartsWith = false,
+            bool includeHistory = false);
+    }
+}

src/Umbraco.Core/Services/IContentService.cs

@@ -101,7 +101,9 @@ namespace Umbraco.Core.Services
         IContent GetBlueprintById(Guid id);
         void SaveBlueprint(IContent content, int userId = 0);
         void DeleteBlueprint(IContent content, int userId = 0);
-        IContent CreateContentFromBlueprint(IContent blueprint, string name, int userId = 0);
+        IContent CreateContentFromBlueprint(IContent blueprint, string name, int userId = 0);
+        void DeleteBlueprintsOfType(int contentTypeId, int userId = 0);
+        void DeleteBlueprintsOfTypes(IEnumerable<int> contentTypeIds, int userId = 0);
 
         /// <summary>
         /// Gets all XML entries found in the cmsContentXml table based on the given path

src/Umbraco.Core/Services/IMemberService.cs

@@ -1,6 +1,7 @@
 using System;
 using System.Collections.Generic;
 using System.ComponentModel;
+using System.Net.Http;
 using System.Xml.Linq;
 using Umbraco.Core.Models;
 using Umbraco.Core.Models.Membership;
@@ -198,7 +199,7 @@ namespace Umbraco.Core.Services
         /// </summary>
         /// <param name="memberTypeId">Id of the MemberType</param>
         void DeleteMembersOfType(int memberTypeId);
-
+        
         [Obsolete("Use the overload with 'long' parameter types instead")]
         [EditorBrowsable(EditorBrowsableState.Never)]
         IEnumerable<IMember> FindMembersByDisplayName(string displayNameToMatch, int pageIndex, int pageSize, out int totalRecords, StringPropertyMatchType matchType = StringPropertyMatchType.StartsWith);
@@ -249,4 +250,4 @@ namespace Umbraco.Core.Services
         /// <returns><see cref="IEnumerable{IMember}"/></returns>
         IEnumerable<IMember> GetMembersByPropertyValue(string propertyTypeAlias, DateTime value, ValuePropertyMatchType matchType = ValuePropertyMatchType.Exact);
     }
-}
+}

src/Umbraco.Core/Services/MediaService.cs

@@ -389,7 +389,7 @@ namespace Umbraco.Core.Services
             using (var uow = UowProvider.GetUnitOfWork(readOnly: true))
             {
                 var repository = RepositoryFactory.CreateMediaRepository(uow);
-                var query = Query<IMedia>.Builder.Where(x => x.Level == level && x.Path.StartsWith("-21") == false);
+                var query = Query<IMedia>.Builder.Where(x => x.Level == level && x.Path.StartsWith(Constants.System.RecycleBinMediaPathPrefix) == false);
                 return repository.GetByQuery(query);
             }
         }
@@ -440,7 +440,7 @@ namespace Umbraco.Core.Services
         /// <returns>An Enumerable list of <see cref="IMedia"/> objects</returns>
         public IEnumerable<IMedia> GetAncestors(IMedia media)
         {
-            var ids = media.Path.Split(',').Where(x => x != "-1" && x != media.Id.ToString(CultureInfo.InvariantCulture)).Select(int.Parse).ToArray();
+            var ids = media.Path.Split(',').Where(x => x != Constants.System.RootString && x != media.Id.ToString(CultureInfo.InvariantCulture)).Select(int.Parse).ToArray();
             if (ids.Any() == false)
                 return new List<IMedia>();
 
@@ -609,7 +609,7 @@ namespace Umbraco.Core.Services
                         totalChildren = 0;
                         return Enumerable.Empty<IMedia>();
                     }
-                    query.Where(x => x.Path.SqlStartsWith(string.Format("{0},", mediaPath[0]), TextColumnType.NVarchar));
+                    query.Where(x => x.Path.SqlStartsWith(string.Format("{0},", mediaPath[0].Path), TextColumnType.NVarchar));
                 }
                 IQuery<IMedia> filterQuery = null;
                 if (filter.IsNullOrWhiteSpace() == false)
@@ -673,7 +673,7 @@ namespace Umbraco.Core.Services
         /// <returns>Parent <see cref="IMedia"/> object</returns>
         public IMedia GetParent(IMedia media)
         {
-            if (media.ParentId == -1 || media.ParentId == -21)
+            if (media.ParentId == Constants.System.Root || media.ParentId == Constants.System.RecycleBinMedia)
                 return null;
 
             return GetById(media.ParentId);
@@ -703,7 +703,7 @@ namespace Umbraco.Core.Services
             using (var uow = UowProvider.GetUnitOfWork(readOnly: true))
             {
                 var repository = RepositoryFactory.CreateMediaRepository(uow);
-                var query = Query<IMedia>.Builder.Where(x => x.ParentId == -1);
+                var query = Query<IMedia>.Builder.Where(x => x.ParentId == Constants.System.Root);
                 return repository.GetByQuery(query);
             }
         }
@@ -717,7 +717,7 @@ namespace Umbraco.Core.Services
             using (var uow = UowProvider.GetUnitOfWork(readOnly: true))
             {
                 var repository = RepositoryFactory.CreateMediaRepository(uow);
-                var query = Query<IMedia>.Builder.Where(x => x.Path.Contains("-21"));
+                var query = Query<IMedia>.Builder.Where(x => x.Path.StartsWith(Constants.System.RecycleBinMediaPathPrefix));
                 return repository.GetByQuery(query);
             }
         }
@@ -767,7 +767,7 @@ namespace Umbraco.Core.Services
             using (new WriteLock(Locker))
             {
                 //This ensures that the correct method is called if this method is used to Move to recycle bin.
-                if (parentId == -21)
+                if (parentId == Constants.System.RecycleBinMedia)
                 {
                     MoveToRecycleBin(media, userId);
                     return;
@@ -868,7 +868,7 @@ namespace Umbraco.Core.Services
 
             var repository = RepositoryFactory.CreateMediaRepository(uow);
             repository.Delete(media);
-            deleteEventArgs.CanCancel = false;            
+            deleteEventArgs.CanCancel = false;
             uow.Events.Dispatch(Deleted, this, deleteEventArgs);
 
             Audit(uow, AuditType.Delete, "Delete Media performed by user", userId, media.Id);
@@ -1003,7 +1003,7 @@ namespace Umbraco.Core.Services
                     recycleBinEventArgs.RecycleBinEmptiedSuccessfully = success;
                     uow.Events.Dispatch(EmptiedRecycleBin, this, recycleBinEventArgs);
 
-                    Audit(uow, AuditType.Delete, "Empty Media Recycle Bin performed by user", 0, -21);
+                    Audit(uow, AuditType.Delete, "Empty Media Recycle Bin performed by user", 0, Constants.System.RecycleBinMedia);
                     uow.Commit();
                 }
             }

src/Umbraco.Core/Services/MemberService.cs

@@ -1,6 +1,7 @@
 using System;
 using System.Collections.Generic;
 using System.ComponentModel;
+using System.IO;
 using System.Threading;
 using System.Web.Security;
 using System.Xml.Linq;
@@ -14,6 +15,9 @@ using Umbraco.Core.Persistence.DatabaseModelDefinitions;
 using Umbraco.Core.Persistence.Querying;
 using Umbraco.Core.Persistence.UnitOfWork;
 using System.Linq;
+using System.Net;
+using System.Net.Http;
+using System.Net.Http.Headers;
 using Umbraco.Core.Security;
 
 namespace Umbraco.Core.Services
@@ -25,11 +29,11 @@ namespace Umbraco.Core.Services
     {
         private readonly IMemberGroupService _memberGroupService;
         private readonly EntityXmlSerializer _entitySerializer = new EntityXmlSerializer();
-        private readonly IDataTypeService _dataTypeService;        
-        private static readonly ReaderWriterLockSlim Locker = new ReaderWriterLockSlim();
-
-        //only for unit tests!
-        internal MembershipProviderBase MembershipProvider { get; set; }
+        private readonly IDataTypeService _dataTypeService;
+        private static readonly ReaderWriterLockSlim Locker = new ReaderWriterLockSlim();
+
+        //only for unit tests!
+        internal MembershipProviderBase MembershipProvider { get; set; }
 
         public MemberService(IDatabaseUnitOfWorkProvider provider, RepositoryFactory repositoryFactory, ILogger logger, IEventMessagesFactory eventMessagesFactory, IMemberGroupService memberGroupService, IDataTypeService dataTypeService)
             : base(provider, repositoryFactory, logger, eventMessagesFactory)
@@ -38,7 +42,7 @@ namespace Umbraco.Core.Services
             if (dataTypeService == null) throw new ArgumentNullException("dataTypeService");
             _memberGroupService = memberGroupService;
             _dataTypeService = dataTypeService;
-        }        
+        }
 
         #region IMemberService Implementation
 
@@ -94,7 +98,7 @@ namespace Umbraco.Core.Services
         {
             if (member == null) throw new ArgumentNullException("member");
 
-            var provider = MembershipProvider ?? MembershipProviderExtensions.GetMembersMembershipProvider();            
+            var provider = MembershipProvider ?? MembershipProviderExtensions.GetMembersMembershipProvider();
             if (provider.IsUmbracoMembershipProvider())
             {
                 provider.ChangePassword(member.Username, "", password);
@@ -588,7 +592,7 @@ namespace Umbraco.Core.Services
             Mandate.ParameterCondition(pageIndex >= 0, "pageIndex");
             Mandate.ParameterCondition(pageSize > 0, "pageSize");
 
-            using (var uow = UowProvider.GetUnitOfWork(readOnly:true))
+            using (var uow = UowProvider.GetUnitOfWork(readOnly: true))
             {
                 var repository = RepositoryFactory.CreateMemberRepository(uow);
                 return repository.GetPagedXmlEntriesByPath("-1", pageIndex, pageSize, null, out totalRecords);
@@ -695,7 +699,7 @@ namespace Umbraco.Core.Services
                 IQuery<IMember> filterQuery = null;
                 if (filter.IsNullOrWhiteSpace() == false)
                 {
-                    filterQuery = Query<IMember>.Builder.Where(x => x.Name.Contains(filter) || x.Username.Contains(filter));
+                    filterQuery = Query<IMember>.Builder.Where(x => x.Name.Contains(filter) || x.Username.Contains(filter) || x.Email.Contains(filter));
                 }
 
                 var repository = RepositoryFactory.CreateMemberRepository(uow);
@@ -986,10 +990,10 @@ namespace Umbraco.Core.Services
         /// <param name="raiseEvents">Optional parameter to raise events.
         /// Default is <c>True</c> otherwise set to <c>False</c> to not raise events</param>
         public void Save(IMember entity, bool raiseEvents = true)
-        {
+        {
             //trimming username and email to make sure we have no trailing space
             entity.Username = entity.Username.Trim();
-            entity.Email = entity.Email.Trim();
+            entity.Email = entity.Email.Trim();
 
             using (var uow = UowProvider.GetUnitOfWork())
             {
@@ -1066,7 +1070,7 @@ namespace Umbraco.Core.Services
 
                     if (raiseEvents)
                     {
-                        saveEventArgs.CanCancel = false;
+                        saveEventArgs.CanCancel = false;
                         uow.Events.Dispatch(Saved, this, saveEventArgs);
                     }
                 }
@@ -1173,12 +1177,16 @@ namespace Umbraco.Core.Services
 
         public void AssignRoles(string[] usernames, string[] roleNames)
         {
+            int[] memberIds;
             using (var uow = UowProvider.GetUnitOfWork())
             {
                 var repository = RepositoryFactory.CreateMemberGroupRepository(uow);
-                repository.AssignRoles(usernames, roleNames);
+                memberIds = repository.GetMemberIds(usernames);
+                repository.AssignRoles(memberIds, roleNames);
                 uow.Commit();
             }
+
+            AssignedRoles?.Invoke(this, new RolesEventArgs(memberIds, roleNames));
         }
 
         public void DissociateRole(string username, string roleName)
@@ -1188,12 +1196,16 @@ namespace Umbraco.Core.Services
 
         public void DissociateRoles(string[] usernames, string[] roleNames)
         {
+            int[] memberIds;
             using (var uow = UowProvider.GetUnitOfWork())
             {
                 var repository = RepositoryFactory.CreateMemberGroupRepository(uow);
-                repository.DissociateRoles(usernames, roleNames);
+                memberIds = repository.GetMemberIds(usernames);
+                repository.DissociateRoles(memberIds, roleNames);
                 uow.Commit();
             }
+
+            RemovedRoles?.Invoke(this, new RolesEventArgs(memberIds, roleNames));
         }
 
         public void AssignRole(int memberId, string roleName)
@@ -1209,6 +1221,8 @@ namespace Umbraco.Core.Services
                 repository.AssignRoles(memberIds, roleNames);
                 uow.Commit();
             }
+
+            AssignedRoles?.Invoke(this, new RolesEventArgs(memberIds, roleNames));
         }
 
         public void DissociateRole(int memberId, string roleName)
@@ -1224,12 +1238,83 @@ namespace Umbraco.Core.Services
                 repository.DissociateRoles(memberIds, roleNames);
                 uow.Commit();
             }
+
+            RemovedRoles?.Invoke(this, new RolesEventArgs(memberIds, roleNames));
         }
 
 
 
         #endregion
 
+        /// <summary>
+        /// Used to export a member
+        /// </summary>
+        /// <param name="key"></param>
+        /// <returns></returns>
+        /// <remarks>
+        /// This is internal for now and is used to export a member in the member editor, it will raise an event so that auditing 
+        /// logs can be created
+        /// </remarks>
+        internal MemberExportModel ExportMember(Guid key)
+        {
+            using (var uow = UowProvider.GetUnitOfWork(readOnly: true))
+            {
+                var repository = RepositoryFactory.CreateMemberRepository(uow);
+                var query = Query<IMember>.Builder.Where(x => x.Key == key);
+                var member = repository.GetByQuery(query).FirstOrDefault();
+
+                if (member == null) return null;
+
+                var model = new MemberExportModel
+                {
+                    Id = member.Id,
+                    Key = member.Key,
+                    Name = member.Name,
+                    Username = member.Username,
+                    Email = member.Email,
+                    Groups = GetAllRoles(member.Id).ToList(),
+                    ContentTypeAlias = member.ContentTypeAlias,
+                    CreateDate = member.CreateDate,
+                    UpdateDate = member.UpdateDate,
+                    Properties = new List<MemberExportProperty>(GetPropertyExportItems(member))
+                };
+
+                uow.Events.Dispatch(Exported, this, new ExportedMemberEventArgs(member, model));
+
+                return model;
+            }
+        }
+
+        private static IEnumerable<MemberExportProperty> GetPropertyExportItems(IMember member)
+        {
+            if (member == null) throw new ArgumentNullException(nameof(member));
+
+            var exportProperties = new List<MemberExportProperty>();
+
+            foreach (var property in member.Properties)
+            {
+                //ignore list
+                switch (property.Alias)
+                {
+                    case Constants.Conventions.Member.PasswordQuestion:
+                        continue;
+                }
+
+                var propertyExportModel = new MemberExportProperty
+                {
+                    Id = property.Id,
+                    Alias = property.Alias,
+                    Name = property.PropertyType.Name,
+                    Value = property.Value,
+                    CreateDate = property.CreateDate,
+                    UpdateDate = property.UpdateDate
+                };
+                exportProperties.Add(propertyExportModel);
+            }
+
+            return exportProperties;
+        }
+
         private IMemberType FindMemberTypeByAlias(string memberTypeAlias)
         {
             using (var uow = UowProvider.GetUnitOfWork())
@@ -1289,6 +1374,11 @@ namespace Umbraco.Core.Services
         /// </summary>
         public static event TypedEventHandler<IMemberService, SaveEventArgs<IMember>> Saved;
 
+        public static event TypedEventHandler<IMemberService, RolesEventArgs> AssignedRoles;
+        public static event TypedEventHandler<IMemberService, RolesEventArgs> RemovedRoles;
+
+        internal static event TypedEventHandler<IMemberService, ExportedMemberEventArgs> Exported;
+
         #endregion
 
         /// <summary>
@@ -1361,4 +1451,4 @@ namespace Umbraco.Core.Services
             return member;
         }
     }
-}
+}

src/Umbraco.Core/Services/PackagingService.cs

@@ -832,21 +832,21 @@ namespace Umbraco.Core.Services
             foreach (var element in structureElement.Elements("DocumentType"))
             {
                 var alias = element.Value;
-                if (_importedContentTypes.ContainsKey(alias))
-                {
-                    var allowedChild = _importedContentTypes[alias];
-                    if (allowedChild == null || allowedChildren.Any(x => x.Id.IsValueCreated && x.Id.Value == allowedChild.Id)) continue;
 
-                    allowedChildren.Add(new ContentTypeSort(new Lazy<int>(() => allowedChild.Id), sortOrder, allowedChild.Alias));
-                    sortOrder++;
-                }
-                else
+                var allowedChild = _importedContentTypes.ContainsKey(alias) ? _importedContentTypes[alias] : _contentTypeService.GetContentType(alias);
+                if (allowedChild == null)
                 {
                     _logger.Warn<PackagingService>(
                     string.Format(
                         "Packager: Error handling DocumentType structure. DocumentType with alias '{0}' could not be found and was not added to the structure for '{1}'.",
                         alias, contentType.Alias));
+
+                    continue;
                 }
+                if (allowedChildren.Any(x => x.Id.IsValueCreated && x.Id.Value == allowedChild.Id)) continue;
+
+                allowedChildren.Add(new ContentTypeSort(new Lazy<int>(() => allowedChild.Id), sortOrder, allowedChild.Alias));
+                sortOrder++;
             }
 
             contentType.AllowedContentTypes = allowedChildren;
@@ -1748,9 +1748,10 @@ namespace Umbraco.Core.Services
 
         internal InstallationSummary InstallPackage(string packageFilePath, int userId = 0, bool raiseEvents = false)
         {
+            var metaData = GetPackageMetaData(packageFilePath);
+
             if (raiseEvents)
-            {
-                var metaData = GetPackageMetaData(packageFilePath);
+            {                
                 if (ImportingPackage.IsRaisedEventCancelled(new ImportPackageEventArgs<string>(packageFilePath, metaData), this))
                 {
                     var initEmpty = new InstallationSummary().InitEmpty();
@@ -1762,7 +1763,7 @@ namespace Umbraco.Core.Services
 
             if (raiseEvents)
             {
-                ImportedPackage.RaiseEvent(new ImportPackageEventArgs<InstallationSummary>(installationSummary, false), this);
+                ImportedPackage.RaiseEvent(new ImportPackageEventArgs<InstallationSummary>(installationSummary, metaData, false), this);
             }
 
             return installationSummary;

src/Umbraco.Core/Services/ServiceContext.cs

@@ -62,38 +62,13 @@ namespace Umbraco.Core.Services
         private Lazy<INotificationService> _notificationService;
         private Lazy<IExternalLoginService> _externalLoginService;
         private Lazy<IRedirectUrlService> _redirectUrlService;
+        private Lazy<IConsentService> _consentService;
 
         internal IdkMap IdkMap { get; private set; }
 
         /// <summary>
         /// public ctor - will generally just be used for unit testing all items are optional and if not specified, the defaults will be used
         /// </summary>
-        /// <param name="contentService"></param>
-        /// <param name="mediaService"></param>
-        /// <param name="contentTypeService"></param>
-        /// <param name="dataTypeService"></param>
-        /// <param name="fileService"></param>
-        /// <param name="localizationService"></param>
-        /// <param name="packagingService"></param>
-        /// <param name="entityService"></param>
-        /// <param name="relationService"></param>
-        /// <param name="memberGroupService"></param>
-        /// <param name="memberTypeService"></param>
-        /// <param name="memberService"></param>
-        /// <param name="userService"></param>
-        /// <param name="sectionService"></param>
-        /// <param name="treeService"></param>
-        /// <param name="tagService"></param>
-        /// <param name="notificationService"></param>
-        /// <param name="localizedTextService"></param>
-        /// <param name="auditService"></param>
-        /// <param name="domainService"></param>
-        /// <param name="taskService"></param>
-        /// <param name="macroService"></param>
-        /// <param name="publicAccessService"></param>
-        /// <param name="externalLoginService"></param>
-        /// <param name="migrationEntryService"></param>
-        /// <param name="redirectUrlService"></param>
         public ServiceContext(
             IContentService contentService = null,
             IMediaService mediaService = null,
@@ -120,7 +95,8 @@ namespace Umbraco.Core.Services
             IPublicAccessService publicAccessService = null,
             IExternalLoginService externalLoginService = null,
             IMigrationEntryService migrationEntryService = null,
-            IRedirectUrlService redirectUrlService = null)
+            IRedirectUrlService redirectUrlService = null,
+            IConsentService consentService = null)
         {
             if (migrationEntryService != null) _migrationEntryService = new Lazy<IMigrationEntryService>(() => migrationEntryService);
             if (externalLoginService != null) _externalLoginService = new Lazy<IExternalLoginService>(() => externalLoginService);
@@ -148,6 +124,7 @@ namespace Umbraco.Core.Services
             if (macroService != null) _macroService = new Lazy<IMacroService>(() => macroService);
             if (publicAccessService != null) _publicAccessService = new Lazy<IPublicAccessService>(() => publicAccessService);
             if (redirectUrlService != null) _redirectUrlService = new Lazy<IRedirectUrlService>(() => redirectUrlService);
+            if (consentService != null) _consentService = new Lazy<IConsentService>(() => consentService);
         }
 
         /// <summary>
@@ -310,6 +287,9 @@ namespace Umbraco.Core.Services
 
             if (_redirectUrlService == null)
                 _redirectUrlService = new Lazy<IRedirectUrlService>(() => new RedirectUrlService(provider, repositoryFactory, logger, eventMessagesFactory));
+
+            if (_consentService == null)
+                _consentService = new Lazy<IConsentService>(() => new ConsentService(provider, repositoryFactory, logger, eventMessagesFactory));
         }
 
         internal IEventMessagesFactory EventMessagesFactory { get; private set; }
@@ -526,5 +506,10 @@ namespace Umbraco.Core.Services
         {
             get { return _redirectUrlService.Value; }
         }
+
+        /// <summary>
+        /// Gets the <see cref="IConsentService"/> implementation.
+        /// </summary>
+        public IConsentService ConsentService => _consentService.Value;
     }
-}
+}

src/Umbraco.Core/Services/UserService.cs

@@ -838,13 +838,9 @@ namespace Umbraco.Core.Services
                 repository.ReplaceGroupPermissions(groupId, permissions, entityIds);
                 uow.Commit();
 
-                uow.Events.Dispatch(UserGroupPermissionsAssigned, this, new SaveEventArgs<EntityPermission>(
-                    entityIds.Select(
-                            x => new EntityPermission(
-                                groupId,
-                                x,
-                                permissions.Select(p => p.ToString(CultureInfo.InvariantCulture)).ToArray()))
-                        .ToArray(), false));
+                var assigned = permissions.Select(p => p.ToString(CultureInfo.InvariantCulture)).ToArray();
+                uow.Events.Dispatch(UserGroupPermissionsAssigned, this,
+                    new SaveEventArgs<EntityPermission>(entityIds.Select(x => new EntityPermission(groupId, x, assigned)).ToArray(), false));
             }
         }
 
@@ -865,13 +861,9 @@ namespace Umbraco.Core.Services
                 repository.AssignGroupPermission(groupId, permission, entityIds);
                 uow.Commit();
 
-                uow.Events.Dispatch(UserGroupPermissionsAssigned, this, new SaveEventArgs<EntityPermission>(
-                    entityIds.Select(
-                            x => new EntityPermission(
-                                groupId,
-                                x,
-                                new[] { permission.ToString(CultureInfo.InvariantCulture) }))
-                        .ToArray(), false));
+                var assigned = new[] { permission.ToString(CultureInfo.InvariantCulture) };
+                uow.Events.Dispatch(UserGroupPermissionsAssigned, this,
+                    new SaveEventArgs<EntityPermission>(entityIds.Select(x => new EntityPermission(groupId, x, assigned)).ToArray(), false));
             }
         }
 
@@ -941,7 +933,7 @@ namespace Umbraco.Core.Services
         /// </summary>
         /// <param name="userGroup">UserGroup to save</param>
         /// <param name="userIds">
-        /// If null than no changes are made to the users who are assigned to this group, however if a value is passed in 
+        /// If null than no changes are made to the users who are assigned to this group, however if a value is passed in
         /// than all users will be removed from this group and only these users will be added
         /// </param>
         /// <param name="raiseEvents">Optional parameter to raise events.
@@ -950,8 +942,28 @@ namespace Umbraco.Core.Services
         {
             using (var uow = UowProvider.GetUnitOfWork())
             {
+                // we need to figure out which users have been added / removed, for audit purposes
+                var empty = new IUser[0];
+                var addedUsers = empty;
+                var removedUsers = empty;
+
+                if (userIds != null)
+                {
+                    var urepository = RepositoryFactory.CreateUserRepository(uow);
+
+                    var groupUsers = userGroup.HasIdentity ? urepository.GetAllInGroup(userGroup.Id).ToArray() : empty;
+                    var xGroupUsers = groupUsers.ToDictionary(x => x.Id, x => x);
+                    var groupIds = groupUsers.Select(x => x.Id).ToArray();
+
+                    addedUsers = urepository.GetAll(userIds.Except(groupIds).ToArray()).Where(x => x.Id != 0).ToArray();
+                    removedUsers = groupIds.Except(userIds).Select(x => xGroupUsers[x]).Where(x => x.Id != 0).ToArray();
+                }
+
+                //raise 2x events - the old and new one for backwards compat reasons
                 var saveEventArgs = new SaveEventArgs<IUserGroup>(userGroup);
-                if (raiseEvents && uow.Events.DispatchCancelable(SavingUserGroup, this, saveEventArgs))
+                var saveEventArgs2 = new SaveEventArgs<UserGroupWithUsers>(new UserGroupWithUsers(userGroup, addedUsers, removedUsers));
+                if (raiseEvents &&
+                    (uow.Events.DispatchCancelable(SavingUserGroup, this, saveEventArgs) || uow.Events.DispatchCancelable(SavingUserGroup2, this, saveEventArgs2)))
                 {
                     uow.Commit();
                     return;
@@ -965,7 +977,10 @@ namespace Umbraco.Core.Services
                 if (raiseEvents)
                 {
                     saveEventArgs.CanCancel = false;
+
+                    //raise 2x events - the old and new one for backwards compat reasons
                     uow.Events.Dispatch(SavedUserGroup, this, saveEventArgs);
+                    uow.Events.Dispatch(SavedUserGroup2, this, saveEventArgs2);
                 }
             }
         }
@@ -1161,8 +1176,8 @@ namespace Umbraco.Core.Services
                     if (byGroup.Value.TryGetValue(pathId, out permissionsForNodeAndGroup) == false)
                         continue;
 
-                    //In theory there will only be one EntityPermission in this group 
-                    // but there's nothing stopping the logic of this method 
+                    //In theory there will only be one EntityPermission in this group
+                    // but there's nothing stopping the logic of this method
                     // from having more so we deal with it here
                     foreach (var entityPermission in permissionsForNodeAndGroup)
                     {
@@ -1198,7 +1213,7 @@ namespace Umbraco.Core.Services
         /// Returns the resulting permission set for a group for the path based on all permissions provided for the branch
         /// </summary>
         /// <param name="pathPermissions">
-        /// The collective set of permissions provided to calculate the resulting permissions set for the path 
+        /// The collective set of permissions provided to calculate the resulting permissions set for the path
         /// based on a single group
         /// </param>
         /// <param name="pathIds">Must be ordered deepest to shallowest (right to left)</param>
@@ -1296,13 +1311,25 @@ namespace Umbraco.Core.Services
         /// <summary>
         /// Occurs before Save
         /// </summary>
+        //TODO: In v8, change this event to be SaveEventArgs<UserGroupWithUsers> and remove SavingUserGroup2
         public static event TypedEventHandler<IUserService, SaveEventArgs<IUserGroup>> SavingUserGroup;
 
         /// <summary>
         /// Occurs after Save
         /// </summary>
+        //TODO: In v8, change this event to be SaveEventArgs<UserGroupWithUsers> and remove SavedUserGroup2
         public static event TypedEventHandler<IUserService, SaveEventArgs<IUserGroup>> SavedUserGroup;
 
+        /// <summary>
+        /// Occurs after Save
+        /// </summary>
+        internal static event TypedEventHandler<IUserService, SaveEventArgs<UserGroupWithUsers>> SavingUserGroup2;
+
+        /// <summary>
+        /// Occurs after Save
+        /// </summary>
+        internal static event TypedEventHandler<IUserService, SaveEventArgs<UserGroupWithUsers>> SavedUserGroup2;
+
         /// <summary>
         /// Occurs before Delete
         /// </summary>

src/Umbraco.Core/Strings/DefaultShortStringHelper.cs

@@ -70,7 +70,7 @@ namespace Umbraco.Core.Strings
         {
             foreach (var node in _umbracoSettings.RequestHandler.CharCollection)
             {
-                if(string.IsNullOrEmpty(node.Char) == false)
+                if (string.IsNullOrEmpty(node.Char) == false)
                     _urlReplaceCharacters[node.Char] = node.Replacement;
             }
         }
@@ -109,7 +109,7 @@ namespace Umbraco.Core.Strings
         private void EnsureNotFrozen()
         {
             if (_frozen)
-                throw new InvalidOperationException("Cannot configure the helper once it is frozen.");            
+                throw new InvalidOperationException("Cannot configure the helper once it is frozen.");
         }
 
         /// <summary>
@@ -176,7 +176,7 @@ namespace Umbraco.Core.Strings
             }).WithConfig(CleanStringType.Alias, new Config
             {
                 PreFilter = ApplyUrlReplaceCharacters,
-                IsTerm = (c, leading) => leading 
+                IsTerm = (c, leading) => leading
                     ? char.IsLetter(c) // only letters
                     : (char.IsLetterOrDigit(c) || c == '_'), // letter, digit or underscore
                 StringType = CleanStringType.Ascii | CleanStringType.UmbracoCase,
@@ -215,12 +215,12 @@ namespace Umbraco.Core.Strings
                 return new Config
                 {
                     PreFilter = PreFilter,
-                    PostFilter =  PostFilter,
+                    PostFilter = PostFilter,
                     IsTerm = IsTerm,
                     StringType = StringType,
                     BreakTermsOnUpper = BreakTermsOnUpper,
-                    CutAcronymOnNonUpper =  CutAcronymOnNonUpper,
-                    GreedyAcronyms =  GreedyAcronyms,
+                    CutAcronymOnNonUpper = CutAcronymOnNonUpper,
+                    GreedyAcronyms = GreedyAcronyms,
                     Separator = Separator
                 };
             }
@@ -338,9 +338,9 @@ function validateSafeAlias(input, value, immediate, callback) {{
         /// Gets the JavaScript code defining client-side short string services.
         /// </summary>
         public string GetShortStringServicesJavaScript(string controllerPath)
-        {
-                return string.Format(SssjsFormat,
-                    _umbracoSettings.Content.ForceSafeAliases ? "true" : "false", controllerPath);
+        {
+            return string.Format(SssjsFormat,
+                _umbracoSettings.Content.ForceSafeAliases ? "true" : "false", controllerPath);
         }
 
         #endregion
@@ -467,7 +467,7 @@ function validateSafeAlias(input, value, immediate, callback) {{
         /// Cleans a string.
         /// </summary>
         /// <param name="text">The text to clean.</param>
-        /// <param name="stringType">A flag indicating the target casing and encoding of the string. By default, 
+        /// <param name="stringType">A flag indicating the target casing and encoding of the string. By default,
         /// strings are cleaned up to camelCase and Ascii.</param>
         /// <returns>The clean string.</returns>
         /// <remarks>The string is cleaned in the context of the default culture.</remarks>
@@ -480,7 +480,7 @@ function validateSafeAlias(input, value, immediate, callback) {{
         /// Cleans a string, using a specified separator.
         /// </summary>
         /// <param name="text">The text to clean.</param>
-        /// <param name="stringType">A flag indicating the target casing and encoding of the string. By default, 
+        /// <param name="stringType">A flag indicating the target casing and encoding of the string. By default,
         /// strings are cleaned up to camelCase and Ascii.</param>
         /// <param name="separator">The separator.</param>
         /// <returns>The clean string.</returns>
@@ -494,7 +494,7 @@ function validateSafeAlias(input, value, immediate, callback) {{
         /// Cleans a string in the context of a specified culture.
         /// </summary>
         /// <param name="text">The text to clean.</param>
-        /// <param name="stringType">A flag indicating the target casing and encoding of the string. By default, 
+        /// <param name="stringType">A flag indicating the target casing and encoding of the string. By default,
         /// strings are cleaned up to camelCase and Ascii.</param>
         /// <param name="culture">The culture.</param>
         /// <returns>The clean string.</returns>
@@ -507,7 +507,7 @@ function validateSafeAlias(input, value, immediate, callback) {{
         /// Cleans a string in the context of a specified culture, using a specified separator.
         /// </summary>
         /// <param name="text">The text to clean.</param>
-        /// <param name="stringType">A flag indicating the target casing and encoding of the string. By default, 
+        /// <param name="stringType">A flag indicating the target casing and encoding of the string. By default,
         /// strings are cleaned up to camelCase and Ascii.</param>
         /// <param name="separator">The separator.</param>
         /// <param name="culture">The culture.</param>
@@ -554,7 +554,7 @@ function validateSafeAlias(input, value, immediate, callback) {{
                     text = Utf8ToAsciiConverter.ToAsciiString(text);
                     break;
                 case CleanStringType.TryAscii:
-                    const char ESC = (char) 27;
+                    const char ESC = (char)27;
                     var ctext = Utf8ToAsciiConverter.ToAsciiString(text, ESC);
                     if (ctext.Contains(ESC) == false) text = ctext;
                     break;
@@ -568,8 +568,8 @@ function validateSafeAlias(input, value, immediate, callback) {{
 
             // apply post-filter
             if (config.PostFilter != null)
-                text = config.PostFilter(text);
-            
+                text = config.PostFilter(text);
+
             return text;
         }
 
@@ -839,7 +839,7 @@ function validateSafeAlias(input, value, immediate, callback) {{
                     {
                         term = term.Substring(i);
                         term.CopyTo(0, output, opos, term.Length);
-                        opos += term.Length;                        
+                        opos += term.Length;
                     }
                     break;
 
@@ -914,21 +914,22 @@ function validateSafeAlias(input, value, immediate, callback) {{
         /// <returns>The filtered string.</returns>
         public virtual string ReplaceMany(string text, IDictionary<string, string> replacements)
         {
-            // be safe
             if (text == null)
+            {
                 throw new ArgumentNullException("text");
+            }
+
             if (replacements == null)
+            {
                 throw new ArgumentNullException("replacements");
+            }
 
-            // Have done various tests, implementing my own "super fast" state machine to handle 
-            // replacement of many items, or via regexes, but on short strings and not too
-            // many replacements (which prob. is going to be our case) nothing can beat this...
-            // (at least with safe and checked code -- we don't want unsafe/unchecked here)
+            foreach (KeyValuePair<string, string> item in replacements)
+            {
+                text = text.Replace(item.Key, item.Value);
+            }
 
-            // Note that it will do chained-replacements ie replaced items can be replaced
-            // in turn by another replacement (ie the order of replacements is important)
-
-            return replacements.Aggregate(text, (current, kvp) => current.Replace(kvp.Key, kvp.Value));
+            return text;
         }
 
         /// <summary>
@@ -940,15 +941,22 @@ function validateSafeAlias(input, value, immediate, callback) {{
         /// <returns>The filtered string.</returns>
         public virtual string ReplaceMany(string text, char[] chars, char replacement)
         {
-            // be safe
             if (text == null)
+            {
                 throw new ArgumentNullException("text");
+            }
+
             if (chars == null)
+            {
                 throw new ArgumentNullException("chars");
+            }
 
-            // see note above
+            for (int i = 0; i < chars.Length; i++)
+            {
+                text = text.Replace(chars[i], replacement);
+            }
 
-            return chars.Aggregate(text, (current, c) => current.Replace(c, replacement));
+            return text;
         }
 
         #endregion

src/Umbraco.Core/Sync/ApplicationUrlHelper.cs

@@ -55,7 +55,7 @@ namespace Umbraco.Core.Sync
                 if (newApplicationUrl)
                 {
                     appContext._umbracoApplicationDomains.Add(applicationUrl);
-                    LogHelper.Info(typeof(ApplicationUrlHelper), $"New ApplicationUrl detected: {applicationUrl}");
+                    LogHelper.Info(typeof(ApplicationUrlHelper), string.Format("New ApplicationUrl detected: {0}", applicationUrl));
                 }
             }
 
@@ -169,4 +169,4 @@ namespace Umbraco.Core.Sync
             return url.TrimEnd('/');
         }
     }
-}
+}

src/Umbraco.Core/Umbraco.Core.csproj

@@ -15,6 +15,7 @@
     <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\</SolutionDir>
     <RestorePackages>true</RestorePackages>
     <TargetFrameworkProfile />
+    <LangVersion>latest</LangVersion>
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
     <DebugSymbols>true</DebugSymbols>
@@ -25,6 +26,7 @@
     <ErrorReport>prompt</ErrorReport>
     <WarningLevel>4</WarningLevel>
     <Prefer32Bit>false</Prefer32Bit>
+    <LangVersion>latest</LangVersion>
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
     <DebugType>pdbonly</DebugType>
@@ -43,8 +45,8 @@
     <Reference Include="AutoMapper.Net4, Version=3.3.1.0, Culture=neutral, PublicKeyToken=be96cd2c38ef1005, processorArchitecture=MSIL">
       <HintPath>..\packages\AutoMapper.3.3.1\lib\net40\AutoMapper.Net4.dll</HintPath>
     </Reference>
-    <Reference Include="ClientDependency.Core, Version=1.9.4.0, Culture=neutral, processorArchitecture=MSIL">
-      <HintPath>..\packages\ClientDependency.1.9.4\lib\net45\ClientDependency.Core.dll</HintPath>
+    <Reference Include="ClientDependency.Core, Version=1.9.6.0, Culture=neutral, processorArchitecture=MSIL">
+      <HintPath>..\packages\ClientDependency.1.9.6\lib\net45\ClientDependency.Core.dll</HintPath>
     </Reference>
     <Reference Include="HtmlAgilityPack, Version=1.4.9.5, Culture=neutral, PublicKeyToken=bd319b19eaf3b43a, processorArchitecture=MSIL">
       <HintPath>..\packages\HtmlAgilityPack.1.4.9.5\lib\Net45\HtmlAgilityPack.dll</HintPath>
@@ -137,6 +139,7 @@
     <Compile Include="AsyncLock.cs" />
     <Compile Include="Attempt{T}.cs" />
     <Compile Include="Auditing\Audit.cs" />
+    <Compile Include="Auditing\AuditEventHandler.cs" />
     <Compile Include="Auditing\AuditTypes.cs" />
     <Compile Include="Auditing\IdentityAuditEventArgs.cs" />
     <Compile Include="BindingRedirects.cs" />
@@ -352,7 +355,9 @@
     <Compile Include="DisposableObjectSlim.cs" />
     <Compile Include="EmailSender.cs" />
     <Compile Include="Events\EventDefinitionFilter.cs" />
+    <Compile Include="Events\ExportedMemberEventArgs.cs" />
     <Compile Include="Events\IDeletingMediaFilesEventArgs.cs" />
+    <Compile Include="Events\UserGroupWithUsers.cs" />
     <Compile Include="Events\ScopeEventDispatcherBase.cs" />
     <Compile Include="Events\ScopeLifespanMessagesFactory.cs" />
     <Compile Include="Events\SendEmailEventArgs.cs" />
@@ -363,20 +368,30 @@
     <Compile Include="IEmailSender.cs" />
     <Compile Include="IHttpContextAccessor.cs" />
     <Compile Include="Logging\RollingFileCleanupAppender.cs" />
+    <Compile Include="Models\AuditEntry.cs" />
+    <Compile Include="Models\Consent.cs" />
+    <Compile Include="Models\ConsentExtensions.cs" />
+    <Compile Include="Models\ConsentState.cs" />
     <Compile Include="Models\EntityBase\EntityPath.cs" />
     <Compile Include="Models\EntityBase\IDeletableEntity.cs" />
+    <Compile Include="Models\IAuditEntry.cs" />
     <Compile Include="Models\IAuditItem.cs" />
+    <Compile Include="Models\IConsent.cs" />
     <Compile Include="Models\IUserControl.cs" />
     <Compile Include="Models\Membership\ContentPermissionSet.cs" />
     <Compile Include="Models\Membership\EntityPermissionCollection.cs" />
     <Compile Include="Models\Membership\IReadOnlyUserGroup.cs" />
     <Compile Include="Models\Membership\IUserType.cs" />
+    <Compile Include="Models\Membership\MemberExportModel.cs" />
+    <Compile Include="Models\Membership\MemberExportProperty.cs" />
     <Compile Include="Models\Membership\ReadOnlyUserGroup.cs" />
     <Compile Include="Models\Membership\UserGroupExtensions.cs" />
     <Compile Include="Models\Membership\UserProfile.cs" />
     <Compile Include="Models\Membership\UserState.cs" />
     <Compile Include="Models\Membership\UserType.cs" />
     <Compile Include="Models\PublishedContent\PublishedContentTypeConverter.cs" />
+    <Compile Include="Models\Rdbms\AuditEntryDto.cs" />
+    <Compile Include="Models\Rdbms\ConsentDto.cs" />
     <Compile Include="Models\Rdbms\MediaDto.cs" />
     <Compile Include="Models\Rdbms\UserLoginDto.cs" />
     <Compile Include="Models\Rdbms\UserStartNodeDto.cs" />
@@ -530,6 +545,7 @@
     <Compile Include="Persistence\Constants-Locks.cs" />
     <Compile Include="Persistence\DatabaseNodeLockExtensions.cs" />
     <Compile Include="Persistence\DatabaseDebugHelper.cs" />
+    <Compile Include="Persistence\Factories\AuditEntryFactory.cs" />
     <Compile Include="Persistence\Factories\ExternalLoginFactory.cs" />
     <Compile Include="Persistence\Factories\MigrationEntryFactory.cs" />
     <Compile Include="Persistence\Factories\PublicAccessEntryFactory.cs" />
@@ -540,7 +556,9 @@
     <Compile Include="Persistence\LockedRepository.cs" />
     <Compile Include="Persistence\LockingRepository.cs" />
     <Compile Include="Persistence\Mappers\AccessMapper.cs" />
+    <Compile Include="Persistence\Mappers\AuditEntryMapper.cs" />
     <Compile Include="Persistence\Mappers\AuditMapper.cs" />
+    <Compile Include="Persistence\Mappers\ConsentMapper.cs" />
     <Compile Include="Persistence\Mappers\DomainMapper.cs" />
     <Compile Include="Persistence\Mappers\ExternalLoginMapper.cs" />
     <Compile Include="Persistence\Mappers\MigrationEntryMapper.cs" />
@@ -552,6 +570,10 @@
     <Compile Include="Persistence\Migrations\Upgrades\TargetVersionSevenEightZero\AddInstructionCountColumn.cs" />
     <Compile Include="Persistence\Migrations\Upgrades\TargetVersionSevenEightZero\AddCmsMediaTable.cs" />
     <Compile Include="Persistence\Migrations\Upgrades\TargetVersionSevenEightZero\AddUserLoginTable.cs" />
+    <Compile Include="Persistence\Migrations\Upgrades\TargetVersionSevenNineZero\AddUmbracoAuditTable.cs" />
+    <Compile Include="Persistence\Migrations\Upgrades\TargetVersionSevenNineZero\AddUmbracoConsentTable.cs" />
+    <Compile Include="Persistence\Migrations\Upgrades\TargetVersionSevenNineZero\AddIsSensitiveMemberTypeColumn.cs" />
+    <Compile Include="Persistence\Migrations\Upgrades\TargetVersionSevenNineZero\CreateSensitiveDataUserGroup.cs" />
     <Compile Include="Persistence\Migrations\Upgrades\TargetVersionSevenSevenZero\AddIndexToDictionaryKeyColumn.cs" />
     <Compile Include="Persistence\Migrations\Upgrades\TargetVersionSevenSevenZero\EnsureContentTemplatePermissions.cs" />
     <Compile Include="Persistence\Migrations\Upgrades\TargetVersionSevenSevenZero\ReduceDictionaryKeyColumnsSize.cs" />
@@ -622,12 +644,17 @@
     <Compile Include="Persistence\Relators\AccessRulesRelator.cs" />
     <Compile Include="Persistence\Relators\UserGroupRelator.cs" />
     <Compile Include="Persistence\Relators\UserGroupSectionRelator.cs" />
+    <Compile Include="Persistence\Repositories\AuditEntryRepository.cs" />
     <Compile Include="Persistence\Repositories\AuditRepository.cs" />
     <Compile Include="Persistence\Repositories\BaseQueryType.cs" />
+    <Compile Include="Persistence\Factories\ConsentFactory.cs" />
+    <Compile Include="Persistence\Repositories\ConsentRepository.cs" />
     <Compile Include="Persistence\Repositories\ContentBlueprintRepository.cs" />
     <Compile Include="Persistence\Repositories\EntityContainerRepository.cs" />
     <Compile Include="Persistence\Repositories\DomainRepository.cs" />
     <Compile Include="Persistence\Repositories\ExternalLoginRepository.cs" />
+    <Compile Include="Persistence\Repositories\IAuditEntryRepository.cs" />
+    <Compile Include="Persistence\Repositories\IConsentRepository.cs" />
     <Compile Include="Persistence\Repositories\Interfaces\IAuditRepository.cs" />
     <Compile Include="Persistence\Repositories\Interfaces\IContentTypeCompositionRepository.cs" />
     <Compile Include="Persistence\Repositories\Interfaces\IDomainRepository.cs" />
@@ -724,8 +751,10 @@
     <Compile Include="Persistence\Migrations\Upgrades\TargetVersionSevenThreeZero\CreateCacheInstructionTable.cs" />
     <Compile Include="Persistence\Migrations\Upgrades\TargetVersionSevenThreeZero\MigrateStylesheetDataToFile.cs" />
     <Compile Include="Services\AuditService.cs" />
+    <Compile Include="Services\ConsentService.cs" />
     <Compile Include="Services\ContentTypeServiceExtensions.cs" />
     <Compile Include="Models\RedirectUrl.cs" />
+    <Compile Include="Services\IConsentService.cs" />
     <Compile Include="Services\IContentServiceBase.cs" />
     <Compile Include="Services\IdkMap.cs" />
     <Compile Include="Services\MediaServiceExtensions.cs" />
@@ -749,6 +778,7 @@
     <Compile Include="Services\RepositoryService.cs" />
     <Compile Include="Services\OperationStatus.cs" />
     <Compile Include="Services\OperationStatusType.cs" />
+    <Compile Include="Events\RolesEventArgs.cs" />
     <Compile Include="Services\ScopeRepositoryService.cs" />
     <Compile Include="Services\TaskService.cs" />
     <Compile Include="Strings\Css\StylesheetHelper.cs" />
@@ -1547,6 +1577,7 @@
     <Compile Include="ReadLock.cs" />
     <Compile Include="TypeFinder.cs" />
     <Compile Include="TypeHelper.cs" />
+    <Compile Include="Collections\CompositeTypeTypeKey.cs" />
     <Compile Include="Udi.cs" />
     <Compile Include="UdiDefinitionAttribute.cs" />
     <Compile Include="UdiEntityType.cs" />
@@ -1642,7 +1673,7 @@
   </ItemGroup>
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
   <Import Project="..\packages\AutoMapper.3.3.1\tools\AutoMapper.targets" Condition="Exists('..\packages\AutoMapper.3.3.1\tools\AutoMapper.targets')" />
-  <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
+  <!-- To modify your build process, add your task inside one of the targets below and uncomment it.
        Other similar extension points exist, see Microsoft.Common.targets.
   <Target Name="BeforeBuild">
   </Target>

src/Umbraco.Core/Umbraco.Core.csproj.DotSettings

@@ -1,2 +0,0 @@
-<wpf:ResourceDictionary xml:space="preserve" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" xmlns:s="clr-namespace:System;assembly=mscorlib" xmlns:ss="urn:shemas-jetbrains-com:settings-storage-xaml" xmlns:wpf="http://schemas.microsoft.com/winfx/2006/xaml/presentation">
-	<s:String x:Key="/Default/CodeInspection/CSharpLanguageProject/LanguageLevel/@EntryValue">CSharp50</s:String></wpf:ResourceDictionary>

src/Umbraco.Core/packages.config

@@ -1,7 +1,7 @@
 <?xml version="1.0" encoding="utf-8"?>
 <packages>
   <package id="AutoMapper" version="3.3.1" targetFramework="net45" />
-  <package id="ClientDependency" version="1.9.4" targetFramework="net45" />
+  <package id="ClientDependency" version="1.9.6" targetFramework="net45" />
   <package id="HtmlAgilityPack" version="1.4.9.5" targetFramework="net45" />
   <package id="ImageProcessor" version="2.5.6" targetFramework="net45" />
   <package id="log4net" version="2.0.8" targetFramework="net45" />

src/Umbraco.Tests.Benchmarks/BulkInsertBenchmarks.cs

@@ -3,43 +3,24 @@ using System.Collections.Generic;
 using System.Data.SqlServerCe;
 using System.IO;
 using BenchmarkDotNet.Attributes;
-using BenchmarkDotNet.Configs;
-using BenchmarkDotNet.Diagnostics.Windows;
-using BenchmarkDotNet.Jobs;
 using Umbraco.Core;
 using Umbraco.Core.Logging;
 using Umbraco.Core.Models.Rdbms;
 using Umbraco.Core.Persistence;
 using Umbraco.Core.Persistence.Migrations.Initial;
 using Umbraco.Core.Persistence.SqlSyntax;
+using Umbraco.Tests.Benchmarks.Config;
 using Umbraco.Tests.TestHelpers;
 using ILogger = Umbraco.Core.Logging.ILogger;
 
 namespace Umbraco.Tests.Benchmarks
 {
-    [Config(typeof(Config))]
+    [QuickRunWithMemoryDiagnoserConfig]
     public class BulkInsertBenchmarks
     {
-        private class Config : ManualConfig
-        {
-            public Config()
-            {
-                Add(new MemoryDiagnoser());
-                //Add(ExecutionValidator.FailOnError);
-
-                //The 'quick and dirty' settings, so it runs a little quicker
-                // see benchmarkdotnet FAQ
-                Add(Job.Default
-                    .WithLaunchCount(1) // benchmark process will be launched only once
-                    .WithIterationTime(100) // 100ms per iteration
-                    .WithWarmupCount(3) // 3 warmup iteration
-                    .WithTargetCount(3)); // 3 target iteration                
-            }
-        }
-
         private static byte[] _initDbBytes = null;
 
-        [Setup]
+        [GlobalSetup]
         public void Setup()
         {
             var logger = new DebugDiagnosticsLogger();
@@ -51,8 +32,8 @@ namespace Umbraco.Tests.Benchmarks
             SetupSqlCe(path, logger);
             SetupSqlServer(logger);
 
-            
-        }        
+
+        }
 
         private void SetupSqlServer(ILogger logger)
         {
@@ -75,7 +56,7 @@ namespace Umbraco.Tests.Benchmarks
 	[lastNotifiedDate] [datetime] NOT NULL,
 	[isActive] [bit] NOT NULL,
 	[isMaster] [bit] NOT NULL,
- CONSTRAINT [PK_umbracoServer] PRIMARY KEY CLUSTERED 
+ CONSTRAINT [PK_umbracoServer] PRIMARY KEY CLUSTERED
 (
 	[id] ASC
 )WITH (PAD_INDEX = OFF, STATISTICS_NORECOMPUTE = OFF, IGNORE_DUP_KEY = OFF, ALLOW_ROW_LOCKS = ON, ALLOW_PAGE_LOCKS = ON) ON [PRIMARY]
@@ -87,7 +68,7 @@ namespace Umbraco.Tests.Benchmarks
             var dbName = string.Concat("Umb", Guid.NewGuid(), ".sdf");
             AppDomain.CurrentDomain.SetData("DataDirectory", path);
             var sqlCeConnectionString = $"Datasource=|DataDirectory|\\{dbName};Flush Interval=1;";
-            
+
             _dbFile = Path.Combine(path, dbName);
 
             //only create the db one time
@@ -107,12 +88,12 @@ namespace Umbraco.Tests.Benchmarks
                     var creation = new DatabaseSchemaCreation(_dbSqlCe, logger, _sqlCeSyntax);
                     creation.InitializeDatabaseSchema();
                 }
-                _initDbBytes = File.ReadAllBytes(_dbFile);            
+                _initDbBytes = File.ReadAllBytes(_dbFile);
             }
             else
             {
                 File.WriteAllBytes(_dbFile, _initDbBytes);
-            }            
+            }
 
             //create the db
             _dbSqlCe = new UmbracoDatabase(
@@ -138,7 +119,7 @@ namespace Umbraco.Tests.Benchmarks
             return data;
         }
 
-        [Cleanup]
+        [GlobalCleanup]
         public void Cleanup()
         {
             _dbSqlCe.Dispose();

src/Umbraco.Tests.Benchmarks/ConcurrentDictionaryBenchmarks.cs

@@ -0,0 +1,153 @@
+using BenchmarkDotNet.Attributes;
+using System;
+using System.Collections.Concurrent;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Umbraco.Core.Collections;
+
+namespace Umbraco.Tests.Benchmarks
+{
+    [MemoryDiagnoser]
+    public class ConcurrentDictionaryBenchmarks
+    {
+        private static readonly ConcurrentDictionary<CompositeTypeTypeKey, bool> AssignableTypeCache = new ConcurrentDictionary<CompositeTypeTypeKey, bool>();
+
+        private static object input = new Bar();
+
+        private static Type source = typeof(Bar);
+
+        private static Type target = typeof(Foo);
+
+        [Benchmark(Baseline = true)]
+        public bool GetCachedCanAssignFactory()
+        {
+            return AssignableTypeCache.GetOrAdd(new CompositeTypeTypeKey(source, target), k =>
+            {
+                var ksource = k.Type1;
+                var ktarget = k.Type2;
+
+                return ktarget.IsAssignableFrom(ksource) && typeof(IConvertible).IsAssignableFrom(ksource);
+            });
+        }
+
+        [Benchmark]
+        public bool GetCachedCanAssignNoFactory()
+        {
+            // This method is 10% faster
+            var key = new CompositeTypeTypeKey(source, target);
+            bool canConvert;
+            if (AssignableTypeCache.TryGetValue(key, out canConvert))
+            {
+                return canConvert;
+            }
+
+            // "is" is faster than "IsAssignableFrom"
+            if (input is IConvertible && target.IsAssignableFrom(source))
+            {
+                return AssignableTypeCache[key] = true;
+            }
+
+            return AssignableTypeCache[key] = false;
+        }
+
+        private class Foo : IConvertible
+        {
+            public TypeCode GetTypeCode()
+            {
+                return TypeCode.Object;
+            }
+
+            public bool ToBoolean(IFormatProvider provider)
+            {
+                throw new NotImplementedException();
+            }
+
+            public byte ToByte(IFormatProvider provider)
+            {
+                throw new NotImplementedException();
+            }
+
+            public char ToChar(IFormatProvider provider)
+            {
+                throw new NotImplementedException();
+            }
+
+            public DateTime ToDateTime(IFormatProvider provider)
+            {
+                throw new NotImplementedException();
+            }
+
+            public decimal ToDecimal(IFormatProvider provider)
+            {
+                throw new NotImplementedException();
+            }
+
+            public double ToDouble(IFormatProvider provider)
+            {
+                throw new NotImplementedException();
+            }
+
+            public short ToInt16(IFormatProvider provider)
+            {
+                throw new NotImplementedException();
+            }
+
+            public int ToInt32(IFormatProvider provider)
+            {
+                throw new NotImplementedException();
+            }
+
+            public long ToInt64(IFormatProvider provider)
+            {
+                throw new NotImplementedException();
+            }
+
+            public sbyte ToSByte(IFormatProvider provider)
+            {
+                throw new NotImplementedException();
+            }
+
+            public float ToSingle(IFormatProvider provider)
+            {
+                throw new NotImplementedException();
+            }
+
+            public string ToString(IFormatProvider provider)
+            {
+                throw new NotImplementedException();
+            }
+
+            public object ToType(Type conversionType, IFormatProvider provider)
+            {
+                if (conversionType == typeof(Foo))
+                {
+                    return new Foo();
+                }
+
+                throw new NotImplementedException();
+            }
+
+            public ushort ToUInt16(IFormatProvider provider)
+            {
+                throw new NotImplementedException();
+            }
+
+            public uint ToUInt32(IFormatProvider provider)
+            {
+                throw new NotImplementedException();
+            }
+
+            public ulong ToUInt64(IFormatProvider provider)
+            {
+                throw new NotImplementedException();
+            }
+        }
+
+        private class Bar : Foo
+        {
+
+        }
+    }
+}

src/Umbraco.Tests.Benchmarks/Config/QuickRunConfigAttribute.cs

@@ -0,0 +1,33 @@
+using BenchmarkDotNet.Configs;
+using BenchmarkDotNet.Horology;
+using BenchmarkDotNet.Jobs;
+using System;
+
+namespace Umbraco.Tests.Benchmarks.Config
+{
+    /// <summary>
+    /// Configures the benchmark to run with less warmup and a shorter iteration time than the standard benchmark.
+    /// </summary>
+    public class QuickRunConfigAttribute : Attribute, IConfigSource
+    {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="QuickRunConfigAttribute"/> class.
+        /// </summary>
+        public QuickRunConfigAttribute()
+        {
+            Config = (ManualConfig) ManualConfig.CreateEmpty()
+                .With(Job.Default.WithLaunchCount(1) // benchmark process will be launched only once
+                .WithIterationTime(new TimeInterval(100, TimeUnit.Millisecond)) // 100ms per iteration
+                .WithWarmupCount(3) // 3 warmup iteration
+                .WithTargetCount(3)); // 3 target iteration
+        }
+
+        /// <summary>
+        /// Gets the manual configuration.
+        /// </summary>
+        protected ManualConfig Config { get; }
+
+        /// <inheritdoc/>
+        IConfig IConfigSource.Config => Config;
+    }
+}