Fix mistakes in 15.0.0 migrations (#17814)

* Fix ConvertLocalLinks migration and add a new migration in case the old one has already run

* RebuildCache

* Clear cache means clear ALL caches

* Fix Block Markup recursion

* Fix Unittest mock constructor

Author: Migaroez

src/Umbraco.Infrastructure/Migrations/MigrationPlanExecutor.cs

@@ -47,6 +47,7 @@ public class MigrationPlanExecutor : IMigrationPlanExecutor
     private readonly IDatabaseCacheRebuilder _databaseCacheRebuilder;
     private readonly IKeyValueService _keyValueService;
     private readonly IServiceScopeFactory _serviceScopeFactory;
+    private readonly AppCaches _appCaches;
     private readonly DistributedCache _distributedCache;
     private readonly IScopeAccessor _scopeAccessor;
     private readonly ICoreScopeProvider _scopeProvider;
@@ -62,7 +63,8 @@ public MigrationPlanExecutor(
         IDatabaseCacheRebuilder databaseCacheRebuilder,
         DistributedCache distributedCache,
         IKeyValueService keyValueService,
-        IServiceScopeFactory serviceScopeFactory)
+        IServiceScopeFactory serviceScopeFactory,
+        AppCaches appCaches)
     {
         _scopeProvider = scopeProvider;
         _scopeAccessor = scopeAccessor;
@@ -72,10 +74,36 @@ public MigrationPlanExecutor(
         _databaseCacheRebuilder = databaseCacheRebuilder;
         _keyValueService = keyValueService;
         _serviceScopeFactory = serviceScopeFactory;
+        _appCaches = appCaches;
         _distributedCache = distributedCache;
         _logger = _loggerFactory.CreateLogger<MigrationPlanExecutor>();
     }
 
+    [Obsolete("Use the non obsoleted constructor instead. Scheduled for removal in v17")]
+    public MigrationPlanExecutor(
+        ICoreScopeProvider scopeProvider,
+        IScopeAccessor scopeAccessor,
+        ILoggerFactory loggerFactory,
+        IMigrationBuilder migrationBuilder,
+        IUmbracoDatabaseFactory databaseFactory,
+        IDatabaseCacheRebuilder databaseCacheRebuilder,
+        DistributedCache distributedCache,
+        IKeyValueService keyValueService,
+        IServiceScopeFactory serviceScopeFactory)
+    : this(
+        scopeProvider,
+        scopeAccessor,
+        loggerFactory,
+        migrationBuilder,
+        databaseFactory,
+        databaseCacheRebuilder,
+        distributedCache,
+        keyValueService,
+        serviceScopeFactory,
+        StaticServiceProvider.Instance.GetRequiredService<AppCaches>())
+    {
+    }
+
     public string Execute(MigrationPlan plan, string fromState) => ExecutePlan(plan, fromState).FinalState;
 
     /// <summary>
@@ -303,6 +331,8 @@ private void RunMigration(Type migrationType, MigrationContext context)
 
     private void RebuildCache()
     {
+        _appCaches.RuntimeCache.Clear();
+        _appCaches.IsolatedCaches.ClearAllCaches();
         _databaseCacheRebuilder.Rebuild();
         _distributedCache.RefreshAllPublishedSnapshot();
     }

src/Umbraco.Infrastructure/Migrations/Upgrade/UmbracoPlan.cs

@@ -105,5 +105,6 @@ protected virtual void DefinePlan()
         To<V_15_0_0.ConvertRichTextEditorProperties>("{37875E80-5CDD-42FF-A21A-7D4E3E23E0ED}");
         To<V_15_0_0.ConvertLocalLinks>("{42E44F9E-7262-4269-922D-7310CB48E724}");
         To<V_15_1_0.RebuildCacheMigration>("{7B51B4DE-5574-4484-993E-05D12D9ED703}");
+        To<V_15_1_0.FixConvertLocalLinks>("{F3D3EF46-1B1F-47DB-B437-7D573EEDEB98}");
     }
 }

src/Umbraco.Infrastructure/Migrations/Upgrade/V_15_0_0/ConvertLocalLinks.cs

@@ -1,7 +1,9 @@
 using System.Collections.Concurrent;
+using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Logging;
 using NPoco;
 using Umbraco.Cms.Core;
+using Umbraco.Cms.Core.DependencyInjection;
 using Umbraco.Cms.Core.Models;
 using Umbraco.Cms.Core.Models.Editors;
 using Umbraco.Cms.Core.Scoping;
@@ -26,7 +28,9 @@ public class ConvertLocalLinks : MigrationBase
     private readonly LocalLinkProcessor _localLinkProcessor;
     private readonly IMediaTypeService _mediaTypeService;
     private readonly ICoreScopeProvider _coreScopeProvider;
+    private readonly LocalLinkMigrationTracker _linkMigrationTracker;
 
