Handle navigation updates in cache refeshers

src/Umbraco.Core/Cache/Refreshers/Implement/ContentCacheRefresher.cs

@@ -19,6 +19,8 @@
     private readonly IDomainService _domainService;
     private readonly IDocumentUrlService _documentUrlService;
     private readonly IDocumentNavigationQueryService _documentNavigationQueryService;
+    private readonly IDocumentNavigationManagementService _documentNavigationManagementService;
+    private readonly IContentService _contentService;
     private readonly IIdKeyMap _idKeyMap;
     private readonly IPublishedSnapshotService _publishedSnapshotService;
 
@@ -40,7 +42,9 @@
             eventAggregator,
             factory,
             StaticServiceProvider.Instance.GetRequiredService<IDocumentUrlService>(),
-            StaticServiceProvider.Instance.GetRequiredService<IDocumentNavigationQueryService>()
+            StaticServiceProvider.Instance.GetRequiredService<IDocumentNavigationQueryService>(),
+            StaticServiceProvider.Instance.GetRequiredService<IDocumentNavigationManagementService>(),
+            StaticServiceProvider.Instance.GetRequiredService<IContentService>()
             )
     {
 
@@ -55,14 +59,18 @@
         IEventAggregator eventAggregator,
         ICacheRefresherNotificationFactory factory,
         IDocumentUrlService documentUrlService,
-        IDocumentNavigationQueryService documentNavigationQueryService)
+        IDocumentNavigationQueryService documentNavigationQueryService,
+        IDocumentNavigationManagementService documentNavigationManagementService,
+        IContentService contentService)
         : base(appCaches, serializer, eventAggregator, factory)
     {
         _publishedSnapshotService = publishedSnapshotService;
         _idKeyMap = idKeyMap;
         _domainService = domainService;
         _documentUrlService = documentUrlService;
         _documentNavigationQueryService = documentNavigationQueryService;
+        _documentNavigationManagementService = documentNavigationManagementService;
+        _contentService = contentService;
     }
 
     #region Indirect
@@ -126,6 +134,7 @@
 
             HandleRouting(payload);
 
+            HandleNavigation(payload);
             _idKeyMap.ClearCache(payload.Id);
             if (payload.Key.HasValue)
             {
@@ -172,6 +181,102 @@
         base.Refresh(payloads);
     }
 
