< Summary

Information
Class: Elsa.Workflows.Runtime.Stores.MemoryBookmarkQueueDeadLetterStore
Assembly: Elsa.Workflows.Runtime
File(s): /home/runner/work/elsa-core/elsa-core/src/modules/Elsa.Workflows.Runtime/Stores/MemoryBookmarkQueueDeadLetterStore.cs
Line coverage
85%
Covered lines: 79
Uncovered lines: 13
Coverable lines: 92
Total lines: 194
Line coverage: 85.8%
Branch coverage
68%
Covered branches: 15
Total branches: 22
Branch coverage: 68.1%
Method coverage

Feature is only available for sponsors

Upgrade to PRO version

Metrics

MethodBranch coverage Crap Score Cyclomatic complexity Line coverage
.ctor(...)100%11100%
SaveAsync(...)75%4485.71%
AddAsync()100%11100%
AddOrGetExistingAsync(...)100%22100%
AddOrGetExistingManyAsync(...)75%4481.81%
TryMarkReplayedAsync(...)100%66100%
FindAsync(...)100%11100%
PageAsync(...)100%210%
PageAsync(...)100%11100%
FindManyAsync(...)100%11100%
DeleteAsync(...)100%11100%
Filter(...)100%11100%
Clone(...)100%11100%
Clone(...)16.66%19628.57%

File(s)

/home/runner/work/elsa-core/elsa-core/src/modules/Elsa.Workflows.Runtime/Stores/MemoryBookmarkQueueDeadLetterStore.cs