+    [Obsolete("Use non obsoleted contructor instead")]
     public ConvertLocalLinks(
         IMigrationContext context,
         IUmbracoContextFactory umbracoContextFactory,
@@ -37,7 +41,8 @@ public ConvertLocalLinks(
         IJsonSerializer jsonSerializer,
         LocalLinkProcessor localLinkProcessor,
         IMediaTypeService mediaTypeService,
-        ICoreScopeProvider coreScopeProvider)
+        ICoreScopeProvider coreScopeProvider,
+        LocalLinkMigrationTracker linkMigrationTracker)
         : base(context)
     {
         _umbracoContextFactory = umbracoContextFactory;
@@ -49,6 +54,33 @@ public ConvertLocalLinks(
         _localLinkProcessor = localLinkProcessor;
         _mediaTypeService = mediaTypeService;
         _coreScopeProvider = coreScopeProvider;
+        _linkMigrationTracker = linkMigrationTracker;
+    }
+
+    public ConvertLocalLinks(
+        IMigrationContext context,
+        IUmbracoContextFactory umbracoContextFactory,
+        IContentTypeService contentTypeService,
+        ILogger<ConvertLocalLinks> logger,
+        IDataTypeService dataTypeService,
+        ILanguageService languageService,
+        IJsonSerializer jsonSerializer,
+        LocalLinkProcessor localLinkProcessor,
+        IMediaTypeService mediaTypeService,
+        ICoreScopeProvider coreScopeProvider)
+        : this(
+            context,
+            umbracoContextFactory,
+            contentTypeService,
+            logger,
+            dataTypeService,
+            languageService,
+            jsonSerializer,
+            localLinkProcessor,
+            mediaTypeService,
+            coreScopeProvider,
+            StaticServiceProvider.Instance.GetRequiredService<LocalLinkMigrationTracker>())
+    {
     }
 
     protected override void Migrate()
@@ -97,6 +129,9 @@ protected override void Migrate()
                     propertyEditorAlias);
             }
         }
+
+        _linkMigrationTracker.MarkFixedMigrationRan();
+        RebuildCache = true;
     }
 
     private bool ProcessPropertyTypes(IPropertyType[] propertyTypes, IDictionary<int, ILanguage> languagesById)

src/Umbraco.Infrastructure/Migrations/Upgrade/V_15_0_0/LocalLinks/ConvertLocalLinkComposer.cs

@@ -13,5 +13,7 @@ public void Compose(IUmbracoBuilder builder)
         builder.Services.AddSingleton<ITypedLocalLinkProcessor, LocalLinkBlockGridProcessor>();
         builder.Services.AddSingleton<ITypedLocalLinkProcessor, LocalLinkRteProcessor>();
         builder.Services.AddSingleton<LocalLinkProcessor>();
+        builder.Services.AddSingleton<LocalLinkProcessorForFaultyLinks>();
+        builder.Services.AddSingleton<LocalLinkMigrationTracker>();
     }
 }

src/Umbraco.Infrastructure/Migrations/Upgrade/V_15_0_0/LocalLinks/LocalLinkMigrationTracker.cs

@@ -0,0 +1,8 @@
+namespace Umbraco.Cms.Infrastructure.Migrations.Upgrade.V_15_0_0.LocalLinks;
+
+public class LocalLinkMigrationTracker
+{
+    public bool HasFixedMigrationRun { get; private set; }
+
+    public void MarkFixedMigrationRan() => HasFixedMigrationRun = true;
+}

src/Umbraco.Infrastructure/Migrations/Upgrade/V_15_0_0/LocalLinks/LocalLinkProcessor.cs

@@ -43,8 +43,8 @@ public string ProcessStringValue(string input)
             string newTagHref;
             if (tag.Udi is not null)
             {
-                newTagHref = $" type=\"{tag.Udi.EntityType}\" "
-                             + tag.TagHref.Replace(tag.Udi.ToString(), tag.Udi.Guid.ToString());
+                newTagHref = tag.TagHref.Replace(tag.Udi.ToString(), tag.Udi.Guid.ToString())
+                             + $"\" type=\"{tag.Udi.EntityType}";
             }
             else if (tag.IntId is not null)
             {
@@ -55,8 +55,8 @@ public string ProcessStringValue(string input)
                     continue;
                 }
 
