Implements Public Access in netcore

src/Umbraco.Core/Cache/CacheRefresherBase.cs

@@ -50,7 +50,12 @@ protected CacheRefresherBase(AppCaches appCaches, IEventAggregator eventAggregat
         /// </summary>
         public virtual void RefreshAll()
         {
-            OnCacheUpdated(NotificationFactory.Create<TNotification>(null, MessageType.RefreshAll));
+            // NOTE: We pass in string.Empty here because if we pass in NULL this causes problems with
+            // the underlying ActivatorUtilities.CreateInstance which doesn't seem to support passing in
+            // null to an 'object' parameter and we end up with "A suitable constructor for type 'ZYZ' could not be located."
+            // In this case, all cache refreshers should be checking for the type first before checking for a msg value
+            // so this shouldn't cause any issues.
+            OnCacheUpdated(NotificationFactory.Create<TNotification>(string.Empty, MessageType.RefreshAll));
         }
 
         /// <summary>

src/Umbraco.Core/Cache/ContentCacheRefresher.cs

@@ -55,9 +55,9 @@ public override void Refresh(JsonPayload[] payloads)
             foreach (var payload in payloads.Where(x => x.Id != default))
             {
                 //By INT Id
-                isolatedCache.Clear(RepositoryCacheKeys.GetKey<IContent>(payload.Id));
+                isolatedCache.Clear(RepositoryCacheKeys.GetKey<IContent, int>(payload.Id));
                 //By GUID Key
-                isolatedCache.Clear(RepositoryCacheKeys.GetKey<IContent>(payload.Key));
+                isolatedCache.Clear(RepositoryCacheKeys.GetKey<IContent, Guid?>(payload.Key));
 
                 _idKeyMap.ClearCache(payload.Id);
 

src/Umbraco.Core/Cache/MacroCacheRefresher.cs

@@ -53,7 +53,7 @@ public override void Refresh(string json)
                 var macroRepoCache = AppCaches.IsolatedCaches.Get<IMacro>();
                 if (macroRepoCache)
                 {
-                    macroRepoCache.Result.Clear(RepositoryCacheKeys.GetKey<IMacro>(payload.Id));
+                    macroRepoCache.Result.Clear(RepositoryCacheKeys.GetKey<IMacro, int>(payload.Id));
                 }
             }
 

src/Umbraco.Core/Cache/MediaCacheRefresher.cs

@@ -56,8 +56,8 @@ public override void Refresh(JsonPayload[] payloads)
                     // repository cache
                     // it *was* done for each pathId but really that does not make sense
                     // only need to do it for the current media
-                    mediaCache.Result.Clear(RepositoryCacheKeys.GetKey<IMedia>(payload.Id));
-                    mediaCache.Result.Clear(RepositoryCacheKeys.GetKey<IMedia>(payload.Key));
+                    mediaCache.Result.Clear(RepositoryCacheKeys.GetKey<IMedia, int>(payload.Id));
+                    mediaCache.Result.Clear(RepositoryCacheKeys.GetKey<IMedia, Guid?>(payload.Key));
 
                     // remove those that are in the branch
                     if (payload.ChangeTypes.HasTypesAny(TreeChangeTypes.RefreshBranch | TreeChangeTypes.Remove))

src/Umbraco.Core/Cache/MemberCacheRefresher.cs

@@ -75,8 +75,8 @@ private void ClearCache(params JsonPayload[] payloads)
                 _idKeyMap.ClearCache(p.Id);
                 if (memberCache)
                 {
-                    memberCache.Result.Clear(RepositoryCacheKeys.GetKey<IMember>(p.Id));
-                    memberCache.Result.Clear(RepositoryCacheKeys.GetKey<IMember>(p.Username));
+                    memberCache.Result.Clear(RepositoryCacheKeys.GetKey<IMember, int>(p.Id));
+                    memberCache.Result.Clear(RepositoryCacheKeys.GetKey<IMember, string>(p.Username));
                 }
             }
 

src/Umbraco.Core/Cache/RelationTypeCacheRefresher.cs

@@ -32,7 +32,7 @@ public override void RefreshAll()
         public override void Refresh(int id)
         {
             var cache = AppCaches.IsolatedCaches.Get<IRelationType>();
-            if (cache) cache.Result.Clear(RepositoryCacheKeys.GetKey<IRelationType>(id));
+            if (cache) cache.Result.Clear(RepositoryCacheKeys.GetKey<IRelationType, int>(id));
             base.Refresh(id);
         }
 
