OrchardCMS · hyzx86 · May 20, 2023 · May 20, 2023 · Jan 29, 2024 · Mar 22, 2024
diff --git a/src/OrchardCore.Modules/OrchardCore.Search.Lucene/Handler/LuceneIndexingContentHandler.cs b/src/OrchardCore.Modules/OrchardCore.Search.Lucene/Handler/LuceneIndexingContentHandler.cs
@@ -64,8 +64,8 @@ private static async Task IndexingAsync(ShellScope scope, IEnumerable<ContentCon
             var services = scope.ServiceProvider;
             var contentManager = services.GetRequiredService<IContentManager>();
             var contentItemIndexHandlers = services.GetServices<IContentItemIndexHandler>();
-            var luceneIndexManager = services.GetRequiredService<LuceneIndexManager>();
-            var luceneIndexSettingsService = services.GetRequiredService<LuceneIndexSettingsService>();
+            var indexManager = services.GetRequiredService<LuceneIndexManager>();
+            var indexSettingsService = services.GetRequiredService<LuceneIndexSettingsService>();
             var logger = services.GetRequiredService<ILogger<LuceneIndexingContentHandler>>();
 
             // Multiple items may have been updated in the same scope, e.g through a recipe.
@@ -77,46 +77,83 @@ private static async Task IndexingAsync(ShellScope scope, IEnumerable<ContentCon
                 // Only process the last context.
                 var context = ContextsById.Last();
 
-                ContentItem published = null, latest = null;
-                bool publishedLoaded = false, latestLoaded = false;
-
-                foreach (var indexSettings in await luceneIndexSettingsService.GetSettingsAsync())
+                foreach (var indexSettings in await indexSettingsService.GetSettingsAsync())
                 {
                     var cultureAspect = await contentManager.PopulateAspectAsync<CultureAspect>(context.ContentItem);
                     var culture = cultureAspect.HasCulture ? cultureAspect.Culture.Name : null;
                     var ignoreIndexedCulture = indexSettings.Culture != "any" && culture != indexSettings.Culture;
 
                     if (indexSettings.IndexedContentTypes.Contains(context.ContentItem.ContentType) && !ignoreIndexedCulture)
                     {
-                        if (!indexSettings.IndexLatest && !publishedLoaded)
-                        {
-                            publishedLoaded = true;
-                            published = await contentManager.GetAsync(context.ContentItem.ContentItemId, VersionOptions.Published);
-                        }
-
-                        if (indexSettings.IndexLatest && !latestLoaded)
+                        if (context is RemoveContentContext)
                         {
-                            latestLoaded = true;
-                            latest = await contentManager.GetAsync(context.ContentItem.ContentItemId, VersionOptions.Latest);
+                            await indexManager.DeleteDocumentsAsync(indexSettings.IndexName, new string[] { context.ContentItem.ContentItemId });
+                            continue;
                         }
 
-                        var contentItem = !indexSettings.IndexLatest ? published : latest;
-
-                        if (contentItem == null)
+                        if (!indexSettings.IndexLatest)
                         {
-                            await luceneIndexManager.DeleteDocumentsAsync(indexSettings.IndexName, new string[] { context.ContentItem.ContentItemId });
+                            if (context is PublishContentContext publishContext)
+                            {
+                                if (publishContext.Cancel)
+                                {
+                                    continue;
+                                }
+
+                                if (publishContext.IsPublishing)
+                                {
+                                    await StoreDocumentAsync(publishContext.PublishingItem, contentItemIndexHandlers, indexManager, logger, indexSettings);
+                                }
+                                else
+                                {
+                                    await indexManager.DeleteDocumentsAsync(indexSettings.IndexName, new string[] { context.ContentItem.ContentItemId });
+                                }
+                            }
+                            else if (context is UpdateContentContext updateContext)
+                            {
+                                await indexManager.DeleteDocumentsAsync(indexSettings.IndexName, new string[] { context.ContentItem.ContentItemId });
+                            }
                         }
                         else
                         {
-                            var buildIndexContext = new BuildIndexContext(new DocumentIndex(contentItem.ContentItemId, contentItem.ContentItemVersionId), contentItem, new string[] { contentItem.ContentType }, new LuceneContentIndexSettings());
-                            await contentItemIndexHandlers.InvokeAsync(x => x.BuildIndexAsync(buildIndexContext), logger);
-
-                            await luceneIndexManager.DeleteDocumentsAsync(indexSettings.IndexName, new string[] { contentItem.ContentItemId });
-                            await luceneIndexManager.StoreDocumentsAsync(indexSettings.IndexName, new DocumentIndex[] { buildIndexContext.DocumentIndex });
+                            if (context is PublishContentContext publishContext)
+                            {
+                                if (publishContext.Cancel)
+                                {
+                                    continue;
+                                }
+
+                                if (publishContext.IsPublishing)
+                                {
+                                    await StoreDocumentAsync(publishContext.PublishingItem, contentItemIndexHandlers,indexManager, logger, indexSettings);
+                                }
+                                else
+                                {
+                                    await indexManager.DeleteDocumentsAsync(indexSettings.IndexName, new string[] { context.ContentItem.ContentItemId });
+                                }
+                            }
+                            else if (context is UpdateContentContext updateContext)
+                            {
+                                await StoreDocumentAsync(updateContext.UpdatingItem, contentItemIndexHandlers, indexManager, logger, indexSettings);
+                            }
+                            else if (context is CreateContentContext createContext)
+                            {
+                                await StoreDocumentAsync(createContext.CreatingItem, contentItemIndexHandlers, indexManager, logger, indexSettings);
+                            }
                         }
                     }
                 }
             }
         }
