Merge branch 'umbraco:main' into main

Author: im-effect

13/umbraco-cms/SUMMARY.md

@@ -353,6 +353,7 @@
     * [TextService](reference/management/services/textservice.md)
     * [ContentService](reference/management/services/contentservice/README.md)
       * [Create content programmatically](reference/management/services/contentservice/create-content-programmatically.md)
+      * [Publish content programmatically](reference/management/services/contentservice/publish-content-programmatically.md)
     * [ContentTypeService](reference/management/services/contenttypeservice/README.md)
       * [Retrieving content types](reference/management/services/contenttypeservice/retrieving-content-type-containers.md)
       * [Retrieving content types](reference/management/services/contenttypeservice/retrieving-content-types.md)

13/umbraco-cms/reference/configuration/contentsettings.md

@@ -47,7 +47,8 @@ The following snippet will give an overview of the keys and values in the conten
       "PreviewBadge": "<![CDATA[<b>My HTML here</b>]]>",
       "ResolveUrlsFromTextString": false,
       "ShowDeprecatedPropertyEditors": false,
-      "ShowDomainWarnings": true
+      "ShowDomainWarnings": true,
+      "ShowUnroutableContentWarnings": true
     }
   }
 }
@@ -174,15 +175,23 @@ This setting is used for controlling whether or not the Data Types marked as obs
 
 By default this is set to `false`. To make the obsolete data types visible in the dropdown change the value to `true`.
 
-### Show Domain Warnings
+### Show domain warnings
 
 If you do not configure Domains for each language in a multilingual site then every time you publish your content you get this warning:
 
 `Content published: Domains are not configured for multilingual site, please contact an administrator, see log for more information.`
 
 If you have a use case for not setting the domains, you can set this setting **ShowDomainWarnings** to `false` to stop the warning from displaying.
 
-## ContentVersionCleanupPolicy
+### Show unroutable content warnings
+
+If your routing setup leads to more than one document having the same URL, on publish a warning will be displayed:
+
+`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.`
+
+To suppress these warnings, set this option to `false`.
+
+## Content version cleanup policy
 
 The global settings for the scheduled job which cleans historic content versions. These settings can be overridden per Document Type.
 
