use pause and resume content import

Author: MikeAlhayek

src/Abstractions/CrestApps.OrchardCore.ContentTransfer.Abstractions/ContentTransferEntry.cs

@@ -69,13 +69,14 @@ public sealed class ContentTransferEntry : Entity
 
 public enum ContentTransferEntryStatus
 {
-    New,
-    Processing,
-    Completed,
-    CompletedWithErrors,
-    Canceled,
-    CanceledWithImportedRecords,
-    Failed,
+    New = 0,
+    Processing = 1,
+    Completed = 2,
+    CompletedWithErrors = 3,
+    Failed = 6,
+    Pending = 7,
+    Paused = 8,
+    Deleting = 9,
 }
 
 public enum ContentTransferDirection

src/Abstractions/CrestApps.OrchardCore.ContentTransfer.Abstractions/ContentTransferEntryStatusExtensions.cs

@@ -0,0 +1,63 @@
+namespace CrestApps.OrchardCore.ContentTransfer;
+
+/// <summary>
+/// Provides helpers for interpreting import-specific content transfer entry statuses.
+/// </summary>
+public static class ContentTransferEntryStatusExtensions
+{
+    /// <summary>
+    /// Determines whether the status represents a queued import waiting to start.
+    /// </summary>
+    /// <param name="status">The status to evaluate.</param>
+    /// <returns><c>true</c> when the import is pending; otherwise, <c>false</c>.</returns>
+    public static bool IsPendingImport(this ContentTransferEntryStatus status)
+        => status == ContentTransferEntryStatus.Pending
+            || status == ContentTransferEntryStatus.New;
+
+    /// <summary>
+    /// Determines whether the status represents a paused import.
+    /// </summary>
+    /// <param name="status">The status to evaluate.</param>
+    /// <returns><c>true</c> when the import is paused; otherwise, <c>false</c>.</returns>
+    public static bool IsPausedImport(this ContentTransferEntryStatus status)
+        => status == ContentTransferEntryStatus.Paused;
+
+    /// <summary>
+    /// Determines whether the status can be resumed for import processing.
+    /// </summary>
+    /// <param name="status">The status to evaluate.</param>
+    /// <returns><c>true</c> when the import can be resumed; otherwise, <c>false</c>.</returns>
+    public static bool CanResumeImport(this ContentTransferEntryStatus status)
+        => status.IsPendingImport()
+            || status.IsPausedImport()
+            || status == ContentTransferEntryStatus.Failed;
+
+    /// <summary>
+    /// Determines whether the status should stop import processing.
+    /// </summary>
+    /// <param name="status">The status to evaluate.</param>
+    /// <returns><c>true</c> when background import processing should stop; otherwise, <c>false</c>.</returns>
+    public static bool ShouldStopImport(this ContentTransferEntryStatus status)
+        => status.IsPausedImport()
+            || status == ContentTransferEntryStatus.Deleting;
+
+    /// <summary>
+    /// Maps import statuses to the normalized status used by the admin UI.
+    /// </summary>
+    /// <param name="status">The status to normalize.</param>
+    /// <returns>The normalized import status for display and filtering.</returns>
+    public static ContentTransferEntryStatus NormalizeImportStatus(this ContentTransferEntryStatus status)
+    {
+        if (status.IsPendingImport())
+        {
+            return ContentTransferEntryStatus.Pending;
+        }
+
+        if (status.IsPausedImport())
+        {
+            return ContentTransferEntryStatus.Paused;
+        }
+
+        return status;
+    }
+}

src/Abstractions/CrestApps.OrchardCore.ContentTransfer.Abstractions/IContentTransferEntryManager.cs