+    private void HandleNavigation(JsonPayload payload)
+    {
+        if (payload.Key is null)
+        {
+            return;
+        }
+
+        if (payload.ChangeTypes.HasType(TreeChangeTypes.Remove))
+        {
+            _documentNavigationManagementService.MoveToBin(payload.Key.Value);
+            _documentNavigationManagementService.RemoveFromBin(payload.Key.Value);
+        }
+
+        if (payload.ChangeTypes.HasType(TreeChangeTypes.RefreshAll))
+        {
+            _documentNavigationManagementService.RebuildAsync();
+            _documentNavigationManagementService.RebuildBinAsync();
+        }
+
+        if (payload.ChangeTypes.HasType(TreeChangeTypes.RefreshNode))
+        {
+            IContent? content = _contentService.GetById(payload.Id);
+
+            if (content is null)
+            {
+                return;
+            }
+
+            HandleNavigationForSingleContent(content);
+        }
+
+        if (payload.ChangeTypes.HasType(TreeChangeTypes.RefreshBranch))
+        {
+            IContent? content = _contentService.GetById(payload.Id);
+
+            if (content is null)
+            {
+                return;
+            }
+
+            IEnumerable<IContent> descendants = _contentService.GetPagedDescendants(content.Id, 0, int.MaxValue, out _);
+            foreach (IContent descendant in content.Yield().Concat(descendants))
+            {
+                HandleNavigationForSingleContent(descendant);
+            }
+        }
+    }
+
+    private void HandleNavigationForSingleContent(IContent content)
+    {
+        // First creation
+        if (ExistsInNavigation(content.Key) is false && ExistsInNavigationBin(content.Key) is false)
+        {
+            _documentNavigationManagementService.Add(content.Key, GetParentKey(content));
+            if (content.Trashed)
+            {
+                // If created as trashed, move to bin
+                _documentNavigationManagementService.MoveToBin(content.Key);
+            }
+        }
+        else if (ExistsInNavigation(content.Key) && ExistsInNavigationBin(content.Key) is false)
+        {
+            if (content.Trashed)
+            {
+                // It must have been trashed
+                _documentNavigationManagementService.MoveToBin(content.Key);
+            }
+            else
+            {
+                // It must have been saved. Check if parent is different
+                if (_documentNavigationQueryService.TryGetParentKey(content.Key, out var oldParentKey))
+                {
+                    Guid? newParentKey = GetParentKey(content);
+                    if (oldParentKey != newParentKey)
+                    {
+                        _documentNavigationManagementService.Move(content.Key, newParentKey);
+                    }
+                }
+            }
+        }
+        else if (ExistsInNavigation(content.Key) is false && ExistsInNavigationBin(content.Key))
+        {
+            if (content.Trashed is false)
+            {
+                // It must have been restored
+                _documentNavigationManagementService.RestoreFromBin(content.Key, GetParentKey(content));
+            }
+        }
+    }
+
+    private Guid? GetParentKey(IContent content) => (content.ParentId == -1) ? null : _idKeyMap.GetKeyForId(content.ParentId, UmbracoObjectTypes.Document).Result;
+
+    private bool ExistsInNavigation(Guid contentKey) => _documentNavigationQueryService.TryGetParentKey(contentKey, out _);
+
+    private bool ExistsInNavigationBin(Guid contentKey) => _documentNavigationQueryService.TryGetParentKeyInBin(contentKey, out _);
+
     private void HandleRouting(JsonPayload payload)
     {
         if(payload.ChangeTypes.HasType(TreeChangeTypes.Remove))

src/Umbraco.Core/Cache/Refreshers/Implement/MediaCacheRefresher.cs

@@ -6,13 +6,17 @@
 using Umbraco.Cms.Core.Serialization;
 using Umbraco.Cms.Core.Services;
 using Umbraco.Cms.Core.Services.Changes;
+using Umbraco.Cms.Core.Services.Navigation;
 using Umbraco.Extensions;
 
 namespace Umbraco.Cms.Core.Cache;
 
 public sealed class MediaCacheRefresher : PayloadCacheRefresherBase<MediaCacheRefresherNotification, MediaCacheRefresher.JsonPayload>
 {
     private readonly IIdKeyMap _idKeyMap;
+    private readonly IMediaNavigationQueryService _mediaNavigationQueryService;
+    private readonly IMediaNavigationManagementService _mediaNavigationManagementService;
+    private readonly IMediaService _mediaService;
     private readonly IPublishedSnapshotService _publishedSnapshotService;
 
     public MediaCacheRefresher(
@@ -21,11 +25,17 @@
         IPublishedSnapshotService publishedSnapshotService,
         IIdKeyMap idKeyMap,
         IEventAggregator eventAggregator,
-        ICacheRefresherNotificationFactory factory)
+        ICacheRefresherNotificationFactory factory,
+        IMediaNavigationQueryService mediaNavigationQueryService,
+        IMediaNavigationManagementService mediaNavigationManagementService,
+        IMediaService mediaService)
         : base(appCaches, serializer, eventAggregator, factory)
     {
         _publishedSnapshotService = publishedSnapshotService;
         _idKeyMap = idKeyMap;
+        _mediaNavigationQueryService = mediaNavigationQueryService;
+        _mediaNavigationManagementService = mediaNavigationManagementService;
+        _mediaService = mediaService;
     }
 
     #region Indirect
@@ -84,35 +94,133 @@
                 _idKeyMap.ClearCache(payload.Id);
             }
 
-            if (!mediaCache.Success)
+            if (mediaCache.Success)
             {
-                continue;
+                // 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, 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))
+                {
+                    var pathid = "," + payload.Id + ",";
+                    mediaCache.Result?.ClearOfType<IMedia>((_, v) => v.Path?.Contains(pathid) ?? false);
+                }
             }
 
