Add support for marking emails as important

Introduced a `RuleAction` enum to support `MarkImportant` and `Move` actions for email rules. Added the `EmailFlagOperation` class and `_flagQueue` in `EmailMonitoringService` to manage flagging operations separately from move operations.

Updated the `Rule` and `RuleTrigger` classes to include an `Action` property. Modified `BatchRuleProcessor` to handle `MarkImportant` actions. Added methods in `EmailMonitoringService` to process queued flag operations and flag emails as important.

Enhanced `IEmailMover` with an `ExtractFlagOperations` method to group and queue flagging operations. Updated `ExecuteTriggers` to process only `Move` actions for move operations.

Updated `appsettings.json` to include a new rule for marking emails from specific senders as important and changed `StoreMovedMessages` to `false`.

These changes add the ability to flag emails as important while maintaining existing move functionality.

Author: Timothy Dodd

src/MailZort/Program.cs

@@ -89,6 +89,7 @@ public class Rule
     /// If true, rule only matches emails that are NOT marked as important. If false or null, importance is ignored.
     /// </summary>
     public bool? RequireNotImportant { get; set; }
+    public RuleAction Action { get; set; } = RuleAction.Move;
 }
 public class EmailSettings
 {
@@ -110,6 +111,7 @@ public class RuleTrigger
     public required string To { get; set; }
     public required UniqueId Id { get; set; }
     public required Email Email { get; set; }
+    public RuleAction Action { get; set; } = RuleAction.Move;
 }
 public enum LookIn
 {
@@ -154,3 +156,16 @@ public class BatchProcessingEventArgs : EventArgs
     public int EmailsMoved { get; set; }
     public TimeSpan ProcessingTime { get; set; }
 }
+
+public enum RuleAction
+{
+    Move,
+    MarkImportant
+}
+
+public class EmailFlagOperation
+{
+    public string SourceFolder { get; set; } = string.Empty;
+    public List<UniqueId> EmailIds { get; set; } = new();
+    public DateTime QueuedAt { get; set; } = DateTime.UtcNow;
+}

src/MailZort/Services/BatchRuleProcessor.cs