@@ -200,19 +209,19 @@ See [Content Version Cleanup](../../fundamentals/data/content-version-cleanup.md
 
 To retain only the current draft and published version, set both the "keep" settings values to 0. The next time the scheduled job runs (hourly) all non-current versions (except those marked "prevent cleanup") will be removed.
 
-### EnableCleanup
+### Enable cleanup
 
 When set to `true`, a scheduled job will delete historic content versions that are not retained according to the policy every hour.
 
 When set to `false`, the scheduled job will not delete any content versions, regardless of any overridden settings for a Document Type.
 
 The dotnet new template provides an `appsettings.json` file with the default value set to `true` for all sites.
 
-### KeepAllVersionsNewerThanDays
+### Keep all versions newer than days
 
 All versions that fall in this period will be kept.
 
-### KeepLatestVersionPerDayForDays
+### Keep latest version per day for days
 
 For content versions that fall in this period, the most recent version for each day is kept. All previous versions for that day are removed unless marked as preventCleanup.
 
@@ -237,11 +246,11 @@ This section is used for managing how Umbraco handles images, allowed attributes
 
 Let's break it down.
 
-### ImageFileTypes
+### Image file types
 
 This is a separated list of accepted image formats
 
-### AutoFillImageProperties
+### Auto fill image properties
 
 You can define what properties should be automatically updated when an image is being uploaded. This means that if you decide to rename the default **umbracoWidth** and **umbracoHeight** properties the values in **`"WidthFieldAlias"`** and **`"HeightFieldAlias"`** need to be updated. This needs to happen in order to automatically populate the values when the image is being uploaded.
 

13/umbraco-cms/reference/management/services/contentservice/publish-content-programmatically.md

@@ -0,0 +1,35 @@
+# Publishing content programmatically
+
+The ContentService is also used for publishing operations.
+
+The following example shows a page being published with all descendants.
+
+```csharp
+using Umbraco.Cms.Core.Models;
+using Umbraco.Cms.Core.Services;
+
+namespace Umbraco.Cms.Web.UI.Custom;
+
+public class PublishContentDemo
+{
+    private readonly IContentService _contentService;
+
+    public PublishContentDemo(IContentService contentService) => _contentService = contentService;
+
+    public void Publish(Guid key)
+    {
+        IContent? content = _contentService.GetById(key)
+            ?? throw new InvalidOperationException($"Could not find content with key: {key}.");
+
+        _contentService.SaveAndPublishBranch(content, PublishBranchFilter.Default);
+    }
+}
+```
+
+The `PublishBranchFilter` option can include one or more of the following flags:
+
+- `Default` - publishes existing published content with pending changes.
+- `IncludeUnpublished` - publishes unpublished content and existing published content with pending changes.
+- `ForceRepublish` - publishes existing published content with or without pending changes.
+- `All` - combines `IncludeUnpublished` and `ForceRepublish`.
+

13/umbraco-cms/tutorials/editors-manual/getting-started-with-umbraco/creating-saving-and-publishing-content.md

@@ -65,8 +65,7 @@ To publish the node with descendants, follow these steps:
 3.  Select **Publish with descendants**.
 
     ![Publish with descendants](../../../../../10/umbraco-cms/tutorials/editors-manual/getting-started-with-umbraco/images/Publish-with-descendants-v9.png)
-4.  Toggle the option to **Include unpublished content items** if you wish to. This option includes all unpublished content items for the selected page and the available linked pages.
-
+4.  Toggle the option to **Include unpublished content items** if you wish to. This option includes all unpublished content items for the selected page and the descendant pages.
     ![Publish with descendants](../../../../../10/umbraco-cms/tutorials/editors-manual/getting-started-with-umbraco/images/Publish-with-descendants2-v9.png)
 
 #### 3: Unpublish

13/umbraco-engage/developers/analytics/location.md

@@ -106,3 +106,10 @@ If the pageviews contain location information, the table with countries is displ
 <figure><img src="../../.gitbook/assets/image (1) (4).png" alt="Location table - missing data error"><figcaption><p>Location table with data</p></figcaption></figure>
 
 From the country, you can drill down to the city. This will then filter the displayed graph and table data to only display session and pageview information for the selected country. Even though Umbraco Engage does support the storage for county and province, the UI only supports displaying data by country and city.
+
+### Community package
+
+A community package called "[Engage LocationHeaders](https://github.com/hjaltedaniel-umbraco/Umbraco.Community.Engage.LocationHeaders)" is available. It's a lightweight package that enriches analytics and segmentation data with location information extracted from the HTTP headers, based on the sample code above.
+
+The package is designed to work out-of-the-box on **Umbraco Cloud**, using location headers automatically injected by services like **Cloudflare** or **Azure Front Door**. This allows Umbraco Engage to tap into geographic information such as **country**, **region**, and **city**, without the need for client-side geolocation or third-party services.
+

15/umbraco-cms/SUMMARY.md

@@ -362,6 +362,7 @@
   * [Determining if an entity is new](reference/notifications/determining-new-entity.md)
   * [MediaService Notifications Example](reference/notifications/mediaservice-notifications.md)
   * [MemberService Notifications Example](reference/notifications/memberservice-notifications.md)
+  * [UserService Notifications Example](reference/notifications/userservice-notifications.md)
   * [Sending Allowed Children Notification](reference/notifications/sendingallowedchildrennotifications.md)
   * [Umbraco Application Lifetime Notifications](reference/notifications/umbracoapplicationlifetime-notifications.md)
   * [EditorModel Notifications](reference/notifications/editormodel-notifications/README.md)

15/umbraco-cms/customizing/extending-overview/extension-registry/README.md

@@ -14,6 +14,6 @@ The extension registry is a global registry that can be accessed and changed at
 
 Each Extension Manifest has to declare its type, this is used to determine where it hooks into the system. It also looks at what data is required to declare within it.
 
-## [Replace, Exclude or Unregistere](./#replace-exclude-or-unregistere)
+## [Replace, Exclude, or Unregister](replace-exclude-or-unregister.md)
 
 Once you understand how to declare your own, you may want to replace or remove existing.

15/umbraco-cms/customizing/extending-overview/extension-registry/replace-exclude-or-unregister.md

@@ -54,12 +54,12 @@ UmbExtensionRegistry.exclude('Umb.WorkspaceAction.Document.SaveAndPreview');
 
 ## Unregister
 
-You can also choose to unregister an extension, this is only preferred if you registered the extension and are in control of the flow. If its not your Extension please seek to use the `Overwrites` or `Exclude` feature.
+You can also choose to unregister an extension, this is only preferred if you registered the extension and are in control of the flow. If it's not your Extension please seek to use the `Overwrites` or `Exclude` feature.
 
 ```typescript
-import { UmbExtensionRegistry } from '@umbraco-cms/backoffice/extension-api';
+import { umbExtensionsRegistry } from '@umbraco-cms/backoffice/extension-registry';
 
-UmbExtensionRegistry.unregister('My.WorkspaceAction.AutoFillWithUnicorns');
+umbExtensionsRegistry.unregister('My.WorkspaceAction.AutoFillWithUnicorns');
 ```
 
 This will not prevent the Extension from being registered again.

15/umbraco-cms/fundamentals/backoffice/property-editors/built-in-umbraco-property-editors/rich-text-editor/extensions.md

@@ -70,8 +70,8 @@ export const manifests: Array<UmbExtensionManifest> = [
     {
         type: 'tiptapExtension',
         kind: 'button',
-        alias: 'My Highlight Tiptap Extension',
-        name: 'My.Tiptap.Highlight',
+        alias: 'My.Tiptap.Highlight',
+        name: 'My Highlight Tiptap Extension',
         api: () => import('./highlight.tiptap-api.js'),
         meta:{
             icon: "icon-thumbnail-list",

15/umbraco-cms/reference/content-type-filters.md

@@ -1,5 +1,5 @@
 ---
-description: Describes how to use Content Type Filters to restrict the allowed content options available to editors.
+description: Describes how to use Allowed Content Type Filters to restrict the allowed content options available to editors.
 ---
 
 # Filtering Allowed Content Types
@@ -23,27 +23,45 @@ There are two methods you can implement:
 * One for filtering the content types allowed at the content root
 * One for the content types allowed below a given parent node.
 
-If you don't want to filter using one of the two approaches, you can return the provided collection unmodified.
+If you don't want to filter using one of the two approaches, you can omit the implementation of that method. The default implementation will return the provided collection unmodified.
 
 ### Example Use Case
 
-The following example shows a typical use case. Often websites will have a "Home Page" Document Type which is created at the root. Normally, only one of these is required. You can enforce that using the following Content Type Filter.
+The following example shows an illustrative but also typical use case. Often websites will have a "Home Page" Document Type which is created at the root. Normally, only one of these is required. You can enforce that using the following Content Type Filter.
 
-The code below is querying the existing content available at the root. Normally you can create a "Home Page" here, but if one already exists that option is removed:
+The code below is querying the existing content available at the root. Normally you can create a "Home Page" here, but if one already exists that option is removed.
+
+It then shows how to limit the allowed children by only permitting a single "Landing Page" under the "Home Page" Document Type.
 
 ```csharp
-internal class OneHomePageOnlyContentTypeFilter : IContentTypeFilter
+using Umbraco.Cms.Core;
+using Umbraco.Cms.Core.Composing;
+using Umbraco.Cms.Core.Models;
+using Umbraco.Cms.Core.Services;
+using Umbraco.Cms.Core.Services.Filters;
+
+internal class MyContentTypeFilter : IContentTypeFilter
 {
+    private const string HomePageDocTypeAlias = "homePage";
+    private const string LandingPageDocTypeAlias = "landingPage";
+
     private readonly IContentService _contentService;
+    private readonly IContentTypeService _contentTypeService;
+    private readonly IIdKeyMap _idKeyMap;
 
-    public OneHomePageOnlyContentTypeFilter(IContentService contentService) => _contentService = contentService;
+    public MyContentTypeFilter(IContentService contentService, IContentTypeService contentTypeService, IIdKeyMap idKeyMap)
+    {
+        _contentService = contentService;
+        _contentTypeService = contentTypeService;
+        _idKeyMap = idKeyMap;
+    }
 
     public Task<IEnumerable<TItem>> FilterAllowedAtRootAsync<TItem>(IEnumerable<TItem> contentTypes)
         where TItem : IContentTypeComposition
     {
+        // Only allow one home page at the root.
         var docTypeAliasesToExclude = new List<string>();
 
-        const string HomePageDocTypeAlias = "homePage";
         var docTypeAliasesAtRoot = _contentService.GetRootContent()
             .Select(x => x.ContentType.Alias)
             .Distinct()
@@ -57,12 +75,47 @@ internal class OneHomePageOnlyContentTypeFilter : IContentTypeFilter
             .Where(x => docTypeAliasesToExclude.Contains(x.Alias) is false));
     }
 
-    public Task<IEnumerable<ContentTypeSort>> FilterAllowedChildrenAsync(IEnumerable<ContentTypeSort> contentTypes, Guid parentKey)
-        => Task.FromResult(contentTypes);
+    public Task<IEnumerable<ContentTypeSort>> FilterAllowedChildrenAsync(
+        IEnumerable<ContentTypeSort> contentTypes,
+        Guid parentContentTypeKey,
+        Guid? parentContentKey)
+    {
+        // Only allow one landing page when under a home page.
+        if (parentContentKey.HasValue is false)
+        {
+            return Task.FromResult(contentTypes);
+        }
+
+        IContentType? docType = _contentTypeService.Get(parentContentTypeKey);
+        if (docType is null || docType.Alias != HomePageDocTypeAlias)
+        {
+            return Task.FromResult(contentTypes);
+        }
+
+        var docTypeAliasesToExclude = new List<string>();
+
+        Attempt<int> parentContentIdAttempt = _idKeyMap.GetIdForKey(parentContentKey.Value, UmbracoObjectTypes.Document);
+        if (parentContentIdAttempt.Success is false)
+        {
+            return Task.FromResult(contentTypes);
+        }
+
+        var docTypeAliasesAtFolder = _contentService.GetPagedChildren(parentContentIdAttempt.Result, 0, int.MaxValue, out _)
+            .Select(x => x.ContentType.Alias)
+            .Distinct()
+            .ToList();
+        if (docTypeAliasesAtFolder.Contains(LandingPageDocTypeAlias))
+        {
+            docTypeAliasesToExclude.Add(LandingPageDocTypeAlias);
+        }
+
+        return Task.FromResult(contentTypes
+            .Where(x => docTypeAliasesToExclude.Contains(x.Alias) is false));
+    }
 }
 ```
 
-Content Type Filters are registered as a collection, making it possible to have more than one in the solution or an installed package.
+Allowed Content Type Filters are registered as a collection, making it possible to have more than one in the solution or an installed package.
 
 The filters need to be registered in a composer:
 
@@ -72,7 +125,7 @@ public class MyComposer : IComposer
     public void Compose(IUmbracoBuilder builder)
     {
         builder.ContentTypeFilters()
-            .Append<OneHomePageOnlyContentTypeFilter>();
+            .Append<MyContentTypeFilter>();
     }
 }
 ```

15/umbraco-cms/reference/notifications/README.md

@@ -285,5 +285,6 @@ Below you can find some articles with some examples using Notifications.
 * [Hot vs. cold restarts](hot-vs-cold-restarts.md)
 * [MediaService Notifications](mediaservice-notifications.md)
 * [MemberService Notifications](memberservice-notifications.md)
+* [UserService Notifications](userservice-notifications.md)
 * [Sending Allowed Children Notification](sendingallowedchildrennotifications.md)
 * [Umbraco Application Lifetime Notifications](umbracoapplicationlifetime-notifications.md)

15/umbraco-cms/reference/notifications/userservice-notifications.md

@@ -0,0 +1,29 @@
+---
+description: Example of how to use a UserService Notification
+---
+
+# UserService Notifications
+
+The UserService implements `IUserService` and provides access to operations involving `IUser`.
+
+The following example illustrates how to cancel the password reset feature for a given set of users.
+
+## Usage
+
+```csharp
+using Umbraco.Cms.Core.Events;
+using Umbraco.Cms.Core.Notifications;
+
+namespace MySite;
+
+public class UserPasswordResettingNotificationHandler : INotificationHandler<UserPasswordResettingNotification>
+{
+    public void Handle(UserPasswordResettingNotification notification)
+    {
+        if (notification.User.Name?.Contains("Eddie") ?? false)
+        {
+           notification.CancelOperation(new EventMessage("fail", "Can't reset password for users with name containing 'Eddie'"));
+        }
+    }
+}
+```