-            // 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, 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))
-            {
-                var pathid = "," + payload.Id + ",";
-                mediaCache.Result?.ClearOfType<IMedia>((_, v) => v.Path?.Contains(pathid) ?? false);
-            }
+            HandleNavigation(payload);
         }
 
         _publishedSnapshotService.Notify(payloads, out var hasPublishedDataChanged);
         // we only need to clear this if the published cache has changed
         if (hasPublishedDataChanged)
         {
             AppCaches.ClearPartialViewCache();
         }
 
+
         base.Refresh(payloads);
     }
 
+    private void HandleNavigation(JsonPayload payload)
+    {
+        if (payload.Key is null)
+        {
+            return;
+        }
+
+        if (payload.ChangeTypes.HasType(TreeChangeTypes.Remove))
+        {
+            _mediaNavigationManagementService.MoveToBin(payload.Key.Value);
+            _mediaNavigationManagementService.RemoveFromBin(payload.Key.Value);
+        }
+
+        if (payload.ChangeTypes.HasType(TreeChangeTypes.RefreshAll))
+        {
+            _mediaNavigationManagementService.RebuildAsync();
+            _mediaNavigationManagementService.RebuildBinAsync();
+        }
+
+        if (payload.ChangeTypes.HasType(TreeChangeTypes.RefreshNode))
+        {
+            IMedia? media = _mediaService.GetById(payload.Id);
+
+            if (media is null)
+            {
+                return;
+            }
+
+            HandleNavigationForSingleMedia(media);
+        }
+
+        if (payload.ChangeTypes.HasType(TreeChangeTypes.RefreshBranch))
+        {
+            IMedia? media = _mediaService.GetById(payload.Id);
+
+            if (media is null)
+            {
+                return;
+            }
+
+            IEnumerable<IMedia> descendants = _mediaService.GetPagedDescendants(media.Id, 0, int.MaxValue, out _);
+            foreach (IMedia descendant in media.Yield().Concat(descendants))
+            {
+                HandleNavigationForSingleMedia(descendant);
+            }
+        }
+    }
+
+    private void HandleNavigationForSingleMedia(IMedia media)
+    {
+        // First creation
+        if (ExistsInNavigation(media.Key) is false && ExistsInNavigationBin(media.Key) is false)
+        {
+            _mediaNavigationManagementService.Add(media.Key, GetParentKey(media));
+            if (media.Trashed)
+            {
+                // If created as trashed, move to bin
+                _mediaNavigationManagementService.MoveToBin(media.Key);
+            }
+        }
+        else if (ExistsInNavigation(media.Key) && ExistsInNavigationBin(media.Key) is false)
+        {
+            if (media.Trashed)
+            {
+                // It must have been trashed
+                _mediaNavigationManagementService.MoveToBin(media.Key);
+            }
+            else
+            {
+                // It must have been saved. Check if parent is different
+                if (_mediaNavigationQueryService.TryGetParentKey(media.Key, out var oldParentKey))
+                {
+                    Guid? newParentKey = GetParentKey(media);
+                    if (oldParentKey != newParentKey)
+                    {
+                        _mediaNavigationManagementService.Move(media.Key, newParentKey);
+                    }
+                }
+            }
+        }
+        else if (ExistsInNavigation(media.Key) is false && ExistsInNavigationBin(media.Key))
+        {
+            if (media.Trashed is false)
+            {
+                // It must have been restored
+                _mediaNavigationManagementService.RestoreFromBin(media.Key, GetParentKey(media));
+            }
+        }
+    }
+
+    private Guid? GetParentKey(IMedia media) => (media.ParentId == -1) ? null : _idKeyMap.GetKeyForId(media.ParentId, UmbracoObjectTypes.Media).Result;
+
+    private bool ExistsInNavigation(Guid contentKey) => _mediaNavigationQueryService.TryGetParentKey(contentKey, out _);
+
+    private bool ExistsInNavigationBin(Guid contentKey) => _mediaNavigationQueryService.TryGetParentKeyInBin(contentKey, out _);
+
+
     // these events should never trigger
     // everything should be JSON
     public override void RefreshAll() => throw new NotSupportedException();