@@ -99,12 +99,13 @@ private static RuleTrigger CreateTrigger(Rule rule, EmailReceivedEventArgs email
         {
             Id = email.UniqueId,
             From = email.Folder,
-            To = rule.MoveTo,
+            To = rule.Action == RuleAction.MarkImportant ? string.Empty : rule.MoveTo,
+            Action = rule.Action,
             Email = new Email
             {
                 MessageIndex = (int)email.UniqueId.Id,
                 Folder = email.Folder,
-                MoveTo = $"{rule.Name}->{rule.MoveTo}",
+                MoveTo = rule.Action == RuleAction.MarkImportant ? $"{rule.Name}->Flagged" : $"{rule.Name}->{rule.MoveTo}",
                 Subject = email.Subject,
                 SenderName = email.SenderName,
                 SenderEmailaddress = email.SenderAddress,

src/MailZort/Services/EmailMonitoringService.cs

@@ -27,6 +27,7 @@ public class EmailMonitoringService : BackgroundService
         private readonly IEmailMover _emailMover;
         private CancellationToken _serviceCancellationToken;
         private readonly ConcurrentQueue<EmailMoveOperation> _moveQueue = new();
+        private readonly ConcurrentQueue<EmailFlagOperation> _flagQueue = new();
         private DateTime _lastFullReprocess = DateTime.MinValue;
 
         public EmailMonitoringService(
@@ -187,15 +188,22 @@ private async Task<List<RuleTrigger>> ProcessBatchAsync(List<EmailReceivedEventA
             var emailsMoved = 0;
             if (triggers.Any())
             {
+                // Extract and queue flag operations
+                var flagOps = _emailMover.ExtractFlagOperations(triggers);
+                foreach (var flagOp in flagOps)
+                {
+                    _flagQueue.Enqueue(flagOp);
+                }
+
                 var ops = _emailMover.ExecuteTriggers(triggers);
-                _logger.LogInformation("📦 Executed {OperationCount} email move operations", ops.Count);
-                // Count how many emails were moved
+                _logger.LogInformation("📦 Executed {OperationCount} move operations and {FlagCount} flag operations",
+                    ops.Count, flagOps.Count);
                 foreach (var op in ops)
                 {
                     this._moveQueue.Enqueue(op);
                 }
 
-                emailsMoved = triggers.Count;
+                emailsMoved = triggers.Count(t => t.Action == RuleAction.Move);
             }
 
             stopwatch.Stop();
@@ -332,6 +340,12 @@ private async Task MonitorForNewEmailsAsync(CancellationToken stoppingToken)
                         continue; // Skip the IDLE cycle and immediately check again
                     }
 
+                    // Process any queued flag operations
+                    if (_flagQueue.Count > 0)
+                    {
+                        await ProcessQueuedFlagOperationsAsync();
+                    }
+
                     // Process any queued move operations
                     if (_moveQueue.Count > 0)
                     {
@@ -469,6 +483,68 @@ private async Task ProcessQueuedMoveOperationsAsync()
             }
         }
 
+        private async Task ProcessQueuedFlagOperationsAsync()
+        {
+            if (_client == null || !_client.IsConnected)
+            {
+                _logger.LogWarning("Cannot process flag operations: client not connected");
+                return;
+            }
+
+            var processedCount = 0;
+
+            while (_flagQueue.TryDequeue(out var flagOperation) && flagOperation != null)
+            {
+                try
+                {
+                    await ProcessSingleFlagOperationAsync(flagOperation);
+                    processedCount++;
+                }
+                catch (Exception ex)
+                {
+                    _logger.LogError(ex, "Error processing flag operation for folder {Source}",
+                        flagOperation.SourceFolder);
+                }
+
+                if (_serviceCancellationToken.IsCancellationRequested)
+                    break;
+            }
+
+            if (processedCount > 0)
+            {
+                _logger.LogInformation("⭐ Processed {Count} flag operations", processedCount);
+            }
+        }
+
+        private async Task ProcessSingleFlagOperationAsync(EmailFlagOperation flagOperation)
+        {
+            if (!flagOperation.EmailIds.Any())
+                return;
+
+            IMailFolder? folder = null;
+            try
+            {
+                folder = _client!.GetFolder(flagOperation.SourceFolder);
+                await folder.OpenAsync(FolderAccess.ReadWrite);
+                await folder.AddFlagsAsync(flagOperation.EmailIds, MessageFlags.Flagged, true);
+
+                _logger.LogInformation("⭐ Flagged {Count} emails as important in {Folder}",
+                    flagOperation.EmailIds.Count, flagOperation.SourceFolder);
+            }
+            catch (Exception ex)
+            {
+                _logger.LogError(ex, "Error flagging emails in {Folder}", flagOperation.SourceFolder);
+                throw;
+            }
+            finally
+            {
+                if (folder is { IsOpen: true })
+                {
+                    await folder.CloseAsync();
+                }
+            }
+        }
+
         private async Task ProcessSingleMoveOperationAsync(EmailMoveOperation moveOperation)
         {
             if (!moveOperation.Emails.Any())

src/MailZort/Services/EmailMover.cs

@@ -7,6 +7,7 @@ namespace MailZort.Services;
 public interface IEmailMover
 {
     List<EmailMoveOperation> ExecuteTriggers(List<RuleTrigger> triggers);
+    List<EmailFlagOperation> ExtractFlagOperations(List<RuleTrigger> triggers);
 }
 
 public class EmailMover : IEmailMover
@@ -19,6 +20,27 @@ public EmailMover(ILogger<EmailMover> logger)
 
     }
 
+    public List<EmailFlagOperation> ExtractFlagOperations(List<RuleTrigger> triggers)
+    {
+        var flagTriggers = triggers.Where(t => t.Action == RuleAction.MarkImportant).ToList();
+        if (!flagTriggers.Any())
+            return new List<EmailFlagOperation>();
+
+        var grouped = flagTriggers
+            .GroupBy(t => t.From)
+            .Select(g => new EmailFlagOperation
+            {
+                SourceFolder = g.Key,
+                EmailIds = g.Select(t => t.Id).ToList()
+            })
+            .ToList();
+
+        _logger.LogInformation("📌 Created {OperationCount} flag operations for {EmailCount} emails",
+            grouped.Count, flagTriggers.Count);
+
+        return grouped;
+    }
+
     public List<EmailMoveOperation> ExecuteTriggers(List<RuleTrigger> triggers)
     {
         List<EmailMoveOperation> ops = new List<EmailMoveOperation>();
@@ -28,6 +50,11 @@ public List<EmailMoveOperation> ExecuteTriggers(List<RuleTrigger> triggers)
             return ops;
         }
 
+        // Only process Move triggers for move operations
+        triggers = triggers.Where(t => t.Action == RuleAction.Move).ToList();
+        if (!triggers.Any())
+            return ops;
+
         var groupedTriggers = GroupTriggersByFolder(triggers);
         var queuedOperations = 0;
 

src/MailZort/appsettings.json

@@ -1,7 +1,7 @@
 {
     "EmailSettings": {
         "Trash": "Deleted Messages",
-        "StoreMovedMessages": true
+        "StoreMovedMessages": false
     },
     "rules": [
         {
@@ -82,6 +82,17 @@
                 "(?:save\\s+(on|big|up|\\$))"
             ]
         },
+        {
+            "Name": "ImportantSenders",
+            "Folder": "Inbox",
+            "Action": 1,
+            "LookIn": 5,
+            "ExpressionType": 0,
+            "Values": [
+                "boss@example.com",
+                "cto@example.com"
+            ]
+        },
         {
             "Name": "CleanupOldUnread",
             "Folder": "Inbox",