@@ -45,7 +45,7 @@ public override void Refresh(Guid id)
         public override void Remove(int id)
         {
             var cache = AppCaches.IsolatedCaches.Get<IRelationType>();
-            if (cache) cache.Result.Clear(RepositoryCacheKeys.GetKey<IRelationType>(id));
+            if (cache) cache.Result.Clear(RepositoryCacheKeys.GetKey<IRelationType, int>(id));
             base.Remove(id);
         }
 

src/Umbraco.Core/Cache/UserCacheRefresher.cs

@@ -40,7 +40,7 @@ public override void Remove(int id)
             var userCache = AppCaches.IsolatedCaches.Get<IUser>();
             if (userCache)
             {
-                userCache.Result.Clear(RepositoryCacheKeys.GetKey<IUser>(id));
+                userCache.Result.Clear(RepositoryCacheKeys.GetKey<IUser, int>(id));
                 userCache.Result.ClearByKey(CacheKeys.UserContentStartNodePathsPrefix + id);
                 userCache.Result.ClearByKey(CacheKeys.UserMediaStartNodePathsPrefix + id);
                 userCache.Result.ClearByKey(CacheKeys.UserAllContentStartNodesPrefix + id);

src/Umbraco.Core/Cache/UserGroupCacheRefresher.cs

@@ -55,7 +55,7 @@ public override void Remove(int id)
             var userGroupCache = AppCaches.IsolatedCaches.Get<IUserGroup>();
             if (userGroupCache)
             {
-                userGroupCache.Result.Clear(RepositoryCacheKeys.GetKey<IUserGroup>(id));
+                userGroupCache.Result.Clear(RepositoryCacheKeys.GetKey<IUserGroup, int>(id));
                 userGroupCache.Result.ClearByKey(CacheKeys.UserGroupGetByAliasCacheKeyPrefix);
             }
 

src/Umbraco.Core/Composing/ICoreComposer.cs

@@ -1,4 +1,4 @@
-namespace Umbraco.Cms.Core.Composing
+namespace Umbraco.Cms.Core.Composing
 {
     /// <summary>
     /// Represents a core <see cref="IComposer"/>.
@@ -7,5 +7,7 @@
     /// <para>Core composers compose after the initial composer, and before user composers.</para>
     /// </remarks>
     public interface ICoreComposer : IComposer
-    { }
+    {
+        // TODO: This should die, there should be exactly zero core composers.
+    }
 }

src/Umbraco.Core/Configuration/Models/GlobalSettings.cs

@@ -14,7 +14,7 @@ internal const string
             StaticReservedPaths = "~/app_plugins/,~/install/,~/mini-profiler-resources/,~/umbraco/,"; // must end with a comma!
 
         internal const string
-            StaticReservedUrls = "~/config/splashes/noNodes.aspx,~/.well-known,"; // must end with a comma!
+            StaticReservedUrls = "~/.well-known,"; // must end with a comma!
 
         /// <summary>
         /// Gets or sets a value for the reserved URLs.

src/Umbraco.Core/Configuration/Models/KeepAliveSettings.cs

@@ -1,6 +1,9 @@
 // Copyright (c) Umbraco.
 // See LICENSE for more details.
 
+using System;
+using Umbraco.Cms.Core.Hosting;
+
 namespace Umbraco.Cms.Core.Configuration.Models
 {
     /// <summary>
@@ -16,6 +19,6 @@ public class KeepAliveSettings
         /// <summary>
         /// Gets a value for the keep alive ping URL.
         /// </summary>
-        public string KeepAlivePingUrl => "{umbracoApplicationUrl}/api/keepalive/ping";
+        public string KeepAlivePingUrl => "~/api/keepalive/ping";
     }
 }

src/Umbraco.Core/DependencyInjection/UmbracoBuilder.Events.cs

@@ -23,14 +23,7 @@ public static IUmbracoBuilder AddNotificationHandler<TNotification, TNotificatio
             where TNotificationHandler : INotificationHandler<TNotification>
             where TNotification : INotification
         {
-            // Register the handler as transient. This ensures that anything can be injected into it.
-            var descriptor = new UniqueServiceDescriptor(typeof(INotificationHandler<TNotification>), typeof(TNotificationHandler), ServiceLifetime.Transient);
-
-            if (!builder.Services.Contains(descriptor))
-            {
-                builder.Services.Add(descriptor);
-            }
-
+            builder.Services.AddNotificationHandler<TNotification, TNotificationHandler>();
             return builder;
         }
 