@@ -0,0 +1,35 @@
+namespace CrestApps.OrchardCore.ContentTransfer;
+
+/// <summary>
+/// Manages content transfer entry lifecycle operations that must be coordinated with background work.
+/// </summary>
+public interface IContentTransferEntryManager
+{
+    /// <summary>
+    /// Pauses an in-progress import entry so it can be resumed later.
+    /// </summary>
+    /// <param name="entryId">The entry identifier.</param>
+    /// <param name="cancellationToken">A cancellation token.</param>
+    Task PauseImportAsync(string entryId, CancellationToken cancellationToken = default);
+
+    /// <summary>
+    /// Marks an import entry as processing so background work can resume it.
+    /// </summary>
+    /// <param name="entryId">The entry identifier.</param>
+    /// <param name="cancellationToken">A cancellation token.</param>
+    Task ResumeImportAsync(string entryId, CancellationToken cancellationToken = default);
+
+    /// <summary>
+    /// Marks an entry as deleting before background cleanup begins.
+    /// </summary>
+    /// <param name="entryId">The entry identifier.</param>
+    /// <param name="cancellationToken">A cancellation token.</param>
+    Task MarkAsDeletingAsync(string entryId, CancellationToken cancellationToken = default);
+
+    /// <summary>
+    /// Deletes an entry and its stored file while coordinating with any active background processing lock.
+    /// </summary>
+    /// <param name="entryId">The entry identifier.</param>
+    /// <param name="cancellationToken">A cancellation token.</param>
+    Task DeleteAsync(string entryId, CancellationToken cancellationToken = default);
+}

src/Core/CrestApps.OrchardCore.ContentTransfer.Core/DefaultContentTransferEntryAdminListFilterProvider.cs