+
+        private static async Task StoreDocumentAsync(ContentItem contentItem, IEnumerable<IContentItemIndexHandler> contentItemIndexHandlers, LuceneIndexManager luceneIndexManager, ILogger logger, LuceneIndexSettings indexSettings)
+        {
+
+            var buildIndexContext = new BuildIndexContext(new DocumentIndex(contentItem.ContentItemId, contentItem.ContentItemVersionId), contentItem, new string[] { contentItem.ContentType }, new LuceneContentIndexSettings());
+            await contentItemIndexHandlers.InvokeAsync(x => x.BuildIndexAsync(buildIndexContext), logger);
+
+            await luceneIndexManager.DeleteDocumentsAsync(indexSettings.IndexName, new string[] { contentItem.ContentItemId });
+            await luceneIndexManager.StoreDocumentsAsync(indexSettings.IndexName, new DocumentIndex[] { buildIndexContext.DocumentIndex });
+        }
     }
 }
diff --git a/src/OrchardCore/OrchardCore.ContentManagement.Abstractions/Handlers/CreateContentContext.cs b/src/OrchardCore/OrchardCore.ContentManagement.Abstractions/Handlers/CreateContentContext.cs
@@ -4,6 +4,9 @@ public class CreateContentContext : ContentContextBase
     {
         public CreateContentContext(ContentItem contentItem) : base(contentItem)
         {
+            CreatingItem = contentItem;
         }
+
+        public ContentItem CreatingItem { get; private set; }
     }
 }
diff --git a/src/OrchardCore/OrchardCore.ContentManagement.Abstractions/Handlers/PublishContentContext.cs b/src/OrchardCore/OrchardCore.ContentManagement.Abstractions/Handlers/PublishContentContext.cs
@@ -2,15 +2,18 @@ namespace OrchardCore.ContentManagement.Handlers
 {
     public class PublishContentContext : ContentContextBase
     {
-        public PublishContentContext(ContentItem contentItem, ContentItem previousContentItem) : base(contentItem)
+        public PublishContentContext(ContentItem contentItem, ContentItem previousContentItem, bool isPublishing = true) : base(contentItem)
         {
-            PublishingItem = contentItem;
+            PublishingItem = isPublishing ? contentItem : null;
             PreviousItem = previousContentItem;
+            IsPublishing = isPublishing;
         }
 
-        public ContentItem PublishingItem { get; set; }
-        public ContentItem PreviousItem { get; set; }
+        public ContentItem PublishingItem { get; private set; }
+        public ContentItem PreviousItem { get; private set; }
 
         public bool Cancel { get; set; }
+
+        public bool IsPublishing { get; private set; } = true;
     }
 }
