Merge branch 'v11/dev' into contrib

Author: nul800sebastiaan

src/Umbraco.Cms.ManagementApi/DependencyInjection/MappingBuilderExtensions.cs

@@ -6,7 +6,6 @@
 using Umbraco.Cms.ManagementApi.Mapping.Languages;
 using Umbraco.Cms.ManagementApi.Mapping.Relation;
 using Umbraco.Cms.ManagementApi.Mapping.TrackedReferences;
-using Umbraco.New.Cms.Infrastructure.Persistence.Mappers;
 
 namespace Umbraco.Cms.ManagementApi.DependencyInjection;
 
@@ -17,7 +16,6 @@ internal static IUmbracoBuilder AddMappers(this IUmbracoBuilder builder)
         builder.WithCollectionBuilder<MapDefinitionCollectionBuilder>()
             .Add<DictionaryViewModelMapDefinition>()
             .Add<TrackedReferenceViewModelsMapDefinition>()
-            .Add<RelationModelMapDefinition>()
             .Add<RelationViewModelsMapDefinition>()
             .Add<LanguageViewModelsMapDefinition>()
             .Add<InstallerViewModelsMapDefinition>()

src/Umbraco.Core/Security/AuthenticationExtensions.cs

@@ -7,26 +7,56 @@
 
 namespace Umbraco.Extensions;
 
