Lots of tweaking to get send mail service working with ionos. Fixed bug where no reports coudl be created from public site.

Author: Felix-CodingClimber

src/DotNetElements.Core/Core/EntityBase.cs

@@ -124,8 +124,21 @@ public void Delete(Guid deleterId, DateTimeOffset deletionTime)
     }
 
     [EditorBrowsable(EditorBrowsableState.Never)]
-    public void Delete(DateTimeOffset deletionTime) => throw new NotImplementedException();
+    public void Delete(DateTimeOffset deletionTime)
+    {
+        if (IsDeleted)
+            throw new InvalidOperationException("Can not delete an already deleted entity");
+
+        IsDeleted = true;
+        DeletionTime = deletionTime;
+    }
 
     [EditorBrowsable(EditorBrowsableState.Never)]
-    public void Delete() => throw new NotImplementedException();
+    public void Delete()
+    {
+        if (IsDeleted)
+            throw new InvalidOperationException("Can not delete an already deleted entity");
+
+        IsDeleted = true;
+    }
 }

src/DotNetElements.Core/Outbox/OutboxMessageProcessor.cs

@@ -2,18 +2,18 @@
 
 public interface IOutboxMessageProcessor
 {
-	Task<Result> ProcessAsync(object message);
+	Task<Result> ProcessAsync(object message, CancellationToken cancellation);
 }
 
 public abstract class OutboxMessageProcessor<T> : IOutboxMessageProcessor
 {
-	public Task<Result> ProcessAsync(object message)
+	public Task<Result> ProcessAsync(object message, CancellationToken cancellation)
 	{
 		if (message is not T tMessage)
 			throw new ArgumentException("Invalid message type");
 
-		return ProcessAsync(tMessage);
+		return ProcessAsync(tMessage, cancellation);
 	}
 
-	protected abstract Task<Result> ProcessAsync(T message);
+	protected abstract Task<Result> ProcessAsync(T message, CancellationToken cancellation);
 }

src/DotNetElements.Core/Outbox/OutboxService.cs

@@ -2,6 +2,7 @@
 using Microsoft.Extensions.Logging;
 using Microsoft.Extensions.Options;
 using System.Text.Json;
+using System.Text.Json.Serialization;
 
 namespace DotNetElements.Core;
 
@@ -19,6 +20,13 @@ public sealed class OutboxService<TDbContext> : IOutboxService
     private readonly OutboxOptions outboxOptions;
     private readonly ILogger<OutboxService<TDbContext>> logger;
 