diff --git a/src/OrchardCore/OrchardCore.ContentManagement.Abstractions/Handlers/UpdateContentContext.cs b/src/OrchardCore/OrchardCore.ContentManagement.Abstractions/Handlers/UpdateContentContext.cs
@@ -7,6 +7,6 @@ public UpdateContentContext(ContentItem contentItem) : base(contentItem)
             UpdatingItem = contentItem;
         }
 
-        public ContentItem UpdatingItem { get; set; }
+        public ContentItem UpdatingItem { get; private set; }
     }
 }
diff --git a/src/OrchardCore/OrchardCore.ContentManagement/DefaultContentManager.cs b/src/OrchardCore/OrchardCore.ContentManagement/DefaultContentManager.cs
@@ -476,10 +476,7 @@ public async Task UnpublishAsync(ContentItem contentItem)
             // Create a context for the item. the publishing version is null in this case
             // and the previous version is the one active prior to unpublishing. handlers
             // should take this null check into account
-            var context = new PublishContentContext(contentItem, publishedItem)
-            {
-                PublishingItem = null
-            };
+            var context = new PublishContentContext(contentItem, publishedItem, false);
 
             await Handlers.InvokeAsync((handler, context) => handler.UnpublishingAsync(context), context, _logger);
 

diff --git a/...chardCore/OrchardCore.Search.AzureAI.Core/Handlers/AzureAISearchIndexingContentHandler.cs b/...chardCore/OrchardCore.Search.AzureAI.Core/Handlers/AzureAISearchIndexingContentHandler.cs
@@ -60,23 +60,19 @@ private static async Task IndexingAsync(ShellScope scope, IEnumerable<ContentCon
         var services = scope.ServiceProvider;
         var contentManager = services.GetRequiredService<IContentManager>();
         var contentItemIndexHandlers = services.GetServices<IContentItemIndexHandler>();
-
+        var indexManager = services.GetRequiredService<AzureAIIndexDocumentManager>();
         var indexSettingsService = services.GetRequiredService<AzureAISearchIndexSettingsService>();
         var logger = services.GetRequiredService<ILogger<AzureAISearchIndexingContentHandler>>();
-        var indexDocumentManager = services.GetRequiredService<AzureAIIndexDocumentManager>();
 
         // Multiple items may have been updated in the same scope, e.g through a recipe.
-        var contextsGroupById = contexts.GroupBy(c => c.ContentItem.ContentItemId);
+        var contextsGroupById = contexts.GroupBy(c => c.ContentItem.ContentItemId, c => c);
 
         // Get all contexts for each content item id.
         foreach (var ContextsById in contextsGroupById)
         {
             // Only process the last context.
             var context = ContextsById.Last();
 
-            ContentItem published = null, latest = null;
-            bool publishedLoaded = false, latestLoaded = false;
-
             foreach (var indexSettings in await indexSettingsService.GetSettingsAsync())
             {
                 var cultureAspect = await contentManager.PopulateAspectAsync<CultureAspect>(context.ContentItem);
@@ -85,33 +81,74 @@ private static async Task IndexingAsync(ShellScope scope, IEnumerable<ContentCon
 
                 if (indexSettings.IndexedContentTypes.Contains(context.ContentItem.ContentType) && !ignoreIndexedCulture)
                 {
-                    if (!indexSettings.IndexLatest && !publishedLoaded)
-                    {
-                        publishedLoaded = true;
-                        published = await contentManager.GetAsync(context.ContentItem.ContentItemId, VersionOptions.Published);
-                    }
-
-                    if (indexSettings.IndexLatest && !latestLoaded)
+                    if (context is RemoveContentContext)
                     {
-                        latestLoaded = true;
-                        latest = await contentManager.GetAsync(context.ContentItem.ContentItemId, VersionOptions.Latest);
+                        await indexManager.DeleteDocumentsAsync(indexSettings.IndexName, new string[] { context.ContentItem.ContentItemId });
+                        continue;
                     }
 
-                    var contentItem = !indexSettings.IndexLatest ? published : latest;
-
-                    if (contentItem == null)
+                    if (!indexSettings.IndexLatest)
                     {
-                        await indexDocumentManager.DeleteDocumentsAsync(indexSettings.IndexName, new string[] { context.ContentItem.ContentItemId });
+                        if (context is PublishContentContext publishContext)
+                        {
+                            if (publishContext.Cancel)
+                            {
+                                continue;
+                            }
+
+                            if (publishContext.IsPublishing)
+                            {
+                                await StoreLuceneDocument(publishContext.PublishingItem, contentItemIndexHandlers, indexManager, logger, indexSettings);
+                            }
+                            else
+                            {
+                                await indexManager.DeleteDocumentsAsync(indexSettings.IndexName, new string[] { context.ContentItem.ContentItemId });
+                            }
+                        }
+                        else if (context is UpdateContentContext updateContext)
+                        {
+                            await indexManager.DeleteDocumentsAsync(indexSettings.IndexName, new string[] { context.ContentItem.ContentItemId });
+                        }
                     }
                     else
                     {
-                        var index = new DocumentIndex(contentItem.ContentItemId, contentItem.ContentItemVersionId);
-                        var buildIndexContext = new BuildIndexContext(index, contentItem, [contentItem.ContentType], new AzureAISearchContentIndexSettings());
-                        await contentItemIndexHandlers.InvokeAsync(x => x.BuildIndexAsync(buildIndexContext), logger);
-                        await indexDocumentManager.MergeOrUploadDocumentsAsync(indexSettings.IndexName, new DocumentIndex[] { buildIndexContext.DocumentIndex }, indexSettings);
+                        if (context is PublishContentContext publishContext)
+                        {
+                            if (publishContext.Cancel)
+                            {
+                                continue;
+                            }
+
+                            if (publishContext.IsPublishing)
+                            {
+                                await StoreLuceneDocument(publishContext.PublishingItem, contentItemIndexHandlers, indexManager, logger, indexSettings);
+                            }
+                            else
+                            {
+                                await indexManager.DeleteDocumentsAsync(indexSettings.IndexName, new string[] { context.ContentItem.ContentItemId });
+                            }
+                        }
+                        else if (context is UpdateContentContext updateContext)
+                        {
+                            await StoreLuceneDocument(updateContext.UpdatingItem, contentItemIndexHandlers, indexManager, logger, indexSettings);
+                        }
+                        else if (context is CreateContentContext createContext)
+                        {
+                            await StoreLuceneDocument(createContext.CreatingItem, contentItemIndexHandlers, indexManager, logger, indexSettings);
+                        }
                     }
                 }
             }
         }
     }
+
+    private static async Task StoreLuceneDocument(ContentItem contentItem, IEnumerable<IContentItemIndexHandler> contentItemIndexHandlers, AzureAIIndexDocumentManager indexManager, ILogger logger, AzureAISearchIndexSettings indexSettings)
+    {
+
+        var buildIndexContext = new BuildIndexContext(new DocumentIndex(contentItem.ContentItemId, contentItem.ContentItemVersionId), contentItem, new string[] { contentItem.ContentType }, new AzureAISearchContentIndexSettings());
+        await contentItemIndexHandlers.InvokeAsync(x => x.BuildIndexAsync(buildIndexContext), logger);
+
+        await indexManager.DeleteDocumentsAsync(indexSettings.IndexName, new string[] { contentItem.ContentItemId });
+        await indexManager.MergeOrUploadDocumentsAsync(indexSettings.IndexName, new DocumentIndex[] { buildIndexContext.DocumentIndex }, indexSettings);
+    }
 }