+/// <summary>
+/// Extension methods for <see cref="IIdentity" />.
+/// </summary>
 public static class AuthenticationExtensions
 {
     /// <summary>
-    ///     Ensures that the thread culture is set based on the back office user's culture
+    /// Ensures that the thread culture is set based on the back office user's culture.
     /// </summary>
+    /// <param name="identity">The identity.</param>
     public static void EnsureCulture(this IIdentity identity)
     {
         CultureInfo? culture = GetCulture(identity);
-        if (!(culture is null))
+        if (culture is not null)
         {
             Thread.CurrentThread.CurrentUICulture = Thread.CurrentThread.CurrentCulture = culture;
         }
     }
 
+    /// <summary>
+    /// Gets the culture string from the back office user.
+    /// </summary>
+    /// <param name="identity">The identity.</param>
+    /// <returns>
+    /// The culture string.
+    /// </returns>
+    public static string? GetCultureString(this IIdentity identity)
+    {
+        if (identity is ClaimsIdentity umbIdentity &&
+            umbIdentity.VerifyBackOfficeIdentity(out _) &&
+            umbIdentity.IsAuthenticated)
+        {
+            return umbIdentity.GetCultureString();
+        }
+
+        return null;
+    }
+
+    /// <summary>
+    /// Gets the culture from the back office user.
+    /// </summary>
+    /// <param name="identity">The identity.</param>
+    /// <returns>
+    /// The culture.
+    /// </returns>
     public static CultureInfo? GetCulture(this IIdentity identity)
     {
-        if (identity is ClaimsIdentity umbIdentity && umbIdentity.VerifyBackOfficeIdentity(out _) &&
-            umbIdentity.IsAuthenticated && umbIdentity.GetCultureString() is not null)
+        string? culture = identity.GetCultureString();
+        if (!string.IsNullOrEmpty(culture))
         {
-            return CultureInfo.GetCultureInfo(umbIdentity.GetCultureString()!);
+            return CultureInfo.GetCultureInfo(culture);
         }
 
         return null;

src/Umbraco.Core/Services/ContentService.cs

@@ -1146,6 +1146,8 @@ public PublishResult SaveAndPublish(IContent content, string culture = "*", int
 
             var allLangs = _languageRepository.GetMany().ToList();
 
+            // Change state to publishing
+            content.PublishedState = PublishedState.Publishing;
             var savingNotification = new ContentSavingNotification(content, evtMsgs);
             if (scope.Notifications.PublishCancelable(savingNotification))
             {

src/Umbraco.Infrastructure/DependencyInjection/UmbracoBuilder.MappingProfiles.cs

@@ -3,6 +3,7 @@
 using Umbraco.Cms.Core.Mapping;
 using Umbraco.Cms.Core.Models.Mapping;
 using Umbraco.Cms.Core.Security;
+using Umbraco.Cms.Infrastructure.Mapping;
 using Umbraco.Extensions;
 
 namespace Umbraco.Cms.Infrastructure.DependencyInjection;
@@ -23,6 +24,7 @@ public static IUmbracoBuilder AddCoreMappingProfiles(this IUmbracoBuilder builde
             .Add<ContentTypeMapDefinition>()
             .Add<DataTypeMapDefinition>()
             .Add<EntityMapDefinition>()
+            .Add<RelationModelMapDefinition>()
             .Add<DictionaryMapDefinition>()
             .Add<MacroMapDefinition>()
             .Add<RedirectUrlMapDefinition>()

src/Umbraco.New.Cms.Infrastructure/Persistence/Mappers/RelationModelMapDefinition.cs renamed to src/Umbraco.Infrastructure/Mapping/RelationModelMapDefinition.cs

@@ -2,7 +2,7 @@
 using Umbraco.Cms.Core.Models;
 using Umbraco.Cms.Infrastructure.Persistence.Repositories.Implement;
 
-namespace Umbraco.New.Cms.Infrastructure.Persistence.Mappers;
+namespace Umbraco.Cms.Infrastructure.Mapping;
 
 public class RelationModelMapDefinition : IMapDefinition
 {

src/Umbraco.Infrastructure/PropertyEditors/NestedPropertyIndexValueFactoryBase.cs

@@ -40,6 +40,23 @@ protected NestedPropertyIndexValueFactoryBase(
                 contentType
                     .PropertyGroups
                     .SelectMany(x => x.PropertyTypes!)
+                    .Select(propertyType =>
+                    {
+                        // We want to ensure that the nested properties are set vary by culture if the parent is
+                        // This is because it's perfectly valid to have a nested property type that's set to invariant even if the parent varies.
+                        // For instance in a block list, the list it self can vary, but the elements can be invariant, at the same time.
+                        if (culture is not null)
+                        {
+                            propertyType.Variations |= ContentVariation.Culture;
+                        }
+
+                        if (segment is not null)
+                        {
+                            propertyType.Variations |= ContentVariation.Segment;
+                        }
+
+                        return propertyType;
+                    })
                     .ToDictionary(x => x.Alias);
 
             result.AddRange(GetNestedResults(

src/Umbraco.Web.Common/Localization/DynamicRequestCultureProviderBase.cs

@@ -0,0 +1,86 @@
+using System.Globalization;
+using Microsoft.AspNetCore.Builder;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Localization;
+using Microsoft.Extensions.Primitives;
+
+namespace Umbraco.Cms.Web.Common.Localization;
+
+/// <summary>
+/// Base implementation that dynamically adds the determined cultures to the supported cultures.
+/// </summary>
+public abstract class DynamicRequestCultureProviderBase : RequestCultureProvider
+{
+    private readonly RequestLocalizationOptions _options;
+    private readonly object _lockerSupportedCultures = new();
+    private readonly object _lockerSupportedUICultures = new();
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="DynamicRequestCultureProviderBase" /> class.
+    /// </summary>
+    /// <param name="requestLocalizationOptions">The request localization options.</param>
+    protected DynamicRequestCultureProviderBase(RequestLocalizationOptions requestLocalizationOptions)
+        => _options = Options = requestLocalizationOptions;
+
+    /// <inheritdoc />
+    public override Task<ProviderCultureResult?> DetermineProviderCultureResult(HttpContext httpContext)
+    {
+        ProviderCultureResult? result = GetProviderCultureResult(httpContext);
+        if (result is not null)
+        {
+            // We need to dynamically change the supported cultures since we won't ever know what languages are used since
+            // they are dynamic within Umbraco. We have to handle this for both UI and Region cultures, in case people run different region and UI languages
+            // This code to check existence is borrowed from aspnetcore to avoid creating a CultureInfo
+            // https://github.com/dotnet/aspnetcore/blob/b795ac3546eb3e2f47a01a64feb3020794ca33bb/src/Middleware/Localization/src/RequestLocalizationMiddleware.cs#L165
+            TryAddLocked(_options.SupportedCultures, result.Cultures, _lockerSupportedCultures, (culture) =>
+            {
+                _options.SupportedCultures ??= new List<CultureInfo>();
+                _options.SupportedCultures.Add(CultureInfo.GetCultureInfo(culture.ToString()));
+            });
+
+            TryAddLocked(_options.SupportedUICultures, result.UICultures, _lockerSupportedUICultures, (culture) =>
+            {
+                _options.SupportedUICultures ??= new List<CultureInfo>();
+                _options.SupportedUICultures.Add(CultureInfo.GetCultureInfo(culture.ToString()));
+            });
+
+            return Task.FromResult<ProviderCultureResult?>(result);
+        }
+
+        return NullProviderCultureResult;
+    }
+
+    /// <summary>
+    /// Gets the provider culture result.
+    /// </summary>
+    /// <param name="httpContext">The HTTP context.</param>
+    /// <returns>
+    /// The provider culture result.
+    /// </returns>
+    protected abstract ProviderCultureResult? GetProviderCultureResult(HttpContext httpContext);
+
+    /// <summary>
+    /// Executes the <paramref name="addAction" /> within a double-checked lock when the a culture in <paramref name="cultures" /> does not exist in <paramref name="supportedCultures" />.
+    /// </summary>
+    /// <param name="supportedCultures">The supported cultures.</param>
+    /// <param name="cultures">The cultures.</param>
+    /// <param name="locker">The locker object to use.</param>
+    /// <param name="addAction">The add action to execute.</param>
+    private static void TryAddLocked(IEnumerable<CultureInfo>? supportedCultures, IEnumerable<StringSegment> cultures, object locker, Action<StringSegment> addAction)
+    {
+        foreach (StringSegment culture in cultures)
+        {
+            Func<CultureInfo, bool> predicate = x => culture.Equals(x.Name, StringComparison.OrdinalIgnoreCase);
+            if (supportedCultures?.Any(predicate) is not true)
+            {
+                lock (locker)
+                {
+                    if (supportedCultures?.Any(predicate) is not true)
+                    {
+                        addAction(culture);
+                    }
+                }
+            }
+        }
+    }
+}

src/Umbraco.Web.Common/Localization/UmbracoBackOfficeIdentityCultureProvider.cs

@@ -1,7 +1,6 @@
 // Copyright (c) Umbraco.
 // See LICENSE for more details.
 
-using System.Globalization;
 using Microsoft.AspNetCore.Builder;
 using Microsoft.AspNetCore.Http;
 using Microsoft.AspNetCore.Localization;
@@ -10,50 +9,21 @@
 namespace Umbraco.Cms.Web.Common.Localization;
 
 /// <summary>
-///     Sets the request culture to the culture of the back office user if one is determined to be in the request
+/// Sets the request culture to the culture of the back office user, if one is determined to be in the request.
 /// </summary>
-public class UmbracoBackOfficeIdentityCultureProvider : RequestCultureProvider
+public class UmbracoBackOfficeIdentityCultureProvider : DynamicRequestCultureProviderBase
 {
-    private readonly RequestLocalizationOptions _localizationOptions;
-    private readonly object _locker = new();
-
     /// <summary>
-    ///     Initializes a new instance of the <see cref="UmbracoBackOfficeIdentityCultureProvider" /> class.
+    /// Initializes a new instance of the <see cref="UmbracoBackOfficeIdentityCultureProvider" /> class.
     /// </summary>
-    public UmbracoBackOfficeIdentityCultureProvider(RequestLocalizationOptions localizationOptions) =>
-        _localizationOptions = localizationOptions;
+    /// <param name="localizationOptions">The localization options.</param>
+    public UmbracoBackOfficeIdentityCultureProvider(RequestLocalizationOptions localizationOptions)
+        : base(localizationOptions)
+    { }
 
     /// <inheritdoc />
-    public override Task<ProviderCultureResult?> DetermineProviderCultureResult(HttpContext httpContext)
-    {
-        CultureInfo? culture = httpContext.User.Identity?.GetCulture();
-
-        if (culture is null)
-        {
-            return NullProviderCultureResult;
-        }
-
-        lock (_locker)
-        {
-            // We need to dynamically change the supported cultures since we won't ever know what languages are used since
-            // they are dynamic within Umbraco. We have to handle this for both UI and Region cultures, in case people run different region and UI languages
-            var cultureExists = _localizationOptions.SupportedCultures?.Contains(culture) ?? false;
-
-            if (!cultureExists)
-            {
-                // add this as a supporting culture
-                _localizationOptions.SupportedCultures?.Add(culture);
-            }
-
-            var uiCultureExists = _localizationOptions.SupportedCultures?.Contains(culture) ?? false;
-
-            if (!uiCultureExists)
-            {
-                // add this as a supporting culture
-                _localizationOptions.SupportedUICultures?.Add(culture);
-            }
-
-            return Task.FromResult<ProviderCultureResult?>(new ProviderCultureResult(culture.Name));
-        }
-    }
+    protected sealed override ProviderCultureResult? GetProviderCultureResult(HttpContext httpContext)
+        => httpContext.User.Identity?.GetCultureString() is string culture
+        ? new ProviderCultureResult(culture)
+        : null;
 }

src/Umbraco.Web.Common/Localization/UmbracoPublishedContentCultureProvider.cs

@@ -1,69 +1,27 @@
-using System.Globalization;
 using Microsoft.AspNetCore.Builder;
 using Microsoft.AspNetCore.Http;
 using Microsoft.AspNetCore.Localization;
-using Microsoft.Extensions.Primitives;
 using Umbraco.Cms.Core.Routing;
 using Umbraco.Cms.Web.Common.Routing;
 
 namespace Umbraco.Cms.Web.Common.Localization;
 
 /// <summary>
-///     Sets the request culture to the culture of the <see cref="IPublishedRequest" /> if one is found in the request
+/// Sets the request culture to the culture of the <see cref="IPublishedRequest" />, if one is found in the request.
 /// </summary>
-public class UmbracoPublishedContentCultureProvider : RequestCultureProvider
+public class UmbracoPublishedContentCultureProvider : DynamicRequestCultureProviderBase
 {
-    private readonly RequestLocalizationOptions _localizationOptions;
-    private readonly object _locker = new();
-
     /// <summary>
-    ///     Initializes a new instance of the <see cref="UmbracoPublishedContentCultureProvider" /> class.
+    /// Initializes a new instance of the <see cref="UmbracoPublishedContentCultureProvider" /> class.
     /// </summary>
-    public UmbracoPublishedContentCultureProvider(RequestLocalizationOptions localizationOptions) =>
-        _localizationOptions = localizationOptions;
+    /// <param name="localizationOptions">The localization options.</param>
+    public UmbracoPublishedContentCultureProvider(RequestLocalizationOptions localizationOptions)
+        : base(localizationOptions)
+    { }
 
     /// <inheritdoc />
-    public override Task<ProviderCultureResult?> DetermineProviderCultureResult(HttpContext httpContext)
-    {
-        UmbracoRouteValues? routeValues = httpContext.Features.Get<UmbracoRouteValues>();
-        if (routeValues != null)
-        {
-            var culture = routeValues.PublishedRequest.Culture;
-            if (culture != null)
-            {
-                lock (_locker)
-                {
-                    // We need to dynamically change the supported cultures since we won't ever know what languages are used since
-                    // they are dynamic within Umbraco. We have to handle this for both UI and Region cultures, in case people run different region and UI languages
-                    // This code to check existence is borrowed from aspnetcore to avoid creating a CultureInfo
-                    // https://github.com/dotnet/aspnetcore/blob/b795ac3546eb3e2f47a01a64feb3020794ca33bb/src/Middleware/Localization/src/RequestLocalizationMiddleware.cs#L165
-                    CultureInfo? existingCulture = _localizationOptions.SupportedCultures?.FirstOrDefault(
-                        supportedCulture =>
-                            StringSegment.Equals(supportedCulture.Name, culture, StringComparison.OrdinalIgnoreCase));
-
-                    if (existingCulture == null)
-                    {
-                        // add this as a supporting culture
-                        var ci = CultureInfo.GetCultureInfo(culture);
-                        _localizationOptions.SupportedCultures?.Add(ci);
-                    }
-
-                    CultureInfo? existingUICulture = _localizationOptions.SupportedUICultures?.FirstOrDefault(
-                        supportedCulture =>
-                            StringSegment.Equals(supportedCulture.Name, culture, StringComparison.OrdinalIgnoreCase));
-
-                    if (existingUICulture == null)
-                    {
-                        // add this as a supporting culture
-                        var ci = CultureInfo.GetCultureInfo(culture);
-                        _localizationOptions.SupportedUICultures?.Add(ci);
-                    }
-                }
-
-                return Task.FromResult<ProviderCultureResult?>(new ProviderCultureResult(culture));
-            }
-        }
-
-        return NullProviderCultureResult;
-    }
+    protected sealed override ProviderCultureResult? GetProviderCultureResult(HttpContext httpContext)
+        => httpContext.Features.Get<UmbracoRouteValues>()?.PublishedRequest.Culture is string culture
+        ? new ProviderCultureResult(culture)
+        : null;
 }