Dedicated configuration option to suppress unroutable content warnings

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

@@ -28,6 +28,7 @@ public class ContentSettings
     internal const bool StaticDisableUnpublishWhenReferenced = false;
     internal const bool StaticAllowEditInvariantFromNonDefault = false;
     internal const bool StaticShowDomainWarnings = true;
+    internal const bool StaticShowUnroutableContentWarnings = true;
 
     /// <summary>
     ///     Gets or sets a value for the content notification settings.
@@ -141,4 +142,10 @@ public class ContentSettings
     /// </summary>
     [DefaultValue(StaticShowDomainWarnings)]
     public bool ShowDomainWarnings { get; set; } = StaticShowDomainWarnings;
+
+    /// <summary>
+    /// Gets or sets a value indicating whether to show unroutable content warnings.
+    /// </summary>
+    [DefaultValue(StaticShowUnroutableContentWarnings)]
+    public bool ShowUnroutableContentWarnings { get; set; } = StaticShowUnroutableContentWarnings;
 }

src/Umbraco.Core/Events/AddUnroutableContentWarningsWhenPublishingNotificationHandler.cs

@@ -29,90 +29,91 @@
     private readonly IEventMessagesFactory _eventMessagesFactory;
     private readonly ContentSettings _contentSettings;
 
     public AddUnroutableContentWarningsWhenPublishingNotificationHandler(
         IPublishedRouter publishedRouter,
         IUmbracoContextAccessor umbracoContextAccessor,
         ILanguageService languageService,
         ILocalizedTextService localizedTextService,
         IContentService contentService,
         IVariationContextAccessor variationContextAccessor,
         ILoggerFactory loggerFactory,
         UriUtility uriUtility,
         IPublishedUrlProvider publishedUrlProvider,
         IPublishedContentCache publishedContentCache,
         IDocumentNavigationQueryService navigationQueryService,
         IEventMessagesFactory eventMessagesFactory,
         IOptions<ContentSettings> contentSettings)
     {
         _publishedRouter = publishedRouter;
         _umbracoContextAccessor = umbracoContextAccessor;
         _languageService = languageService;
         _localizedTextService = localizedTextService;
         _contentService = contentService;
         _variationContextAccessor = variationContextAccessor;
         _loggerFactory = loggerFactory;
         _uriUtility = uriUtility;
         _publishedUrlProvider = publishedUrlProvider;
         _publishedContentCache = publishedContentCache;
         _navigationQueryService = navigationQueryService;
         _eventMessagesFactory = eventMessagesFactory;
         _contentSettings = contentSettings.Value;
     }
+
     public async Task HandleAsync(ContentPublishedNotification notification, CancellationToken cancellationToken)
     {
-        if (_contentSettings.ShowDomainWarnings is false)
+        if (_contentSettings.ShowUnroutableContentWarnings is false)
         {
             return;
         }
 
         foreach (IContent content in notification.PublishedEntities)
         {
             string[]? successfulCultures;
             if (content.ContentType.VariesByCulture() is false)
             {
                 // successfulCultures will be null here - change it to a wildcard and utilize this below
                 successfulCultures = ["*"];
             }
             else
             {
                 successfulCultures = content.PublishedCultures.ToArray();
             }
 
             if (successfulCultures?.Any() is not true)
             {
                 return;
             }
 
             if (!_umbracoContextAccessor.TryGetUmbracoContext(out IUmbracoContext? umbracoContext))
             {
                 return;
             }
 
             UrlInfo[] urls = (await content.GetContentUrlsAsync(
                 _publishedRouter,
                 umbracoContext,
                 _languageService,
                 _localizedTextService,
                 _contentService,
                 _variationContextAccessor,
                 _loggerFactory.CreateLogger<IContent>(),
                 _uriUtility,
                 _publishedUrlProvider,
                 _publishedContentCache,
                 _navigationQueryService)).ToArray();
 
 
             EventMessages eventMessages = _eventMessagesFactory.Get();
             foreach (var culture in successfulCultures)
             {
                 if (urls.Where(u => u.Culture == culture || culture == "*").All(u => u.IsUrl is false))
                 {
                     eventMessages.Add(new EventMessage("Content published", "The document does not have a URL, possibly due to a naming collision with another document. More details can be found under Info.", EventMessageType.Warning));
 
                     // only add one warning here, even though there might actually be more
                     break;
                 }
             }
         }
     }
 }