+    private readonly JsonSerializerOptions jsonOptions = new()
+    {
+        UnmappedMemberHandling = JsonUnmappedMemberHandling.Disallow,
+        PropertyNameCaseInsensitive = true
+    };
+
+
     public OutboxService(
         TDbContext dbContext,
         TimeProvider timeProvider,
@@ -37,12 +45,18 @@ public OutboxService(
 
     public async Task RunAsync(CancellationToken cancellation)
     {
-        IReadOnlyList<OutboxMessage> messages = await GetPendingMessages();
+        IReadOnlyList<OutboxMessage> messages = await GetPendingMessages(cancellation);
 
         logger.LogInformation("Started processing {MessageCount} messages", messages.Count);
 
         foreach (var messagesByType in messages.GroupBy(m => m.Type))
         {
+            if (cancellation.IsCancellationRequested)
+            {
+                logger.LogWarning("Processing was cancelled");
+                break;
+            }
+
             logger.LogInformation("Started processing {MessageCount} messages of type {MessageType}", messagesByType.Count(), messagesByType.Key);
 
             Type? messageType = outboxOptions.MessagesAssembly!.GetType(messagesByType.Key);
@@ -66,17 +80,31 @@ public async Task RunAsync(CancellationToken cancellation)
 
             foreach (OutboxMessage message in messagesByType)
             {
+                if (cancellation.IsCancellationRequested)
+                {
+                    logger.LogWarning("Processing was cancelled");
+                    break;
+                }
+
                 try
                 {
-                    object? deserializedMessage = JsonSerializer.Deserialize(message.Content, messageType);
+                    object? deserializedMessage = JsonSerializer.Deserialize(message.Content, messageType, jsonOptions);
 
                     if (deserializedMessage is null)
                     {
                         logger.LogError("Failed to process message {MessageId} of type {MessageType}. Failed to read content", message.Id, message.Type);
                         continue;
                     }
 
-                    await messageProcessor.ProcessAsync(deserializedMessage);
+                    Result processMessageResult = await messageProcessor.ProcessAsync(deserializedMessage, cancellation);
+
+                    if (processMessageResult.IsFail)
+                    {
+                        logger.LogError("Failed to process message {MessageId} of type {MessageType}. Error: {Error}", message.Id, message.Type, processMessageResult.ErrorMessage);
+
+                        await HandleFailedMessage(message, processMessageResult.ErrorMessage);
+                        continue;
+                    }
 
                     bool updateSuccess = await UpdateMessageStatus(message, processedOnUtc: timeProvider.GetUtcNow());
 
@@ -102,14 +130,14 @@ public async Task RunAsync(CancellationToken cancellation)
         logger.LogInformation("Finished processing messages");
     }
 
-    private async Task<IReadOnlyList<OutboxMessage>> GetPendingMessages()
+    private async Task<IReadOnlyList<OutboxMessage>> GetPendingMessages(CancellationToken cancellation)
     {
         try
         {
             return await dbContext.OutboxMessages
                 .Where(m => m.ProcessedOnUtc == null)
                 .OrderBy(m => m.OccurredOnUtc)
-                .ToListAsync();
+                .ToListAsync(cancellation);
         }
         catch (Exception ex)
         {
@@ -131,7 +159,7 @@ private async Task HandleFailedMessage(OutboxMessage message, string error)
         {
             logger.LogError("Failed to process message {MessageId} of type {MessageType}. Error: Max retry count reached", message.Id, message.Type);
 
-            bool updateSuccess = await UpdateMessageStatus(message, processedOnUtc: timeProvider.GetUtcNow(), error: error, retryCount: message.RetryCount + 1);
+            bool updateSuccess = await UpdateMessageStatus(message, processedOnUtc: timeProvider.GetUtcNow(), error: error, retryCount: message.RetryCount);
 
             // todo check what to do if update fails here
         }
@@ -148,8 +176,6 @@ private async Task<bool> UpdateMessageStatus(OutboxMessage message, DateTimeOffs
         if (retryCount is not null)
             message.RetryCount = retryCount.Value;
 
-        //dbContext.OutboxMessages.Update(message); // todo remove, should not be needed as EF already tracks the entity
-
         int numRowsUpdated = await dbContext.SaveChangesAsync();
 
         bool success = numRowsUpdated == 1;

src/DotNetElements.Core/Outbox/ServiceCollectionExtensions.cs

@@ -37,4 +37,12 @@ public static IServiceCollection AddOutbox<TDbContext>(this IServiceCollection s
 
         return services;
     }
+
+    public static IServiceCollection AddOutboxMessageProcessor<TService, TMessage>(this IServiceCollection services)
+        where TService : OutboxMessageProcessor<TMessage>
+    {
+        services.AddScoped<OutboxMessageProcessor<TMessage>, TService>();
+
+        return services;
+    }
 }

src/DotNetElements.Web.Blazor/Extensions/EditContextExtensions.cs

@@ -10,11 +10,14 @@ public static void LogDebugInfo(this EditContext? editContext)
         if (editContext is null)
             return;
 
+        IEnumerable<string> messages = editContext.GetValidationMessages();
+
+        if (!messages.Any())
+            return;
+
         Console.WriteLine($"DEBUG EditContext validation messages. Context: {editContext.Model.GetType()}");
 
-        foreach (string message in editContext.GetValidationMessages())
-        {
+        foreach (string message in messages)
             Console.WriteLine(message);
-        }
     }
 }