-                newTagHref = $" type=\"{conversionResult.Value.EntityType}\" "
-                             + tag.TagHref.Replace(tag.IntId.Value.ToString(), conversionResult.Value.Key.ToString());
+                newTagHref = tag.TagHref.Replace(tag.IntId.Value.ToString(), conversionResult.Value.Key.ToString())
+                             + $"\" type=\"{conversionResult.Value.EntityType}";
             }
             else
             {

src/Umbraco.Infrastructure/Migrations/Upgrade/V_15_0_0/LocalLinks/LocalLinkProcessorForFaultyLinks.cs

@@ -0,0 +1,73 @@
+using System.Text.RegularExpressions;
+using Umbraco.Cms.Core;
+using Umbraco.Cms.Core.Models;
+using Umbraco.Cms.Core.Services;
+
+namespace Umbraco.Cms.Infrastructure.Migrations.Upgrade.V_15_0_0.LocalLinks;
+
+[Obsolete("Will be removed in V18")]
+public class LocalLinkProcessorForFaultyLinks
+{
+    private readonly IIdKeyMap _idKeyMap;
+    private readonly IEnumerable<ITypedLocalLinkProcessor> _localLinkProcessors;
+    private const string LocalLinkLocation = "__LOCALLINKLOCATION__";
+    private const string TypeAttributeLocation = "__TYPEATTRIBUTELOCATION__";
+
+    internal static readonly Regex FaultyHrefPattern = new(
+        @"<a (?<faultyHref>href=['""] ?(?<typeAttribute> type=*?['""][^'""]*?['""] )?(?<localLink>\/{localLink:[a-fA-F0-9-]+}['""])).*?>",
+        RegexOptions.IgnoreCase | RegexOptions.Singleline);
+
+    public LocalLinkProcessorForFaultyLinks(
+        IIdKeyMap idKeyMap,
+        IEnumerable<ITypedLocalLinkProcessor> localLinkProcessors)
+    {
+        _idKeyMap = idKeyMap;
+        _localLinkProcessors = localLinkProcessors;
+    }
+
+    public IEnumerable<string> GetSupportedPropertyEditorAliases() =>
+        _localLinkProcessors.SelectMany(p => p.PropertyEditorAliases);
+
+    public bool ProcessToEditorValue(object? editorValue)
+    {
+        ITypedLocalLinkProcessor? processor =
+            _localLinkProcessors.FirstOrDefault(p => p.PropertyEditorValueType == editorValue?.GetType());
+
+        return processor is not null && processor.Process.Invoke(editorValue, ProcessToEditorValue, ProcessStringValue);
+    }
+
+    public string ProcessStringValue(string input)
+    {
+        MatchCollection faultyTags = FaultyHrefPattern.Matches(input);
+
+        foreach (Match fullTag in faultyTags)
+        {
+            var newValue =
+                fullTag.Value.Replace(fullTag.Groups["typeAttribute"].Value, LocalLinkLocation)
+                    .Replace(fullTag.Groups["localLink"].Value, TypeAttributeLocation)
+                    .Replace(LocalLinkLocation, fullTag.Groups["localLink"].Value)
+                    .Replace(TypeAttributeLocation, fullTag.Groups["typeAttribute"].Value);
+            input = input.Replace(fullTag.Value, newValue);
+        }
+
+        return input;
+    }
+
+    private (Guid Key, string EntityType)? CreateIntBasedKeyType(int id)
+    {
+        // very old data, best effort replacement
+        Attempt<Guid> documentAttempt = _idKeyMap.GetKeyForId(id, UmbracoObjectTypes.Document);
+        if (documentAttempt.Success)
+        {
+            return (Key: documentAttempt.Result, EntityType: UmbracoObjectTypes.Document.ToString());
+        }
+
+        Attempt<Guid> mediaAttempt = _idKeyMap.GetKeyForId(id, UmbracoObjectTypes.Media);
+        if (mediaAttempt.Success)
+        {
+            return (Key: mediaAttempt.Result, EntityType: UmbracoObjectTypes.Media.ToString());
+        }
+
+        return null;
+    }
+}

src/Umbraco.Infrastructure/Migrations/Upgrade/V_15_0_0/LocalLinks/LocalLinkRteProcessor.cs

@@ -1,3 +1,4 @@
+using System.Text.RegularExpressions;
 using Umbraco.Cms.Core;
 using Umbraco.Cms.Core.Models.Blocks;
 
@@ -28,6 +29,16 @@ public bool ProcessRichText(
         bool hasChanged = false;
 
         var newMarkup = processStringValue.Invoke(richTextValue.Markup);
+
+        // fix recursive hickup in ConvertRichTextEditorProperties
+        newMarkup = RteBlockHelper.BlockRegex().Replace(
+            newMarkup,
+            match => UdiParser.TryParse(match.Groups["udi"].Value, out GuidUdi? guidUdi)
+                ? match.Value
+                    .Replace(match.Groups["attribute"].Value, "data-content-key")
+                    .Replace(match.Groups["udi"].Value, guidUdi.Guid.ToString("D"))
+                : string.Empty);
+
         if (newMarkup.Equals(richTextValue.Markup) == false)
         {
             hasChanged = true;
@@ -53,3 +64,10 @@ public bool ProcessRichText(
         return hasChanged;
     }
 }
+
+[Obsolete("Will be removed in V18")]
+public static partial class RteBlockHelper
+{
+    [GeneratedRegex("<umb-rte-block.*(?<attribute>data-content-udi)=\"(?<udi>.[^\"]*)\".*<\\/umb-rte-block")]
+    public static partial Regex BlockRegex();
+}