@@ -44,16 +37,39 @@ public static IUmbracoBuilder AddNotificationHandler<TNotification, TNotificatio
         public static IUmbracoBuilder AddNotificationAsyncHandler<TNotification, TNotificationAsyncHandler>(this IUmbracoBuilder builder)
             where TNotificationAsyncHandler : INotificationAsyncHandler<TNotification>
             where TNotification : INotification
+        {
+            builder.Services.AddNotificationAsyncHandler<TNotification, TNotificationAsyncHandler>();
+            return builder;
+        }
+
+        internal static IServiceCollection AddNotificationHandler<TNotification, TNotificationHandler>(this IServiceCollection services)
+            where TNotificationHandler : INotificationHandler<TNotification>
+            where TNotification : INotification
+        {
+            // Register the handler as transient. This ensures that anything can be injected into it.
+            var descriptor = new UniqueServiceDescriptor(typeof(INotificationHandler<TNotification>), typeof(TNotificationHandler), ServiceLifetime.Transient);
+
+            if (!services.Contains(descriptor))
+            {
+                services.Add(descriptor);
+            }
+
+            return services;
+        }
+
+        internal static IServiceCollection AddNotificationAsyncHandler<TNotification, TNotificationAsyncHandler>(this IServiceCollection services)
+            where TNotificationAsyncHandler : INotificationAsyncHandler<TNotification>
+            where TNotification : INotification
         {
             // Register the handler as transient. This ensures that anything can be injected into it.
             var descriptor = new ServiceDescriptor(typeof(INotificationAsyncHandler<TNotification>), typeof(TNotificationAsyncHandler), ServiceLifetime.Transient);
 
-            if (!builder.Services.Contains(descriptor))
+            if (!services.Contains(descriptor))
             {
-                builder.Services.Add(descriptor);
+                services.Add(descriptor);
             }
 
-            return builder;
+            return services;
         }
     }
 }

src/Umbraco.Core/DependencyInjection/UmbracoBuilder.cs

@@ -19,6 +19,7 @@
 using Umbraco.Cms.Core.Editors;
 using Umbraco.Cms.Core.Events;
 using Umbraco.Cms.Core.Features;
+using Umbraco.Cms.Core.Handlers;
 using Umbraco.Cms.Core.Hosting;
 using Umbraco.Cms.Core.Install;
 using Umbraco.Cms.Core.IO;
@@ -31,6 +32,7 @@
 using Umbraco.Cms.Core.Runtime;
 using Umbraco.Cms.Core.Security;
 using Umbraco.Cms.Core.Services;
+using Umbraco.Cms.Core.Services.Notifications;
 using Umbraco.Cms.Core.Sync;
 using Umbraco.Cms.Core.Templates;
 using Umbraco.Cms.Core.Web;
@@ -219,6 +221,10 @@ private void AddCoreServices()
             // which may be replaced by models builder but the default is required to make plain old IPublishedContent
             // instances.
             Services.AddSingleton<IPublishedModelFactory>(factory => factory.CreateDefaultPublishedModelFactory());
+
+            Services
+                .AddNotificationHandler<MemberGroupSavedNotification, PublicAccessHandler>()
+                .AddNotificationHandler<MemberGroupDeletedNotification, PublicAccessHandler>();
         }
     }
 }

src/Umbraco.Core/Extensions/ObjectExtensions.cs

@@ -1,4 +1,4 @@
-// Copyright (c) Umbraco.
+// Copyright (c) Umbraco.
 // See LICENSE for more details.
 
 using System;