#LineLine coverage
 1using Elsa.Common.Models;
 2using Elsa.Common.Services;
 3using Elsa.Extensions;
 4using Elsa.Workflows.Runtime.Entities;
 5using Elsa.Workflows.Runtime.Filters;
 6using Elsa.Workflows.Runtime.OrderDefinitions;
 7using Elsa.Workflows.Runtime.Options;
 8using JetBrains.Annotations;
 9
 10namespace Elsa.Workflows.Runtime.Stores;
 11
 12/// <inheritdoc />
 13[UsedImplicitly]
 18714public class MemoryBookmarkQueueDeadLetterStore(MemoryStore<BookmarkQueueDeadLetterItem> store) : IBookmarkQueueDeadLett
 15{
 18716    private readonly object _lock = new();
 17
 18    /// <inheritdoc />
 19    public Task SaveAsync(BookmarkQueueDeadLetterItem record, CancellationToken cancellationToken = default)
 20    {
 321        lock (_lock)
 22        {
 723            var existing = store.Find(x => x.OriginalQueueItemId == record.OriginalQueueItemId && x.Id != record.Id);
 324            if (existing != null)
 025                throw new InvalidOperationException($"A bookmark queue dead-letter item for original queue item '{record
 26
 627            store.Save(Clone(record), x => x.Id);
 328        }
 29
 330        return Task.CompletedTask;
 31    }
 32
 33    /// <inheritdoc />
 34    public async Task AddAsync(BookmarkQueueDeadLetterItem record, CancellationToken cancellationToken = default)
 35    {
 2536        await AddOrGetExistingAsync(record, cancellationToken);
 2537    }
 38
 39    /// <inheritdoc />
 40    public Task<BookmarkQueueDeadLetterItem> AddOrGetExistingAsync(BookmarkQueueDeadLetterItem record, CancellationToken
 41    {
 2642        lock (_lock)
 43        {
 4544            var existing = store.Find(x => x.OriginalQueueItemId == record.OriginalQueueItemId);
 2645            if (existing != null)
 1946                return Task.FromResult(Clone(existing));
 47
 1448            store.Add(Clone(record), x => x.Id);
 749            return Task.FromResult(Clone(record));
 50        }
 2651    }
 52
 53    /// <inheritdoc />
 54    public Task<IReadOnlyCollection<BookmarkQueueDeadLetterItem>> AddOrGetExistingManyAsync(IEnumerable<BookmarkQueueDea
 55    {
 756        lock (_lock)
 57        {
 758            var results = new List<BookmarkQueueDeadLetterItem>();
 59
 3260            foreach (var record in records)
 61            {
 1162                var existing = store.Find(x => x.OriginalQueueItemId == record.OriginalQueueItemId);
 963                if (existing != null)
 64                {
 065                    results.Add(Clone(existing));
 066                    continue;
 67                }
 68
 1869                store.Add(Clone(record), x => x.Id);
 970                results.Add(Clone(record));
 71            }
 72
 773            return Task.FromResult<IReadOnlyCollection<BookmarkQueueDeadLetterItem>>(results);
 74        }
 775    }
 76
 77    /// <inheritdoc />
 78    public Task<BookmarkQueueDeadLetterItem?> TryMarkReplayedAsync(string id, string queueItemId, DateTimeOffset replaye
 79    {
 880        lock (_lock)
 81        {
 1682            var entity = store.Find(x => x.Id == id);
 883            if (entity == null || !entity.CanReplay || entity.ReplayedAt != null)
 384                return Task.FromResult<BookmarkQueueDeadLetterItem?>(null);
 85
 586            entity.ReplayedAt = replayedAt;
 587            entity.ReplayedQueueItemId = queueItemId;
 588            entity.CanReplay = false;
 1089            store.Save(entity, x => x.Id);
 590            return Task.FromResult<BookmarkQueueDeadLetterItem?>(Clone(entity));
 91        }
 892    }
 93
 94    /// <inheritdoc />
 95    public Task<BookmarkQueueDeadLetterItem?> FindAsync(BookmarkQueueDeadLetterFilter filter, CancellationToken cancella
 96    {
 97        BookmarkQueueDeadLetterItem? entity;
 598        lock (_lock)
 99        {
 10100            entity = store.Query(query => Filter(query, filter)).Select(Clone).FirstOrDefault();
 5101        }
 102
 5103        return Task.FromResult(entity);
 104    }
 105
 106    /// <inheritdoc />
 107    public Task<Page<BookmarkQueueDeadLetterItem>> PageAsync<TOrderBy>(PageArgs pageArgs, BookmarkQueueDeadLetterItemOrd
 108    {
 109        Page<BookmarkQueueDeadLetterItem> entities;
 0110        lock (_lock)
 111        {
 0112            var page = store.Query(query => query.OrderBy(orderBy)).Paginate(pageArgs);
 0113            entities = page with { Items = page.Items.Select(Clone).ToList() };
 0114        }
 115
 0116        return Task.FromResult(entities);
 117    }
 118
 119    /// <inheritdoc />
 120    public Task<Page<BookmarkQueueDeadLetterItem>> PageAsync<TOrderBy>(PageArgs pageArgs, BookmarkQueueDeadLetterFilter 
 121    {
 122        Page<BookmarkQueueDeadLetterItem> entities;
 12123        lock (_lock)
 124        {
 24125            var page = store.Query(query => Filter(query, filter).OrderBy(orderBy)).Paginate(pageArgs);
 12126            entities = page with { Items = page.Items.Select(Clone).ToList() };
 12127        }
 128
 12129        return Task.FromResult(entities);
 130    }
 131
 132    /// <inheritdoc />
 133    public Task<IEnumerable<BookmarkQueueDeadLetterItem>> FindManyAsync(BookmarkQueueDeadLetterFilter filter, Cancellati
 134    {
 135        IEnumerable<BookmarkQueueDeadLetterItem> entities;
 25136        lock (_lock)
 137        {
 50138            entities = store.Query(query => Filter(query, filter)).Select(Clone).ToList();
 25139        }
 140
 25141        return Task.FromResult(entities);
 142    }
 143
 144    /// <inheritdoc />
 145    public Task<long> DeleteAsync(BookmarkQueueDeadLetterFilter filter, CancellationToken cancellationToken = default)
 146    {
 1147        lock (_lock)
 148        {
 3149            var ids = store.Query(query => Filter(query, filter)).Select(x => x.Id).ToList();
 1150            return Task.FromResult(store.DeleteMany(ids));
 151        }
 1152    }
 153
 43154    private static IQueryable<BookmarkQueueDeadLetterItem> Filter(IQueryable<BookmarkQueueDeadLetterItem> query, Bookmar
 155
 156    private static BookmarkQueueDeadLetterItem Clone(BookmarkQueueDeadLetterItem item)
 157    {
 80158        return new()
 80159        {
 80160            Id = item.Id,
 80161            TenantId = item.TenantId,
 80162            OriginalQueueItemId = item.OriginalQueueItemId,
 80163            WorkflowInstanceId = item.WorkflowInstanceId,
 80164            CorrelationId = item.CorrelationId,
 80165            BookmarkId = item.BookmarkId,
 80166            StimulusHash = item.StimulusHash,
 80167            ActivityInstanceId = item.ActivityInstanceId,
 80168            ActivityTypeName = item.ActivityTypeName,
 80169            Options = Clone(item.Options),
 80170            OriginalCreatedAt = item.OriginalCreatedAt,
 80171            DeadLetteredAt = item.DeadLetteredAt,
 80172            Reason = item.Reason,
 80173            DeliveryAttempts = item.DeliveryAttempts,
 80174            LastAttemptedAt = item.LastAttemptedAt,
 80175            LastErrorType = item.LastErrorType,
 80176            LastErrorMessage = item.LastErrorMessage,
 80177            CanReplay = item.CanReplay,
 80178            ReplayedAt = item.ReplayedAt,
 80179            ReplayedQueueItemId = item.ReplayedQueueItemId
 80180        };
 181    }
 182
 183    private static ResumeBookmarkOptions? Clone(ResumeBookmarkOptions? options)
 184    {
 80185        if (options == null)
 80186            return null;
 187
 0188        return new()
 0189        {
 0190            Input = options.Input == null ? null : new Dictionary<string, object>(options.Input),
 0191            Properties = options.Properties == null ? null : new Dictionary<string, object>(options.Properties)
 0192        };
 193    }
 194}
Generated by: ReportGenerator 5.5.10.0
05/31/2026 - 13:48:40
GitHub | reportgenerator.io

Methods/Properties

.ctor(Elsa.Common.Services.MemoryStore`1<Elsa.Workflows.Runtime.Entities.BookmarkQueueDeadLetterItem>)
SaveAsync(Elsa.Workflows.Runtime.Entities.BookmarkQueueDeadLetterItem,System.Threading.CancellationToken)
AddAsync()
AddOrGetExistingAsync(Elsa.Workflows.Runtime.Entities.BookmarkQueueDeadLetterItem,System.Threading.CancellationToken)
AddOrGetExistingManyAsync(System.Collections.Generic.IEnumerable`1<Elsa.Workflows.Runtime.Entities.BookmarkQueueDeadLetterItem>,System.Threading.CancellationToken)
TryMarkReplayedAsync(System.String,System.String,System.DateTimeOffset,System.Threading.CancellationToken)
FindAsync(Elsa.Workflows.Runtime.Filters.BookmarkQueueDeadLetterFilter,System.Threading.CancellationToken)
PageAsync(Elsa.Common.Models.PageArgs,Elsa.Workflows.Runtime.OrderDefinitions.BookmarkQueueDeadLetterItemOrder`1<TOrderBy>,System.Threading.CancellationToken)
PageAsync(Elsa.Common.Models.PageArgs,Elsa.Workflows.Runtime.Filters.BookmarkQueueDeadLetterFilter,Elsa.Workflows.Runtime.OrderDefinitions.BookmarkQueueDeadLetterItemOrder`1<TOrderBy>,System.Threading.CancellationToken)
FindManyAsync(Elsa.Workflows.Runtime.Filters.BookmarkQueueDeadLetterFilter,System.Threading.CancellationToken)
DeleteAsync(Elsa.Workflows.Runtime.Filters.BookmarkQueueDeadLetterFilter,System.Threading.CancellationToken)
Filter(System.Linq.IQueryable`1<Elsa.Workflows.Runtime.Entities.BookmarkQueueDeadLetterItem>,Elsa.Workflows.Runtime.Filters.BookmarkQueueDeadLetterFilter)
Clone(Elsa.Workflows.Runtime.Entities.BookmarkQueueDeadLetterItem)
Clone(Elsa.Workflows.Runtime.Options.ResumeBookmarkOptions)