@@ -15,6 +15,19 @@ public void Build(QueryEngineBuilder<ContentTransferEntry> builder)
                 {
                     if (Enum.TryParse<ContentTransferEntryStatus>(val, true, out var status))
                     {
+                        if (status == ContentTransferEntryStatus.Pending)
+                        {
+                            return new ValueTask<IQuery<ContentTransferEntry>>(query.With<ContentTransferEntryIndex>(x =>
+                                x.Status == ContentTransferEntryStatus.Pending
+                                || x.Status == ContentTransferEntryStatus.New));
+                        }
+
+                        if (status == ContentTransferEntryStatus.Paused)
+                        {
+                            return new ValueTask<IQuery<ContentTransferEntry>>(query.With<ContentTransferEntryIndex>(x =>
+                                x.Status == ContentTransferEntryStatus.Paused));
+                        }
+
                         return new ValueTask<IQuery<ContentTransferEntry>>(query.With<ContentTransferEntryIndex>(x => x.Status == status));
                     }
 

src/CrestApps.Docs/docs/changelog/v2.0.0.md

@@ -113,6 +113,7 @@ Large parts of the reusable AI infrastructure are no longer implemented only ins
 - Content Transfer content-type settings now default **Allow Bulk Import** and **Allow Bulk Export** to enabled, so content types participate by default and can explicitly opt out by turning either setting off
 - Content Transfer now keeps CSV support in the base `CrestApps.OrchardCore.ContentTransfer` feature and moves optional `.xlsx` support into `CrestApps.OrchardCore.ContentTransfer.OpenXml`, with the import and export UI showing only the file extensions enabled by the current tenant feature set
 - Content Transfer now welds lazily created parts onto the parent content item during column discovery, import, and export so `.xlsx` exports no longer fail with a `System.Text.Json` node-cycle exception when a content item does not already materialize one of its configured parts
+- Content Transfer imports now commit inline status changes before their deferred background jobs run, use **Pending**, **Paused**, and **Deleting** import states in the admin list, surface **Resume import** and **Pause import** actions instead of the earlier cancel/process wording, and migrate older canceled import rows to the paused state
 - Omnichannel contact import and export now map the first contact-method bag entries to workbook `Email`, `Cell Phone`, and `Phone` columns, also read and write `DoNotCall`, `DoNotCallUtc`, `DoNotSms`, `DoNotSmsUtc`, `DoNotEmail`, `DoNotEmailUtc`, `DoNotChat`, and `DoNotChatUtc` on `OmnichannelContactPart`, advertise `true` and `false` for the `DoNot*` boolean columns, default duplicate-phone filtering to enabled, add skipped duplicate rows to the error export with a reason, batch-check duplicate phone numbers against both the import file and the existing Orchard contact records, fall back to legacy stored phone values when older tenants have not yet backfilled normalized-phone indexes, normalize non-E.164 import numbers before handing them to DNC registry providers, and can enforce national do-not-call registry checks through **Settings** -> **Import Content Settings**
 - Omnichannel contact and communication-preference content-item indexes now subscribe to Orchard's default content-item collection instead of the custom omnichannel document collection, so publishing or updating a contact reliably refreshes its index rows
 - Omnichannel contact definitions now enforce a fixed `ContactMethods` bag for content types that attach `OmnichannelContactPart`, while `OmnichannelContactPart` itself owns the contact-level Do-Not-Call, Do-Not-SMS, Do-Not-Email, and Do-Not-Chat compliance flags so omnichannel indexing, campaign actions, and activity loading all use one C#-controlled contact model

src/CrestApps.Docs/docs/modules/content-transfer.md

@@ -41,10 +41,12 @@ Use **Content** -> **Bulk Import** to upload a transfer file for a content type.
 2. Download the template if you need the expected column layout.
 3. Upload one of the enabled file formats shown in the UI.
 4. Choose whether the imported items should stay as the latest draft or be published immediately.
-5. The import is queued and processed in the background.
+5. The import is queued with a **Pending** status and processed in the background.
 
 Validation runs through `IContentManager.ValidateAsync()`. Failed rows are tracked, and rejected rows can be downloaded again in the same file format as the original import as long as that format feature is still enabled.
 
+Queued imports now follow the same background-job pattern used by the local DNC list importer. The admin list updates the status inline before work starts or stops, so entries can move through **Pending**, **Processing**, **Paused**, **Deleting**, **Completed**, **Completed with errors**, and **Failed** states without briefly showing stale values. While an import is running, the action menu offers **Pause import**. Paused, failed, pending, and stalled imports show **Resume import** so the background job can continue from the last saved batch.
+
 For Omnichannel contacts, the import UI can also expose duplicate-phone filtering, a lead-country selector for phone normalization, and national do-not-call registry checks. Duplicate-phone filtering is enabled by default, skipped duplicate rows are recorded in the error export with the reason, and duplicate detection checks both the current import batch and existing contact phone numbers already stored in Orchard before the batch commits. When a row includes an existing `ContentItemId`, duplicate detection now treats matching phone numbers on that same content item as an update instead of a conflict. The database lookup also falls back to older stored phone values that predate the normalized-phone index columns, so re-importing the same contact list is still rejected while older tenants finish reindexing. See [DNC Registry](./dnc-registry) for registry configuration and global enforcement.
 
 Bulk imports now default to saving drafts only. Enable **Publish imported content** when the imported items should be published immediately after create or update. When a row includes an existing `ContentItemId`, the import updates a new latest version of that item and then either keeps that version as a draft or publishes it based on the checkbox. For versionable content types, exports still include `ContentItemVersionId` for reference, but imports now ignore that value entirely.

src/Modules/CrestApps.OrchardCore.ContentTransfer/BackgroundTasks/ExportFilesBackgroundTask.cs

@@ -253,7 +253,7 @@ private static async Task SaveEntryWithErrorAsync(ISession session, IClock clock
         await session.SaveChangesAsync();
     }
 
-    private static string GetExportLockKey(string entryId)
+    internal static string GetExportLockKey(string entryId)
         => $"ContentsTransfer_Export_{entryId}";
 
     private static IQuery<ContentItem> BuildExportQuery(

src/Modules/CrestApps.OrchardCore.ContentTransfer/BackgroundTasks/ImportFilesBackgroundTask.cs

@@ -36,7 +36,9 @@ internal static async Task ProcessEntriesAsync(IServiceProvider serviceProvider,
         var distributedLock = serviceProvider.GetRequiredService<IDistributedLock>();
 
         var entries = await session.Query<ContentTransferEntry, ContentTransferEntryIndex>(x =>
-                (x.Status == ContentTransferEntryStatus.New || x.Status == ContentTransferEntryStatus.Processing)
+                (x.Status == ContentTransferEntryStatus.New
+                    || x.Status == ContentTransferEntryStatus.Pending
+                    || x.Status == ContentTransferEntryStatus.Processing)
                 && x.Direction == ContentTransferDirection.Import
                 && (entryId == null || x.EntryId == entryId))
             .OrderBy(x => x.CreatedUtc)
@@ -78,7 +80,7 @@ private static async Task ProcessEntryAsync(IServiceProvider serviceProvider, st
         var rowFilters = serviceProvider.GetServices<IContentImportRowFilter>();
         var entry = await session.Query<ContentTransferEntry, ContentTransferEntryIndex>(x => x.EntryId == entryId).FirstOrDefaultAsync(cancellationToken);
 
-        if (entry == null || entry.Status == ContentTransferEntryStatus.Canceled || entry.Status == ContentTransferEntryStatus.CanceledWithImportedRecords)
+        if (entry == null || entry.Status.ShouldStopImport())
         {
             return;
         }
@@ -103,13 +105,25 @@ private static async Task ProcessEntryAsync(IServiceProvider serviceProvider, st
             ? ContentImportOptions.DefaultImportBatchSize
             : contentImportOptions.ImportBatchSize;
 
+        var progressPart = entry.GetOrCreate<ImportFileProcessStatsPart>();
+        progressPart.Errors ??= [];
+        progressPart.ErrorMessages ??= [];
+
+        var isResuming = progressPart.CurrentRow > 0;
+
         entry.Status = ContentTransferEntryStatus.Processing;
         entry.Error = null;
         entry.CompletedUtc = null;
 
-        var progressPart = entry.GetOrCreate<ImportFileProcessStatsPart>();
-        progressPart.Errors ??= [];
-        progressPart.ErrorMessages ??= [];
+        if (!isResuming)
+        {
+            progressPart.CurrentRow = 0;
+            progressPart.TotalProcessed = 0;
+            progressPart.ImportedCount = 0;
+            progressPart.Errors.Clear();
+            progressPart.ErrorMessages.Clear();
+        }
+
         entry.Put(progressPart);
 
         session.Save(entry);
@@ -141,7 +155,7 @@ private static async Task ProcessEntryAsync(IServiceProvider serviceProvider, st
                 }
             }
 
-            await ProcessFileInBatchesAsync(
+            var completed = await ProcessFileInBatchesAsync(
                 serviceProvider,
                 fileStream,
                 formatProvider,
@@ -155,24 +169,18 @@ await ProcessFileInBatchesAsync(
                 clock,
                 batchSize,
                 cancellationToken);
+
+            if (!completed)
+            {
+                return;
+            }
         }
         catch (Exception ex)
         {
             await SaveEntryWithErrorAsync(session, clock, entry, localizer["Error processing file: {0}", ex.Message], cancellationToken);
             return;
         }
 
-        if (await IsImportCanceledAsync(serviceProvider, entry.EntryId, cancellationToken))
-        {
-            entry.Status = GetCanceledStatus(progressPart);
-            entry.ProcessSaveUtc = clock.UtcNow;
-            entry.CompletedUtc = clock.UtcNow;
-            entry.Put(progressPart);
-            session.Save(entry);
-            await session.SaveChangesAsync(cancellationToken);
-            return;
-        }
-
         var nowUtc = clock.UtcNow;
         entry.ProcessSaveUtc = nowUtc;
         entry.CompletedUtc = nowUtc;
@@ -185,7 +193,7 @@ await ProcessFileInBatchesAsync(
         await session.SaveChangesAsync(cancellationToken);
     }
 
-    private static async Task ProcessFileInBatchesAsync(
+    private static async Task<bool> ProcessFileInBatchesAsync(
         IServiceProvider serviceProvider,
         Stream stream,
         IContentTransferFileFormatProvider formatProvider,
@@ -203,7 +211,7 @@ private static async Task ProcessFileInBatchesAsync(
         using var reader = formatProvider.CreateReader(stream);
 
         var columnNames = reader.GetColumnNames();
-        var dataTable = new DataTable();
+        using var dataTable = new DataTable();
 
         foreach (var columnName in columnNames)
         {
@@ -226,6 +234,7 @@ private static async Task ProcessFileInBatchesAsync(
 
         var rowIndex = 1;
         var hasFilters = activeRowFilters.Count > 0;
+        var importInterrupted = false;
 
         foreach (var rowValues in reader.ReadRows())
         {
@@ -234,8 +243,9 @@ private static async Task ProcessFileInBatchesAsync(
                 break;
             }
 
-            if (await IsImportCanceledAsync(serviceProvider, entry.EntryId, cancellationToken))
+            if (await ShouldStopImportAsync(serviceProvider, entry.EntryId, cancellationToken))
             {
+                importInterrupted = true;
                 break;
             }
 
@@ -328,14 +338,18 @@ await ProcessBatchAsync(
                     clock,
                     cancellationToken);
                 newRecords.Clear();
-                newRecords.Clear();
                 existingRows.Clear();
                 dataTable.Rows.Clear();
             }
 
             rowIndex++;
         }
 
+        if (importInterrupted || cancellationToken.IsCancellationRequested)
+        {
+            return false;
+        }
+
         if (newRecords.Count + existingRows.Count > 0)
         {
             await ProcessBatchAsync(
@@ -353,7 +367,7 @@ await ProcessBatchAsync(
                 cancellationToken);
         }
 
-        dataTable.Dispose();
+        return true;
     }
 
     private static async Task ProcessBatchAsync(
@@ -377,7 +391,7 @@ private static async Task ProcessBatchAsync(
 
             foreach (var existingRow in existingRows)
             {
-                if (await IsImportCanceledAsync(serviceProvider, entry.EntryId, cancellationToken))
+                if (await ShouldStopImportAsync(serviceProvider, entry.EntryId, cancellationToken))
                 {
                     return;
                 }
@@ -406,7 +420,7 @@ await ProcessRowAsync(
 
         foreach (var record in newRecords)
         {
-            if (await IsImportCanceledAsync(serviceProvider, entry.EntryId, cancellationToken))
+            if (await ShouldStopImportAsync(serviceProvider, entry.EntryId, cancellationToken))
             {
                 return;
             }
@@ -543,27 +557,22 @@ private static async Task SaveEntryWithErrorAsync(ISession session, IClock clock
     {
         entry.Status = ContentTransferEntryStatus.Failed;
         entry.Error = error;
+        entry.ProcessSaveUtc = clock.UtcNow;
         entry.CompletedUtc = clock.UtcNow;
 
         session.Save(entry);
         await session.SaveChangesAsync(cancellationToken);
     }
 
-    private static string GetImportLockKey(string entryId)
+    internal static string GetImportLockKey(string entryId)
         => $"ContentsTransfer_Import_{entryId}";
 
-    private static async Task<bool> IsImportCanceledAsync(IServiceProvider serviceProvider, string entryId, CancellationToken cancellationToken)
+    private static async Task<bool> ShouldStopImportAsync(IServiceProvider serviceProvider, string entryId, CancellationToken cancellationToken)
     {
         await using var scope = serviceProvider.CreateAsyncScope();
         var session = scope.ServiceProvider.GetRequiredService<ISession>();
         var currentEntry = await session.Query<ContentTransferEntry, ContentTransferEntryIndex>(x => x.EntryId == entryId).FirstOrDefaultAsync(cancellationToken);
 
-        return currentEntry?.Status == ContentTransferEntryStatus.Canceled
-            || currentEntry?.Status == ContentTransferEntryStatus.CanceledWithImportedRecords;
+        return currentEntry?.Status.ShouldStopImport() == true;
     }
-
-    private static ContentTransferEntryStatus GetCanceledStatus(ImportFileProcessStatsPart progressPart)
-        => (progressPart?.ImportedCount ?? 0) > 0
-            ? ContentTransferEntryStatus.CanceledWithImportedRecords
-            : ContentTransferEntryStatus.Canceled;
 }