@@ -76,10 +76,26 @@ public static T SafeCast<T>(this object input)
         /// <returns>The <see cref="Attempt{T}"/></returns>
         public static Attempt<T> TryConvertTo<T>(this object input)
         {
-            var result = TryConvertTo(input, typeof(T));
+            Attempt<object> result = TryConvertTo(input, typeof(T));
 
             if (result.Success)
+            {
                 return Attempt<T>.Succeed((T)result.Result);
+            }
+
+            if (input == null)
+            {
+                if (typeof(T).IsValueType)
+                {
+                    // fail, cannot convert null to a value type
+                    return Attempt<T>.Fail();
+                }
+                else
+                {
+                    // sure, null can be any object
+                    return Attempt<T>.Succeed((T)input);
+                } 
+            } 
 
             // just try to cast
             try

src/Umbraco.Core/Extensions/RuntimeStateExtensions.cs

@@ -0,0 +1,13 @@
+using Umbraco.Cms.Core;
+using Umbraco.Cms.Core.Services;
+
+namespace Umbraco.Extensions
+{
+    public static class RuntimeStateExtensions
+    {
+        /// <summary>
+        /// Returns true if Umbraco <see cref="IRuntimeState"/> is greater than <see cref="RuntimeLevel.BootFailed"/>
+        /// </summary>
+        public static bool UmbracoCanBoot(this IRuntimeState state) => state.Level > RuntimeLevel.BootFailed;
+    }
+}

src/Umbraco.Core/Compose/AuditNotificationsHandler.cs → src/Umbraco.Core/Handlers/AuditNotificationsHandler.cs

@@ -12,7 +12,7 @@
 using Umbraco.Cms.Core.Services.Notifications;
 using Umbraco.Extensions;
 
-namespace Umbraco.Cms.Core.Compose
+namespace Umbraco.Cms.Core.Handlers
 {
     public sealed class AuditNotificationsHandler :
         INotificationHandler<MemberSavedNotification>,
@@ -61,7 +61,7 @@ private IUser CurrentPerformingUser
             }
         }
 
-        public static IUser UnknownUser(GlobalSettings globalSettings) => new User(globalSettings) { Id = Cms.Core.Constants.Security.UnknownUserId, Name = Cms.Core.Constants.Security.UnknownUserName, Email = "" };
+        public static IUser UnknownUser(GlobalSettings globalSettings) => new User(globalSettings) { Id = Constants.Security.UnknownUserId, Name = Constants.Security.UnknownUserName, Email = "" };
 
         private string PerformingIp => _ipResolver.GetCurrentRequestIpAddress();
 

src/Umbraco.Core/Compose/PublicAccessHandler.cs → src/Umbraco.Core/Handlers/PublicAccessHandler.cs

@@ -6,7 +6,7 @@
 using Umbraco.Cms.Core.Services.Notifications;
 using Umbraco.Extensions;
 
-namespace Umbraco.Cms.Core.Compose
+namespace Umbraco.Cms.Core.Handlers
 {
     public sealed class PublicAccessHandler :
         INotificationHandler<MemberGroupSavedNotification>,

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

@@ -1,5 +1,5 @@
 using System.Collections.Generic;
-using Umbraco.Cms.Core.Models.Identity;
+using Umbraco.Cms.Core.Security;
 
 namespace Umbraco.Cms.Core.Persistence.Repositories
 {

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

@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Collections.Generic;
 
 namespace Umbraco.Cms.Core.Persistence.Repositories
@@ -8,14 +8,30 @@ namespace Umbraco.Cms.Core.Persistence.Repositories
     /// </summary>
     public static class RepositoryCacheKeys
     {
-        private static readonly Dictionary<Type, string> Keys = new Dictionary<Type, string>();
+        // used to cache keys so we don't keep allocating strings
+        private static readonly Dictionary<Type, string> s_keys = new Dictionary<Type, string>();
 
         public static string GetKey<T>()
         {
-            var type = typeof(T);
-            return Keys.TryGetValue(type, out var key) ? key : (Keys[type] = "uRepo_" + type.Name + "_");
+            Type type = typeof(T);
+            return s_keys.TryGetValue(type, out var key) ? key : (s_keys[type] = "uRepo_" + type.Name + "_");
         }
 
-        public static string GetKey<T>(object id) => GetKey<T>() + id;
+        public static string GetKey<T, TId>(TId id)
+        {
+            if (EqualityComparer<TId>.Default.Equals(id, default))
+            {
+                return string.Empty;
+            }
+
+            if (typeof(TId).IsValueType)
+            {
+                return GetKey<T>() + id;
+            }
+            else
+            {
+                return GetKey<T>() + id.ToString().ToUpperInvariant();
+            }
+        }
     }
 }

src/Umbraco.Core/PublishedCache/IPublishedMemberCache.cs

@@ -1,9 +1,11 @@
-using System.Xml.XPath;
+using System.Xml.XPath;
 using Umbraco.Cms.Core.Models;
 using Umbraco.Cms.Core.Models.PublishedContent;
 
 namespace Umbraco.Cms.Core.PublishedCache
 {
+    // TODO: Kill this, why do we want this at all?
+    // See https://dev.azure.com/umbraco/D-Team%20Tracker/_workitems/edit/11487
     public interface IPublishedMemberCache : IXPathNavigable
     {
         IPublishedContent GetByProviderKey(object key);