Refactor IMAP sync caching and improve thread safety

Replaced `IMemoryCache` with a thread-safe `ConcurrentDictionary`
for managing IMAP sync dates in `LimilabsImapEmailService`. Added
`GetLastImapSyncDate` and `SetLastImapSyncDate` methods to handle
cache operations. Updated the `IImapEmailService` interface to
include `GetLastImapSyncDate`. Simplified the `MarkAsSeenAsync`
method signature for better readability. Introduced a private
record type `ImapCacheKey` to encapsulate cache keys.

.gitignore

@@ -370,3 +370,6 @@ FodyWeavers.xsd
 /EnvelopeGenerator.Server/EnvelopeGenerator.Server/publish-output
 /EnvelopeGenerator.Server/EnvelopeGenerator.Server/tekh_softHSM_test.md
 /legacy/App
+/src/DigitalData.MessagingService.API/appsettings.Secrets.json
+/src/presentation/DigitalData.MessagingService.API/appsettings.Secrets.json
+/src/presentation/DigitalData.MessagingService.API/appsettings.Secrets.json

AGENTS.md

@@ -0,0 +1,714 @@
+# MessagingService - Agent Notes and Future Enhancements
+
+## Purpose
+This document contains important notes, decisions, and future enhancement plans for the MessagingService application. This is intended for AI agents and developers who will continue development.
+
+---
+
+## Important Notes
+
+### 1. Database Schema - DO NOT MODIFY
+**CRITICAL**: The database schema must NEVER be modified. All Entity Framework entities must map to existing legacy tables using `[Table]` and `[Column]` attributes.
+
+**Naming Convention**:
+- Database: `SNAKE_CASE` with prefixes (TBEMLP_, TBDD_)
+- C# Entities: `PascalCase` without prefixes
+- Use `[Table("TBDD_FOO")]` and `[Column("COLUMN_NAME")]` attributes
+
+**Example**:
+```csharp
+[Table("TBDD_EMAIL_ACCOUNT")]
+public class EmailAccount
+{
+    [Column("EMAIL_ACCOUNT_ID")]
+    public int Id { get; set; }
+    
+    [Column("ACCOUNT_NAME")]
+    public string AccountName { get; set; }
+}
+```
+
+### 2. Message ID Hash Algorithm
+The `MessageIdGenerator` in `Domain.Services` must use **exactly the same algorithm** as the legacy system to ensure duplicate detection works correctly.
+
+**Algorithm**: SHA256 hash of `{originalMessageId}|{sender}|{date:yyyyMMddHHmmss}|{subject}`
+
+### 3. DateTime Usage - ALWAYS Use Local Time
+**CRITICAL**: Always use `DateTime.Now` instead of `DateTime.UtcNow` throughout the entire application.
+
+**Reason**: The legacy system uses local server time, and the database stores all timestamps as local time. Using UTC would break compatibility and cause incorrect time comparisons.
+
+**Examples**:
+```csharp
+// ✅ CORRECT
+profile.CreatedDate = DateTime.Now;
+var lastPoll = DateTime.Now.AddMinutes(-profile.PollIntervalMinutes);
+
+// ❌ WRONG - DO NOT USE
+profile.CreatedDate = DateTime.UtcNow;  // NEVER USE UTC
+var lastPoll = DateTime.UtcNow.AddMinutes(-profile.PollIntervalMinutes);  // NEVER USE UTC
+```
+
+**Important**: This applies to:
+- All entity audit fields (CreatedDate, ModifiedDate, LastPollDate, etc.)
+- All date comparisons in business logic
+- All timestamps in logs and error messages
+- All date parameters in queries
+
+### 4. Git Operations - NEVER Without Explicit Permission
+**CRITICAL**: NEVER execute `git commit` or `git push` commands automatically. ALWAYS wait for explicit user instruction.
+
+**Rules**:
+- Only commit when user explicitly says "commit" or "commit this"
+- Only push when user explicitly says "push" or "push to remote"
+- Stage files with `git add` ONLY when about to commit per user request
+
+### 5. MediatR Command/Query File Organization
+**IMPORTANT**: Commands/Queries and their Handlers must be in the SAME file.
+
+**Example**:
+```csharp
+// ✅ CORRECT - CreateEmailProfileCommand.cs contains BOTH
+public record CreateEmailProfileCommand : IRequest<int> { ... }
+
+public class CreateEmailProfileCommandHandler : IRequestHandler<CreateEmailProfileCommand, int> { ... }
+
+// ❌ WRONG - Separate files
+// CreateEmailProfileCommand.cs (command only)
+// CreateEmailProfileCommandHandler.cs (handler only)
+```
+
+**File Naming**:
+- Commands: `{Verb}{Entity}Command.cs` (e.g., `CreateEmailProfileCommand.cs`)
+- Queries: `{Verb}{Entity}Query.cs` (e.g., `GetEmailProfilesQuery.cs`)
+
+**Folder Structure** (NO Features/ prefix):
+```
+Application/
+├── EmailProfiles/
+│   ├── Commands/CreateEmailProfileCommand.cs
+│   ├── Queries/GetEmailProfilesQuery.cs
+│   └── Validators/CreateEmailProfileCommandValidator.cs
+├── EmailAccounts/
+│   ├── Commands/CreateEmailAccountCommand.cs
+│   └── Queries/GetEmailAccountsQuery.cs
+└── Common/
+    ├── Dtos/EmailProfileDto.cs (single DTOs at root)
+    ├── Dtos/EmailHistories/ (multiple DTOs in subfolder)
+    └── Interfaces/IEmailService.cs
+```
+
+### 6. Repository Pattern - NO UnitOfWork, Generic CRUD with AutoMapper
+**CRITICAL**: DO NOT use IUnitOfWork pattern. Use generic repository pattern with AutoMapper-based CRUD operations.
+
+**Key Principles**:
+- ✅ Each operation auto-saves changes - NO explicit SaveChangesAsync needed
+- ✅ Use `UpdateSingleAsync` / `DeleteSingleAsync` for single-record safety
+- ✅ Use `UpdateAsync` / `DeleteAsync` only when intentionally modifying multiple records
+- ✅ AutoMapper handles all DTO → Entity mappings
+
+**Pattern**:
+```csharp
+// IRepository<T> generic interface
+public interface IRepository<TEntity> where TEntity : class
+{
+    // Query operations
+    Task<TEntity?> GetByIdAsync(int id, CancellationToken cancellationToken = default);
+    Task<IEnumerable<TEntity>> FindAsync(Expression<Func<TEntity, bool>> predicate, ...);
+    
+    // Create - auto-saves
+    Task<TEntity> CreateAsync<TDto>(TDto dto, CancellationToken cancellationToken = default);
+    
+    // Update - auto-saves
+    Task<int> UpdateAsync<TDto>(Expression<...> predicate, TDto dto, ...); // Multiple records
+    Task UpdateSingleAsync<TDto>(Expression<...> predicate, TDto dto, ...); // SAFE: Single record only
+    
+    // Delete - auto-saves
+    Task<int> DeleteAsync(Expression<...> predicate, ...); // Multiple records
+    Task DeleteSingleAsync(Expression<...> predicate, ...); // SAFE: Single record only
+}
+```
+
+**Command Handler Examples**:
+```csharp
+// ✅ CORRECT - CreateAsync auto-saves
+public class CreateEmailProfileCommandHandler(IRepository<EmailProfile> repository) 
+    : IRequestHandler<CreateEmailProfileCommand, int>
+{
+    public async Task<int> Handle(CreateEmailProfileCommand request, CancellationToken cancellationToken)
+    {
+        var profile = await repository.CreateAsync(request, cancellationToken);
+        return profile.Id; // NO SaveChangesAsync needed!
+    }
+}
+
+// ✅ CORRECT - UpdateSingleAsync for safety (throws if 0 or 2+ records match)
+public class UpdateEmailProfileCommandHandler(IRepository<EmailProfile> repository) 
+    : IRequestHandler<UpdateEmailProfileCommand, int>
+{
+    public async Task<int> Handle(UpdateEmailProfileCommand request, CancellationToken cancellationToken)
+    {
+        await repository.UpdateSingleAsync(p => p.Id == request.Id, request, cancellationToken);
+        return request.Id; // NO SaveChangesAsync needed!
+    }
+}
+
+// ✅ CORRECT - DeleteSingleAsync for safety (throws if 0 or 2+ records match)
+public class DeleteEmailProfileCommandHandler(IRepository<EmailProfile> repository) 
+    : IRequestHandler<DeleteEmailProfileCommand, int>
+{
+    public async Task<int> Handle(DeleteEmailProfileCommand request, CancellationToken cancellationToken)
+    {
+        await repository.DeleteSingleAsync(p => p.Id == request.Id, cancellationToken);
+        return request.Id; // NO SaveChangesAsync needed!
+    }
+}
+
+// ❌ WRONG - Manual entity creation (use AutoMapper instead)
+var profile = new EmailProfile 
+{ 
+    ProfileName = request.ProfileName, 
+    EmailAccountId = request.EmailAccountId,
+    // ... 15 more properties
+};
+
+// ❌ WRONG - Using IUnitOfWork (removed)
+public CreateEmailProfileCommandHandler(IUnitOfWork unitOfWork) { ... }
+
+// ❌ WRONG - Calling SaveChangesAsync (removed)
+await repository.SaveChangesAsync(cancellationToken);
+```
+
+**Safety Rules**:
+1. **UpdateSingleAsync** - Use for ID-based updates. Throws `InvalidOperationException` if:
+   - Zero records match (entity not found)
+   - Multiple records match (predicate too broad)
+
+2. **DeleteSingleAsync** - Use for ID-based deletes. Throws `InvalidOperationException` if:
+   - Zero records match (entity not found)
+   - Multiple records match (predicate too broad)
+
+3. **UpdateAsync / DeleteAsync** - Use ONLY when intentionally modifying multiple records:
+   ```csharp
+   // ✅ CORRECT - Intentional bulk operation
+   await repository.UpdateAsync(
+       p => p.EmailAccountId == accountId, 
+       new { IsActive = false }, 
+       cancellationToken);
+   
+   // ✅ Returns count of updated/deleted records
+   var count = await repository.DeleteAsync(p => p.IsActive == false, cancellationToken);
+   ```
+
+**DTO Mapping Responsibility**:
+- Each DTO creator must define their own AutoMapper profile
+- Example: `CreateEmailProfileCommand` → `EmailProfile` mapping must be defined in `EmailProfileMappingProfile.cs`
+- Repository implementation uses `IMapper.Map<TEntity>(dto)` internally
+
+---
+
+## Future Enhancements
+
+### 7. RabbitMQ Command Bus Integration (IMPLEMENTED)
+
+**Purpose**: Asynchronous command processing via RabbitMQ message broker for POST/PUT/DELETE operations.
+
+**Architecture**:
+- **GET Queries**: Synchronous (immediate response via MediatR)
+- **POST/PUT/DELETE Commands**: Can be asynchronous (published to RabbitMQ, processed by background worker)
+
+**RabbitMQ Server**:
+- Management UI: `http://172.24.12.56:15672`
+- AMQP Port: `5672` (default)
+- Exchange: `emailprofiler.commands` (Direct)
+- Queue: `emailprofiler.command.queue`
+- Routing Key: `command`
+
+**Implementation Components**:
+
+1. **ICommandPublisher** (`Application/Common/Interfaces/ICommandPublisher.cs`):
+   - Interface for publishing commands to message broker
+   - Generic method: `PublishAsync<TCommand>(TCommand command, CancellationToken)`
+
+2. **RabbitMqCommandPublisher** (`Infrastructure/Messaging/RabbitMqCommandPublisher.cs`):
+   - Implements `ICommandPublisher`
+   - Serializes command to JSON with metadata envelope (CommandType, Payload, CorrelationId, PublishedAt)
+   - Publishes to RabbitMQ exchange with persistent delivery mode
+
+3. **RabbitMqCommandConsumer** (`Infrastructure/Messaging/RabbitMqCommandConsumer.cs`):
+   - BackgroundService that consumes commands from RabbitMQ
+   - Deserializes command envelope
+   - Resolves command type from assembly
+   - Executes command via MediatR in scoped service
+   - Acknowledges message on success, requeues on error
+
+4. **RabbitMqConfiguration** (`Infrastructure/Messaging/RabbitMqConfiguration.cs`):
+   - Configuration model for RabbitMQ connection
+   - Binds to `appsettings.json` section: `RabbitMq`
+
+**Configuration** (`appsettings.json`):
+```json
+{
+  "RabbitMq": {
+    "HostName": "172.24.12.56",
+    "Port": 5672,
+    "UserName": "guest",
+    "Password": "guest",
+    "VirtualHost": "/",
+    "ExchangeName": "emailprofiler.commands",
+    "QueueName": "emailprofiler.command.queue",
+    "RoutingKey": "command",
+    "AutomaticRecoveryEnabled": true,
+    "NetworkRecoveryIntervalSeconds": 10
+  }
+}
+```
+
+**Dependency Injection** (`Infrastructure/DependencyInjection.cs`):
+```csharp
+services.Configure<RabbitMqConfiguration>(configuration.GetSection(RabbitMqConfiguration.SectionName));
+services.AddSingleton<ICommandPublisher, RabbitMqCommandPublisher>();
+services.AddHostedService<RabbitMqCommandConsumer>();
+```
+
+**Usage in API Controllers** (Future):
+```csharp
+// Option 1: Synchronous (immediate execution via MediatR)
+var result = await _mediator.Send(new CreateEmailProfileCommand(...), cancellationToken);
+return Ok(result);
+
+// Option 2: Asynchronous (publish to RabbitMQ for background processing)
+await _commandPublisher.PublishAsync(new CreateEmailProfileCommand(...), cancellationToken);
+return Accepted(); // HTTP 202 - command queued for processing
+```
+
+**Benefits**:
+- Decouples API from long-running command processing
+- Improves API responsiveness (fire-and-forget)
+- Enables horizontal scaling (multiple consumers)
+- Automatic retries on failure (requeue mechanism)
+- Message persistence (survives application restarts)
+
+---
+
+### HIGH PRIORITY: Email Queue for Outgoing Messages (Future)
+
+**Implementation Steps**:
+
+1. **Add NuGet Package**:
+   ```bash
+   dotnet add package RabbitMQ.Client
+   ```
+
+2. **Create RabbitMqEmailQueue.cs**:
+   ```csharp
+   // src/DigitalData.MessagingService.Infrastructure/Queue/RabbitMqEmailQueue.cs
+   public class RabbitMqEmailQueue : IEmailQueue
+   {
+       private readonly IConnection _connection;
+       private readonly IModel _channel;
+       private const string QueueName = "email-outbox";
+       
+       public RabbitMqEmailQueue(IOptions<RabbitMqConfiguration> config)
+       {
+           var factory = new ConnectionFactory
+           {
+               HostName = config.Value.HostName,
+               Port = config.Value.Port,
+               UserName = config.Value.UserName,
+               Password = config.Value.Password
+           };
+           
+           _connection = factory.CreateConnection();
+           _channel = _connection.CreateModel();
+           
+           _channel.QueueDeclare(
+               queue: QueueName,
+               durable: true,
+               exclusive: false,
+               autoDelete: false,
+               arguments: null);
+       }
+       
+       public async Task EnqueueAsync(SendingEmail email, CancellationToken cancellationToken)
+       {
+           var json = JsonSerializer.Serialize(email);
+           var body = Encoding.UTF8.GetBytes(json);
+           
+           var properties = _channel.CreateBasicProperties();
+           properties.Persistent = true;
+           
+           _channel.BasicPublish(
+               exchange: "",
+               routingKey: QueueName,
+               basicProperties: properties,
+               body: body);
+           
+           await Task.CompletedTask;
+       }
+       
+       public async Task<SendingEmail?> DequeueAsync(CancellationToken cancellationToken)
+       {
+           var result = _channel.BasicGet(QueueName, autoAck: false);
+           
+           if (result == null)
+               return null;
+           
+           var json = Encoding.UTF8.GetString(result.Body.ToArray());
+           var email = JsonSerializer.Deserialize<SendingEmail>(json);
+           
+           _channel.BasicAck(result.DeliveryTag, false);
+           
+           return await Task.FromResult(email);
+       }
+   }
+   ```
+
+3. **Configuration** (appsettings.json):
+   ```json
+   {
+     "RabbitMq": {
+       "HostName": "localhost",
+       "Port": 5672,
+       "UserName": "guest",
+       "Password": "guest"
+     }
+   }
+   ```
+
+4. **Dependency Injection** (Program.cs):
+   ```csharp
+   // Replace InMemoryEmailQueue with RabbitMqEmailQueue
+   // builder.Services.AddSingleton<IEmailQueue, InMemoryEmailQueue>();
+   builder.Services.AddSingleton<IEmailQueue, RabbitMqEmailQueue>();
+   ```
+
+**Benefits**:
+- Message persistence (survives application restarts)
+- Scalability (multiple worker instances can consume from queue)
+- Reliability (automatic retries, dead letter queues)
+- Monitoring (RabbitMQ management UI)
+
+**Migration Path**:
+1. Deploy RabbitMQ server (Docker recommended)
+2. Test RabbitMqEmailQueue in staging environment
+3. Switch DI registration from InMemoryEmailQueue to RabbitMqEmailQueue
+4. Monitor queue depth and worker performance
+
+---
+
+## Pending Implementation Tasks
+
+### Phase 2: Application Layer (COMPLETE)
+**Status**: ✅ Complete - All Commands, Queries, Handlers, Validators, AutoMapper Profiles, and Interfaces implemented
+
+**Completed**:
+- ✅ MediatR Commands (CreateEmailProfileCommand, ProcessEmailCommand, etc.)
+- ✅ MediatR Queries (GetEmailProfilesQuery, GetEmailHistoryQuery, etc.)
+- ✅ Command/Query Handlers
+- ✅ FluentValidation Validators
+- ✅ AutoMapper Profiles
+- ✅ Application Interfaces (IEmailService, IPdfProcessingService, IDmsService, etc.)
+
+**Example Command**:
+```csharp
+// src/DigitalData.MessagingService.Application/EmailProfiles/Commands/CreateEmailProfileCommand.cs
+public record CreateEmailProfileCommand(string ProfileName, int EmailAccountId) : IRequest<int>;
+
+public class CreateEmailProfileCommandHandler : IRequestHandler<CreateEmailProfileCommand, int>
+{
+    private readonly IRepository<EmailProfile> _repository;
+    
+    public async Task<int> Handle(CreateEmailProfileCommand request, CancellationToken cancellationToken)
+    {
+        var profile = await _repository.CreateAsync(request, cancellationToken);
+        return profile.Id;
+    }
+}
+```
+
+### 8. Email Library - Limilabs Mail.dll
+
+**IMPORTANT**: This project uses **Limilabs Mail.dll** (https://www.limilabs.com/) for email operations, NOT MailKit/MimeKit.
+
+**Why Limilabs?**:
+- Commercial-grade IMAP/POP3/SMTP library
+- Better OAuth2 support (Microsoft 365, Gmail)
+- More reliable with Exchange servers
+- Superior attachment handling
+- Built-in retry mechanisms
+
+**NuGet Package**:
+```bash
+dotnet add package Limilabs.Mail
+```
+
+**Key Classes**:
+- `Imap` - IMAP client for receiving emails
+- `Smtp` - SMTP client for sending emails
+- `Mail.Message` - Email message representation
+- `OAuth2` - OAuth2 authentication helper
+
+**Implementation Example**:
+```csharp
+// Limilabs IMAP with OAuth2
+using Limilabs.Client.IMAP;
+using Limilabs.Mail;
+
+public class LimilabsEmailService : IEmailService
+{
+    public async Task<IEnumerable<EmailMessage>> ReceiveEmailsAsync(EmailAccountDto account)
+    {
+        using var imap = new Imap();
+        
+        if (account.UseOAuth2)
+        {
+            await imap.ConnectSSLAsync(account.ImapServer, account.ImapPort);
+            await imap.LoginOAUTH2Async(account.Username, account.OAuth2AccessToken);
+        }
+        else
+        {
+            await imap.ConnectSSLAsync(account.ImapServer, account.ImapPort);
+            await imap.LoginAsync(account.Username, account.EncryptedPassword);
+        }
+        
+        imap.SelectInbox();
+        var uids = imap.Search(Flag.Unseen);
+        
+        var messages = new List<EmailMessage>();
+        foreach (var uid in uids)
+        {
+            var eml = imap.GetMessageByUID(uid);
+            var mail = new MailBuilder().CreateFromEml(eml);
+            messages.Add(ConvertToEmailMessage(mail));
+        }
+        
+        imap.Close();
+        return messages;
+    }
+}
+```
+
+**DO NOT USE**:
+- ❌ MailKit
+- ❌ MimeKit
+- ❌ System.Net.Mail (obsolete)
+
+### Phase 3: Infrastructure Layer (COMPLETE)
+**Status**: ✅ Complete - DbContext, Repository, Services, RabbitMQ, and DI implemented
+
+**Completed**:
+- ✅ MessagingServiceDbContext with DbSet<T> for all entities (attribute-only config, no overrides)
+- ✅ Generic Repository<T> implementing IRepository<T> with AutoMapper-based CRUD
+- ✅ LimilabsEmailService (IMAP/SMTP with OAuth2 using Limilabs Mail.dll - TODO: Add Limilabs.Mail NuGet)
+- ✅ GdPicturePdfProcessingService (using GdPicture.NET 14 - TODO: Add GdPicture NuGet and license)
+- ✅ WindreamDmsService (COM Interop - TODO: Add windream COM Interop references)
+- ✅ DataProtectionEncryptionService (Data Protection API)
+- ✅ InMemoryEmailQueue (TODO: Upgrade to RabbitMqEmailQueue later)
+- ✅ RabbitMqCommandPublisher and RabbitMqCommandConsumer
+- ✅ DependencyInjection.cs with all service registrations
+
+**Implementation Notes**:
+- All services have real implementations with commented TODO blocks for external dependencies
+- LimilabsEmailService uses Microsoft.Identity.Client for OAuth2 token acquisition
+- GdPicturePdfProcessingService uses GdPicture.NET 14.x API (GetAttachmentCount, ExtractEmbeddedFile)
+- WindreamDmsService uses COM Interop (WMSession, WMConnect, WMObjects) based on legacy patterns
+- NO EF Core migrations (legacy DB must not be modified)
+
+**DbContext Example**:
+```csharp
+public class MessagingServiceDbContext : DbContext
+{
+    public DbSet<EmailAccount> EmailAccounts { get; set; }
+    public DbSet<EmailProfile> EmailProfiles { get; set; }
+    // ... other DbSets
+    
+    protected override void OnModelCreating(ModelBuilder modelBuilder)
+    {
+        modelBuilder.ApplyConfigurationsFromAssembly(Assembly.GetExecutingAssembly());
+        
+        // Important: Check for triggers
+        modelBuilder.Entity<EmailHistory>().ToTable(tb => tb.HasTrigger("TR_TBEMLP_HISTORY_AUDIT"));
+    }
+}
+```
+
+### Phase 4: API Layer
+**Status**: Minimal structure exists
+
+**TODO**:
+- [ ] Create Controllers (EmailProfilesController, EmailAccountsController, EmailHistoryController)
+- [ ] Create Background Workers (EmailPollingWorker, EmailSenderWorker)
+- [ ] Configure Serilog
+- [ ] Configure Scalar (OpenAPI documentation)
+- [ ] Add Exception Handling Middleware
+- [ ] Configure DI for all layers
+- [ ] Support both IIS and Windows Service hosting
+
+**Worker Configuration** (appsettings.json):
+```json
+{
+  "Workers": {
+    "EmailPolling": {
+      "Enabled": true,
+      "IntervalSeconds": 60
+    },
+    "EmailSender": {
+      "Enabled": true,
+      "IntervalSeconds": 5
+    }
+  },
+  "Hosting": {
+    "Mode": "IIS"  // or "WindowsService"
+  }
+}
+```
+
+### Phase 5: Testing
+**Status**: Not started
+
+**TODO**:
+- [ ] Unit tests for Domain entities
+- [ ] Unit tests for Application handlers (using FakeItEasy)
+- [ ] Integration tests for Repositories (using Testcontainers)
+- [ ] API tests (using WebApplicationFactory)
+- [ ] Generate fake test data (using Bogus)
+
+**Test Example**:
+```csharp
+public class MessageIdGeneratorTests
+{
+    [Fact]
+    public void Generate_ShouldProduceSameHashAsLegacy()
+    {
+        // Arrange
+        var generator = new MessageIdGenerator();
+        var original = "msg-123";
+        var sender = "test@example.com";
+        var date = new DateTime(2026, 1, 1, 12, 0, 0);
+        var subject = "Test Subject";
+        
+        // Act
+        var messageId = generator.Generate(original, sender, date, subject);
+        
+        // Assert
+        messageId.Hash.Should().NotBeNullOrEmpty();
+        // TODO: Verify against known legacy hash
+    }
+}
+```
+
+---
+
+## Architecture Decisions
+
+### Clean Architecture Layers
+1. **Domain**: Core business logic, no dependencies
+2. **Application**: Use cases, depends on Domain
+3. **Infrastructure**: External concerns, depends on Domain + Application
+4. **API**: Entry point, depends on all
+
+### CQRS Pattern with MediatR
+- **Commands**: Modify state (Create, Update, Delete)
+- **Queries**: Read data (Get, List)
+- Separate models for read and write operations
+
+### Repository Pattern
+- Interface in Application layer
+- Implementation in Infrastructure layer
+- One repository per Aggregate Root
+
+---
+
+## Known Issues and Limitations
+
+### 1. PdfSharp Embedded File Extraction
+PdfSharp has limited support for embedded file extraction from PDFs. If advanced PDF processing is needed, consider:
+- **iText7** (AGPL or commercial license)
+- **Aspose.PDF** (commercial license)
+- Custom PDF parsing using PDF specification
+
+### 2. windream COM Interop
+The windream DMS integration uses COM Interop which is Windows-only. The application cannot be fully cross-platform unless windream provides a REST API alternative.
+
+### 3. OAuth2 Token Refresh
+Current implementation acquires new tokens on each request. Consider implementing token caching:
+- Use `Microsoft.Identity.Web` for automatic token management
+- Cache tokens in memory or distributed cache (Redis)
+
+---
+
+## Development Guidelines
+
+### 1. Code Style
+- All code and comments: **English**
+- README.md and user documentation: **German**
+- Follow C# naming conventions (PascalCase, camelCase)
+- Use nullable reference types (`#nullable enable`)
+
+### 2. Logging
+Use Serilog with structured logging:
+```csharp
+_logger.LogInformation("Processing email {MessageId} from profile {ProfileId}", messageId, profileId);
+```
+
+### 3. Configuration
+- Development: `appsettings.Development.json` + User Secrets
+- Production: `appsettings.json` + Environment Variables + Azure Key Vault
+
+### 4. Error Handling
+- Domain: Throw `DomainException` for business rule violations
+- Application: Use `FluentValidation` for input validation
+- API: Use exception handling middleware to return proper HTTP status codes
+
+---
+
+## Deployment Scenarios
+
+### IIS Hosting (Default)
+```json
+{
+  "Hosting": {
+    "Mode": "IIS"
+  }
+}
+```
+
+### Windows Service Hosting
+```json
+{
+  "Hosting": {
+    "Mode": "WindowsService"
+  }
+}
+```
+
+In `Program.cs`:
+```csharp
+var builder = WebApplication.CreateBuilder(args);
+
+if (builder.Configuration["Hosting:Mode"] == "WindowsService")
+{
+    builder.Host.UseWindowsService();
+}
+```
+
+Install as Windows Service:
+```bash
+sc create MessagingService binPath="C:\Path\To\DigitalData.MessagingService.API.exe"
+```
+
+---
+
+## Contact and Support
+
+For questions about this implementation, consult:
+- Legacy system analysis: `legacy/PROJECT_ANALYSIS.md`
+- Migration plan: `MIGRATION_PLAN.md` (if created)
+- This document: `agents.md`
+
+---
+
+**Last Updated**: 2026-07-07
+**Version**: 1.0
+**Status**: Phase 1 Complete (Domain Layer), Phase 2-8 Pending

DigitalData.EmailProfiler.sln

@@ -1,68 +0,0 @@
-
-Microsoft Visual Studio Solution File, Format Version 12.00
-# Visual Studio Version 17
-VisualStudioVersion = 17.14.36717.8
-MinimumVisualStudioVersion = 10.0.40219.1
-Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "src", "src", "{02EA681E-C7D8-13C7-8484-4AC65E1B71E8}"
-EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "DigitalData.EmailProfiler.API", "src\DigitalData.EmailProfiler.API\DigitalData.EmailProfiler.API.csproj", "{456817AB-67A3-49DD-9EC5-1253A727B958}"
-EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "DigitalData.EmailProfiler.Infrastructure", "src\DigitalData.EmailProfiler.Infrastructure\DigitalData.EmailProfiler.Infrastructure.csproj", "{D2C32417-FE92-4063-97A9-3DA8D811E561}"
-EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "DigitalData.EmailProfiler.Domain", "src\DigitalData.EmailProfiler.Domain\DigitalData.EmailProfiler.Domain.csproj", "{76ADC1D0-4DFA-0B1E-57C9-2636434A0043}"
-EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "DigitalData.EmailProfiler.Application", "src\DigitalData.EmailProfiler.Application\DigitalData.EmailProfiler.Application.csproj", "{1874A827-C6A5-EB5E-0FE9-30A7200382B7}"
-EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "DigitalData.EmailProfiler.Tests", "tests\DigitalData.EmailProfiler.Tests\DigitalData.EmailProfiler.Tests.csproj", "{211FB65F-2406-474E-A426-DA246B250AB8}"
-EndProject
-Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "tests", "tests", "{4F20FEFD-9289-42C6-ABA6-8DB236D74559}"
-EndProject
-Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Solution Items", "Solution Items", "{8EC462FD-D22E-90A8-E5CE-7E832BA40C5D}"
-	ProjectSection(SolutionItems) = preProject
-		agents.md = agents.md
-		IMPLEMENTATION_GUIDE.md = IMPLEMENTATION_GUIDE.md
-		README.md = README.md
-		STATUS.md = STATUS.md
-	EndProjectSection
-EndProject
-Global
-	GlobalSection(SolutionConfigurationPlatforms) = preSolution
-		Debug|Any CPU = Debug|Any CPU
-		Release|Any CPU = Release|Any CPU
-	EndGlobalSection
-	GlobalSection(ProjectConfigurationPlatforms) = postSolution
-		{456817AB-67A3-49DD-9EC5-1253A727B958}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{456817AB-67A3-49DD-9EC5-1253A727B958}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{456817AB-67A3-49DD-9EC5-1253A727B958}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{456817AB-67A3-49DD-9EC5-1253A727B958}.Release|Any CPU.Build.0 = Release|Any CPU
-		{D2C32417-FE92-4063-97A9-3DA8D811E561}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{D2C32417-FE92-4063-97A9-3DA8D811E561}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{D2C32417-FE92-4063-97A9-3DA8D811E561}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{D2C32417-FE92-4063-97A9-3DA8D811E561}.Release|Any CPU.Build.0 = Release|Any CPU
-		{76ADC1D0-4DFA-0B1E-57C9-2636434A0043}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{76ADC1D0-4DFA-0B1E-57C9-2636434A0043}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{76ADC1D0-4DFA-0B1E-57C9-2636434A0043}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{76ADC1D0-4DFA-0B1E-57C9-2636434A0043}.Release|Any CPU.Build.0 = Release|Any CPU
-		{1874A827-C6A5-EB5E-0FE9-30A7200382B7}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{1874A827-C6A5-EB5E-0FE9-30A7200382B7}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{1874A827-C6A5-EB5E-0FE9-30A7200382B7}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{1874A827-C6A5-EB5E-0FE9-30A7200382B7}.Release|Any CPU.Build.0 = Release|Any CPU
-		{211FB65F-2406-474E-A426-DA246B250AB8}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{211FB65F-2406-474E-A426-DA246B250AB8}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{211FB65F-2406-474E-A426-DA246B250AB8}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{211FB65F-2406-474E-A426-DA246B250AB8}.Release|Any CPU.Build.0 = Release|Any CPU
-	EndGlobalSection
-	GlobalSection(SolutionProperties) = preSolution
-		HideSolutionNode = FALSE
-	EndGlobalSection
-	GlobalSection(NestedProjects) = preSolution
-		{456817AB-67A3-49DD-9EC5-1253A727B958} = {02EA681E-C7D8-13C7-8484-4AC65E1B71E8}
-		{D2C32417-FE92-4063-97A9-3DA8D811E561} = {02EA681E-C7D8-13C7-8484-4AC65E1B71E8}
-		{76ADC1D0-4DFA-0B1E-57C9-2636434A0043} = {02EA681E-C7D8-13C7-8484-4AC65E1B71E8}
-		{1874A827-C6A5-EB5E-0FE9-30A7200382B7} = {02EA681E-C7D8-13C7-8484-4AC65E1B71E8}
-		{211FB65F-2406-474E-A426-DA246B250AB8} = {4F20FEFD-9289-42C6-ABA6-8DB236D74559}
-	EndGlobalSection
-	GlobalSection(ExtensibilityGlobals) = postSolution
-		SolutionGuid = {90E29FDC-F6C6-414F-94BF-25DF61D18060}
-	EndGlobalSection
-EndGlobal

DigitalData.MessagingService.sln

@@ -0,0 +1,98 @@
+
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio Version 17
+VisualStudioVersion = 17.14.36717.8
+MinimumVisualStudioVersion = 10.0.40219.1
+Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "src", "src", "{02EA681E-C7D8-13C7-8484-4AC65E1B71E8}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "DigitalData.MessagingService.Tests", "tests\DigitalData.MessagingService.Tests\DigitalData.MessagingService.Tests.csproj", "{211FB65F-2406-474E-A426-DA246B250AB8}"
+EndProject
+Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "tests", "tests", "{4F20FEFD-9289-42C6-ABA6-8DB236D74559}"
+EndProject
+Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Solution Items", "Solution Items", "{8EC462FD-D22E-90A8-E5CE-7E832BA40C5D}"
+	ProjectSection(SolutionItems) = preProject
+		agents.md = agents.md
+		IMPLEMENTATION_GUIDE.md = IMPLEMENTATION_GUIDE.md
+		README.md = README.md
+		STATUS.md = STATUS.md
+	EndProjectSection
+EndProject
+Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "presentation", "presentation", "{B52B4CEE-1C67-424B-8659-370FEA7EAF2A}"
+EndProject
+Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "core", "core", "{DD9D4A3A-AB55-456E-80D3-54A2D4025E64}"
+EndProject
+Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "infrastructure", "infrastructure", "{71BEA4D0-7835-4A8C-B11E-1088E0801DCE}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "DigitalData.MessagingService.Application", "src\core\DigitalData.MessagingService.Application\DigitalData.MessagingService.Application.csproj", "{7CBE8648-F259-CC91-87FF-5859280867A8}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "DigitalData.MessagingService.Domain", "src\core\DigitalData.MessagingService.Domain\DigitalData.MessagingService.Domain.csproj", "{8E44FA5B-43DD-E273-C682-FC382A854A6D}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "DigitalData.MessagingService.Infrastructure", "src\infrastructure\DigitalData.MessagingService.Infrastructure\DigitalData.MessagingService.Infrastructure.csproj", "{56607AAB-3DEC-CB78-3062-56A8EEF5E9D2}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "DigitalData.MessagingService.RabbitMQ", "src\infrastructure\DigitalData.MessagingService.RabbitMQ\DigitalData.MessagingService.RabbitMQ.csproj", "{4CF993A6-FA3E-CBF7-C4CB-FFAEBFCFF705}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "DigitalData.MessagingService.API", "src\presentation\DigitalData.MessagingService.API\DigitalData.MessagingService.API.csproj", "{8BF22107-3CB9-C326-B94B-C40C99DA9B68}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "DigitalData.MessagingService.Publisher", "src\infrastructure\DigitalData.MessagingService.Publisher\DigitalData.MessagingService.Publisher.csproj", "{8DBBAA7C-C4D3-4ADD-8372-B0D6260C8FFC}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "DigitalData.MessagingService.Client", "src\presentation\DigitalData.MessagingService.Client\DigitalData.MessagingService.Client.csproj", "{770E96B0-C3C9-A9A3-4F98-F7A0295D1599}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|Any CPU = Debug|Any CPU
+		Release|Any CPU = Release|Any CPU
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{211FB65F-2406-474E-A426-DA246B250AB8}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{211FB65F-2406-474E-A426-DA246B250AB8}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{211FB65F-2406-474E-A426-DA246B250AB8}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{211FB65F-2406-474E-A426-DA246B250AB8}.Release|Any CPU.Build.0 = Release|Any CPU
+		{7CBE8648-F259-CC91-87FF-5859280867A8}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{7CBE8648-F259-CC91-87FF-5859280867A8}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{7CBE8648-F259-CC91-87FF-5859280867A8}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{7CBE8648-F259-CC91-87FF-5859280867A8}.Release|Any CPU.Build.0 = Release|Any CPU
+		{8E44FA5B-43DD-E273-C682-FC382A854A6D}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{8E44FA5B-43DD-E273-C682-FC382A854A6D}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{8E44FA5B-43DD-E273-C682-FC382A854A6D}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{8E44FA5B-43DD-E273-C682-FC382A854A6D}.Release|Any CPU.Build.0 = Release|Any CPU
+		{56607AAB-3DEC-CB78-3062-56A8EEF5E9D2}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{56607AAB-3DEC-CB78-3062-56A8EEF5E9D2}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{56607AAB-3DEC-CB78-3062-56A8EEF5E9D2}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{56607AAB-3DEC-CB78-3062-56A8EEF5E9D2}.Release|Any CPU.Build.0 = Release|Any CPU
+		{4CF993A6-FA3E-CBF7-C4CB-FFAEBFCFF705}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{4CF993A6-FA3E-CBF7-C4CB-FFAEBFCFF705}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{4CF993A6-FA3E-CBF7-C4CB-FFAEBFCFF705}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{4CF993A6-FA3E-CBF7-C4CB-FFAEBFCFF705}.Release|Any CPU.Build.0 = Release|Any CPU
+		{8BF22107-3CB9-C326-B94B-C40C99DA9B68}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{8BF22107-3CB9-C326-B94B-C40C99DA9B68}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{8BF22107-3CB9-C326-B94B-C40C99DA9B68}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{8BF22107-3CB9-C326-B94B-C40C99DA9B68}.Release|Any CPU.Build.0 = Release|Any CPU
+		{8DBBAA7C-C4D3-4ADD-8372-B0D6260C8FFC}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{8DBBAA7C-C4D3-4ADD-8372-B0D6260C8FFC}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{8DBBAA7C-C4D3-4ADD-8372-B0D6260C8FFC}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{8DBBAA7C-C4D3-4ADD-8372-B0D6260C8FFC}.Release|Any CPU.Build.0 = Release|Any CPU
+		{770E96B0-C3C9-A9A3-4F98-F7A0295D1599}.Debug|Any CPU.ActiveCfg = Release|Any CPU
+		{770E96B0-C3C9-A9A3-4F98-F7A0295D1599}.Debug|Any CPU.Build.0 = Release|Any CPU
+		{770E96B0-C3C9-A9A3-4F98-F7A0295D1599}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{770E96B0-C3C9-A9A3-4F98-F7A0295D1599}.Release|Any CPU.Build.0 = Release|Any CPU
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+	GlobalSection(NestedProjects) = preSolution
+		{211FB65F-2406-474E-A426-DA246B250AB8} = {4F20FEFD-9289-42C6-ABA6-8DB236D74559}
+		{B52B4CEE-1C67-424B-8659-370FEA7EAF2A} = {02EA681E-C7D8-13C7-8484-4AC65E1B71E8}
+		{DD9D4A3A-AB55-456E-80D3-54A2D4025E64} = {02EA681E-C7D8-13C7-8484-4AC65E1B71E8}
+		{71BEA4D0-7835-4A8C-B11E-1088E0801DCE} = {02EA681E-C7D8-13C7-8484-4AC65E1B71E8}
+		{7CBE8648-F259-CC91-87FF-5859280867A8} = {DD9D4A3A-AB55-456E-80D3-54A2D4025E64}
+		{8E44FA5B-43DD-E273-C682-FC382A854A6D} = {DD9D4A3A-AB55-456E-80D3-54A2D4025E64}
+		{56607AAB-3DEC-CB78-3062-56A8EEF5E9D2} = {71BEA4D0-7835-4A8C-B11E-1088E0801DCE}
+		{4CF993A6-FA3E-CBF7-C4CB-FFAEBFCFF705} = {71BEA4D0-7835-4A8C-B11E-1088E0801DCE}
+		{8BF22107-3CB9-C326-B94B-C40C99DA9B68} = {B52B4CEE-1C67-424B-8659-370FEA7EAF2A}
+		{8DBBAA7C-C4D3-4ADD-8372-B0D6260C8FFC} = {71BEA4D0-7835-4A8C-B11E-1088E0801DCE}
+		{770E96B0-C3C9-A9A3-4F98-F7A0295D1599} = {B52B4CEE-1C67-424B-8659-370FEA7EAF2A}
+	EndGlobalSection
+	GlobalSection(ExtensibilityGlobals) = postSolution
+		SolutionGuid = {90E29FDC-F6C6-414F-94BF-25DF61D18060}
+	EndGlobalSection
+EndGlobal

IMPLEMENTATION_GUIDE.md

@@ -1,8 +1,8 @@
-# EmailProfiler - Implementation Guide for AI Agents
+# MessagingService - Implementation Guide for AI Agents
 
 ## Overview
 
-This guide provides step-by-step instructions for AI agents to continue the implementation of the EmailProfiler application. The project is a modern .NET 8.0 rewrite of a legacy VB.NET email automation system.
+This guide provides step-by-step instructions for AI agents to continue the implementation of the MessagingService application. The project is a modern .NET 8.0 rewrite of a legacy VB.NET email automation system.
 
 ---
 
@@ -34,7 +34,7 @@ This guide provides step-by-step instructions for AI agents to continue the impl
 ## Architecture Overview
 
 ```
-DigitalData.EmailProfiler/
+DigitalData.MessagingService/
 ├── src/
 │   ├── Domain/              ✅ COMPLETE
 │   ├── Application/         🚧 IN PROGRESS (5%)
@@ -56,15 +56,15 @@ DigitalData.EmailProfiler/
 
 #### 2.1. Create Repository Interfaces
 
-**Location**: `src/DigitalData.EmailProfiler.Application/Interfaces/Repositories/`
+**Location**: `src/DigitalData.MessagingService.Application/Interfaces/Repositories/`
 
 Create these files:
 
 **IEmailProfileRepository.cs**:
 ```csharp
-using DigitalData.EmailProfiler.Domain.Entities;
+using DigitalData.MessagingService.Domain.Entities;
 
-namespace DigitalData.EmailProfiler.Application.Interfaces.Repositories;
+namespace DigitalData.MessagingService.Application.Interfaces.Repositories;
 
 public interface IEmailProfileRepository
 {
@@ -80,9 +80,9 @@ public interface IEmailProfileRepository
 
 **IEmailAccountRepository.cs**:
 ```csharp
-using DigitalData.EmailProfiler.Domain.Entities;
+using DigitalData.MessagingService.Domain.Entities;
 
-namespace DigitalData.EmailProfiler.Application.Interfaces.Repositories;
+namespace DigitalData.MessagingService.Application.Interfaces.Repositories;
 
 public interface IEmailAccountRepository
 {
@@ -97,9 +97,9 @@ public interface IEmailAccountRepository
 
 **IEmailHistoryRepository.cs**:
 ```csharp
-using DigitalData.EmailProfiler.Domain.Entities;
+using DigitalData.MessagingService.Domain.Entities;
 
-namespace DigitalData.EmailProfiler.Application.Interfaces.Repositories;
+namespace DigitalData.MessagingService.Application.Interfaces.Repositories;
 
 public interface IEmailHistoryRepository
 {
@@ -116,11 +116,11 @@ public interface IEmailHistoryRepository
 
 #### 2.2. Create Service Interfaces
 
-**Location**: `src/DigitalData.EmailProfiler.Application/Interfaces/Services/`
+**Location**: `src/DigitalData.MessagingService.Application/Interfaces/Services/`
 
 **IEmailService.cs**:
 ```csharp
-namespace DigitalData.EmailProfiler.Application.Interfaces.Services;
+namespace DigitalData.MessagingService.Application.Interfaces.Services;
 
 public interface IEmailService
 {
@@ -169,13 +169,13 @@ public class EmailAttachmentData
 
 #### 2.3. Create MediatR Commands
 
-**Location**: `src/DigitalData.EmailProfiler.Application/EmailProfiles/Commands/`
+**Location**: `src/DigitalData.MessagingService.Application/EmailProfiles/Commands/`
 
 **CreateEmailProfileCommand.cs**:
 ```csharp
 using MediatR;
 
-namespace DigitalData.EmailProfiler.Application.EmailProfiles.Commands;
+namespace DigitalData.MessagingService.Application.EmailProfiles.Commands;
 
 public record CreateEmailProfileCommand(
     string ProfileName,
@@ -213,15 +213,15 @@ public class CreateEmailProfileCommandHandler : IRequestHandler<CreateEmailProfi
 
 #### 2.4. Create MediatR Queries
 
-**Location**: `src/DigitalData.EmailProfiler.Application/EmailProfiles/Queries/`
+**Location**: `src/DigitalData.MessagingService.Application/EmailProfiles/Queries/`
 
 **GetEmailProfilesQuery.cs**:
 ```csharp
 using MediatR;
 using AutoMapper;
-using DigitalData.EmailProfiler.Application.Common.Dtos;
+using DigitalData.MessagingService.Application.Common.Dtos;
 
-namespace DigitalData.EmailProfiler.Application.EmailProfiles.Queries;
+namespace DigitalData.MessagingService.Application.EmailProfiles.Queries;
 
 public record GetEmailProfilesQuery : IRequest<List<EmailProfileDto>>;
 
@@ -248,14 +248,14 @@ public class GetEmailProfilesQueryHandler : IRequestHandler<GetEmailProfilesQuer
 
 #### 2.5. Create Validators
 
-**Location**: `src/DigitalData.EmailProfiler.Application/EmailProfiles/Validators/`
+**Location**: `src/DigitalData.MessagingService.Application/EmailProfiles/Validators/`
 
 **CreateEmailProfileCommandValidator.cs**:
 ```csharp
 using FluentValidation;
-using DigitalData.EmailProfiler.Application.EmailProfiles.Commands;
+using DigitalData.MessagingService.Application.EmailProfiles.Commands;
 
-namespace DigitalData.EmailProfiler.Application.EmailProfiles.Validators;
+namespace DigitalData.MessagingService.Application.EmailProfiles.Validators;
 
 public class CreateEmailProfileCommandValidator : AbstractValidator<CreateEmailProfileCommand>
 {
@@ -277,15 +277,15 @@ public class CreateEmailProfileCommandValidator : AbstractValidator<CreateEmailP
 
 #### 2.6. Create AutoMapper Profiles
 
-**Location**: `src/DigitalData.EmailProfiler.Application/Common/Mappings/`
+**Location**: `src/DigitalData.MessagingService.Application/Common/Mappings/`
 
 **MappingProfile.cs**:
 ```csharp
 using AutoMapper;
-using DigitalData.EmailProfiler.Domain.Entities;
-using DigitalData.EmailProfiler.Application.Common.Dtos;
+using DigitalData.MessagingService.Domain.Entities;
+using DigitalData.MessagingService.Application.Common.Dtos;
 
-namespace DigitalData.EmailProfiler.Application.Common.Mappings;
+namespace DigitalData.MessagingService.Application.Common.Mappings;
 
 public class MappingProfile : Profile
 {
@@ -312,14 +312,14 @@ public class MappingProfile : Profile
 
 #### 2.7. Create DependencyInjection.cs
 
-**Location**: `src/DigitalData.EmailProfiler.Application/DependencyInjection.cs`
+**Location**: `src/DigitalData.MessagingService.Application/DependencyInjection.cs`
 
 ```csharp
 using Microsoft.Extensions.DependencyInjection;
 using FluentValidation;
 using System.Reflection;
 
-namespace DigitalData.EmailProfiler.Application;
+namespace DigitalData.MessagingService.Application;
 
 public static class DependencyInjection
 {
@@ -348,7 +348,7 @@ public static class DependencyInjection
 #### 3.1. Add NuGet Packages
 
 ```bash
-cd src/DigitalData.EmailProfiler.Infrastructure
+cd src/DigitalData.MessagingService.Infrastructure
 dotnet add package Microsoft.EntityFrameworkCore.SqlServer
 dotnet add package Microsoft.EntityFrameworkCore.Tools
 dotnet add package MailKit
@@ -360,18 +360,18 @@ dotnet add package Microsoft.AspNetCore.DataProtection
 
 #### 3.2. Create DbContext
 
-**Location**: `src/DigitalData.EmailProfiler.Infrastructure/Persistence/EmailProfilerDbContext.cs`
+**Location**: `src/DigitalData.MessagingService.Infrastructure/Persistence/MessagingServiceDbContext.cs`
 
 ```csharp
 using Microsoft.EntityFrameworkCore;
-using DigitalData.EmailProfiler.Domain.Entities;
+using DigitalData.MessagingService.Domain.Entities;
 using System.Reflection;
 
-namespace DigitalData.EmailProfiler.Infrastructure.Persistence;
+namespace DigitalData.MessagingService.Infrastructure.Persistence;
 
-public class EmailProfilerDbContext : DbContext
+public class MessagingServiceDbContext : DbContext
 {
-    public EmailProfilerDbContext(DbContextOptions<EmailProfilerDbContext> options) : base(options) { }
+    public MessagingServiceDbContext(DbContextOptions<MessagingServiceDbContext> options) : base(options) { }
     
     public DbSet<EmailAccount> EmailAccounts { get; set; }
     public DbSet<EmailProfile> EmailProfiles { get; set; }
@@ -420,21 +420,21 @@ public class EmailProfilerDbContext : DbContext
 
 #### 3.3. Create Repositories
 
-**Location**: `src/DigitalData.EmailProfiler.Infrastructure/Persistence/Repositories/`
+**Location**: `src/DigitalData.MessagingService.Infrastructure/Persistence/Repositories/`
 
 **EmailProfileRepository.cs**:
 ```csharp
 using Microsoft.EntityFrameworkCore;
-using DigitalData.EmailProfiler.Domain.Entities;
-using DigitalData.EmailProfiler.Application.Interfaces.Repositories;
+using DigitalData.MessagingService.Domain.Entities;
+using DigitalData.MessagingService.Application.Interfaces.Repositories;
 
-namespace DigitalData.EmailProfiler.Infrastructure.Persistence.Repositories;
+namespace DigitalData.MessagingService.Infrastructure.Persistence.Repositories;
 
 public class EmailProfileRepository : IEmailProfileRepository
 {
-    private readonly EmailProfilerDbContext _context;
+    private readonly MessagingServiceDbContext _context;
     
-    public EmailProfileRepository(EmailProfilerDbContext context)
+    public EmailProfileRepository(MessagingServiceDbContext context)
     {
         _context = context;
     }
@@ -516,17 +516,17 @@ Create similar repositories for **EmailAccountRepository**, **EmailHistoryReposi
 
 #### 3.5. Create DependencyInjection.cs
 
-**Location**: `src/DigitalData.EmailProfiler.Infrastructure/DependencyInjection.cs`
+**Location**: `src/DigitalData.MessagingService.Infrastructure/DependencyInjection.cs`
 
 ```csharp
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Configuration;
 using Microsoft.EntityFrameworkCore;
-using DigitalData.EmailProfiler.Infrastructure.Persistence;
-using DigitalData.EmailProfiler.Application.Interfaces.Repositories;
-using DigitalData.EmailProfiler.Infrastructure.Persistence.Repositories;
+using DigitalData.MessagingService.Infrastructure.Persistence;
+using DigitalData.MessagingService.Application.Interfaces.Repositories;
+using DigitalData.MessagingService.Infrastructure.Persistence.Repositories;
 
-namespace DigitalData.EmailProfiler.Infrastructure;
+namespace DigitalData.MessagingService.Infrastructure;
 
 public static class DependencyInjection
 {
@@ -535,7 +535,7 @@ public static class DependencyInjection
         IConfiguration configuration)
     {
         // DbContext
-        services.AddDbContext<EmailProfilerDbContext>(options =>
+        services.AddDbContext<MessagingServiceDbContext>(options =>
             options.UseSqlServer(
                 configuration.GetConnectionString("DefaultConnection"),
                 sqlOptions =>
@@ -572,7 +572,7 @@ public static class DependencyInjection
 #### 4.1. Add NuGet Packages
 
 ```bash
-cd src/DigitalData.EmailProfiler.API
+cd src/DigitalData.MessagingService.API
 dotnet add package Serilog.AspNetCore
 dotnet add package Serilog.Sinks.File
 dotnet add package Serilog.Sinks.MSSqlServer
@@ -581,12 +581,12 @@ dotnet add package Scalar.AspNetCore
 
 #### 4.2. Update Program.cs
 
-**Location**: `src/DigitalData.EmailProfiler.API/Program.cs`
+**Location**: `src/DigitalData.MessagingService.API/Program.cs`
 
 ```csharp
-using DigitalData.EmailProfiler.API;
-using DigitalData.EmailProfiler.Application;
-using DigitalData.EmailProfiler.Infrastructure;
+using DigitalData.MessagingService.API;
+using DigitalData.MessagingService.Application;
+using DigitalData.MessagingService.Infrastructure;
 using Serilog;
 using Scalar.AspNetCore;
 
@@ -639,7 +639,7 @@ app.MapControllers();
 
 try
 {
-    Log.Information("Starting EmailProfiler API");
+    Log.Information("Starting MessagingService API");
     app.Run();
 }
 catch (Exception ex)
@@ -654,16 +654,16 @@ finally
 
 #### 4.3. Create Controllers
 
-**Location**: `src/DigitalData.EmailProfiler.API/Controllers/`
+**Location**: `src/DigitalData.MessagingService.API/Controllers/`
 
 **EmailProfilesController.cs**:
 ```csharp
 using Microsoft.AspNetCore.Mvc;
 using MediatR;
-using DigitalData.EmailProfiler.Application.EmailProfiles.Commands;
-using DigitalData.EmailProfiler.Application.EmailProfiles.Queries;
+using DigitalData.MessagingService.Application.EmailProfiles.Commands;
+using DigitalData.MessagingService.Application.EmailProfiles.Queries;
 
-namespace DigitalData.EmailProfiler.API.Controllers;
+namespace DigitalData.MessagingService.API.Controllers;
 
 [ApiController]
 [Route("api/[controller]")]
@@ -713,13 +713,13 @@ Create similar controllers for **EmailAccountsController**, **EmailHistoryContro
 
 #### 4.4. Create Background Workers
 
-**Location**: `src/DigitalData.EmailProfiler.API/Workers/`
+**Location**: `src/DigitalData.MessagingService.API/Workers/`
 
 **EmailPollingWorker.cs** and **EmailSenderWorker.cs** (See agents.md for implementation examples)
 
 #### 4.5. Update appsettings.json
 
-**Location**: `src/DigitalData.EmailProfiler.API/appsettings.json`
+**Location**: `src/DigitalData.MessagingService.API/appsettings.json`
 
 ```json
 {
@@ -758,7 +758,7 @@ Create similar controllers for **EmailAccountsController**, **EmailHistoryContro
 #### 5.1. Add NuGet Packages
 
 ```bash
-cd tests/DigitalData.EmailProfiler.Tests
+cd tests/DigitalData.MessagingService.Tests
 dotnet add package FakeItEasy
 dotnet add package Bogus
 dotnet add package FluentAssertions
@@ -768,15 +768,15 @@ dotnet add package Testcontainers.MsSql
 
 #### 5.2. Create Unit Tests
 
-**Location**: `tests/DigitalData.EmailProfiler.Tests/Unit/Domain/`
+**Location**: `tests/DigitalData.MessagingService.Tests/Unit/Domain/`
 
 **MessageIdGeneratorTests.cs**:
 ```csharp
 using Xunit;
 using FluentAssertions;
-using DigitalData.EmailProfiler.Domain.Services;
+using DigitalData.MessagingService.Domain.Services;
 
-namespace DigitalData.EmailProfiler.Tests.Unit.Domain;
+namespace DigitalData.MessagingService.Tests.Unit.Domain;
 
 public class MessageIdGeneratorTests
 {
@@ -844,7 +844,7 @@ The README should include (in German):
 
 **Template structure**:
 ```markdown
-# DigitalData EmailProfiler
+# DigitalData MessagingService
 
 ## Übersicht
 [Application overview in German]
@@ -912,15 +912,15 @@ dotnet build
 dotnet test
 
 # Run API
-cd src/DigitalData.EmailProfiler.API
+cd src/DigitalData.MessagingService.API
 dotnet run
 
 # Create migration
-cd src/DigitalData.EmailProfiler.Infrastructure
-dotnet ef migrations add InitialCreate --startup-project ../DigitalData.EmailProfiler.API
+cd src/DigitalData.MessagingService.Infrastructure
+dotnet ef migrations add InitialCreate --startup-project ../DigitalData.MessagingService.API
 
 # Update database
-dotnet ef database update --startup-project ../DigitalData.EmailProfiler.API
+dotnet ef database update --startup-project ../DigitalData.MessagingService.API
 ```
 
 ---

README.md

@@ -1,2 +1,2 @@
-# DigitalData.EmailProfiler
+# DigitalData.MessagingService
 

STATUS.md

@@ -1,266 +1,506 @@
-# EmailProfiler - Current Implementation Status
+# MessagingService - Implementation Status Report
 
-**Last Updated**: 2026-07-07
+**Last Updated**: 2026-07-20  
+**Overall Progress**: 75% Complete (3 of 4 phases done)
 
 ---
 
-## ✅ COMPLETED (Phase 1: Domain Layer - 100%)
+## Executive Summary
 
-### Entities (with proper [Table] and [Column] attributes)
-- ✅ `EmailAccount.cs` - Maps to `TBDD_EMAIL_ACCOUNT`
-- ✅ `EmailProfile.cs` - Maps to `TBEMLP_POLL_PROFILES`
-- ✅ `EmailProcess.cs` - Maps to `TBEMLP_POLL_PROCESS`
-- ✅ `ProcessStep.cs` - Maps to `TBEMLP_POLL_STEPS`
-- ✅ `IndexingStep.cs` - Maps to `TBEMLP_POLL_INDEXING_STEPS`
-- ✅ `EmailHistory.cs` - Maps to `TBEMLP_HISTORY`
-- ✅ `EmailAttachment.cs` - Maps to `TBEMLP_HISTORY_ATTACHMENT`
-- ✅ `EmailOutbox.cs` - Maps to `TBEMLP_EMAIL_OUT`
+The MessagingService migration from legacy VB.NET to modern C# .NET 8.0 Clean Architecture is **75% complete**. All core layers (Domain, Application, Infrastructure) are fully implemented with real service stubs ready for integration. Only API layer controllers and workers remain.
 
-### Value Objects
-- ✅ `MessageId.cs` - Uses SHA256 hash (legacy-compatible algorithm)
-- ✅ `EmailAddress.cs` - Email validation and parsing
+### ✅ What's Working
+- Complete Domain model with 8 entities mapped to legacy database
+- Full CQRS implementation with MediatR (5 Commands, 7 Queries)
+- Generic repository with AutoMapper-based CRUD
+- RabbitMQ integration for async command processing
+- Real service implementations (pending external dependencies)
+- Data Protection encryption service
+- Database context with legacy table mapping
 
-### Enums
-- ✅ `ErrorCode.cs` - All error codes from legacy system
-- ✅ `ProcessType.cs` - ProcessManager, AttachmentSniffer, ZugFeRDParser
-- ✅ `AuthenticationType.cs` - UsernamePassword, OAuth2
-- ✅ `EmailStatus.cs` - Email processing status
-- ✅ `AttachmentStatus.cs` - Attachment validation status
-
-### Common Classes
-- ✅ `BaseEntity.cs` - Base class with audit fields
-- ✅ `IAggregateRoot.cs` - DDD aggregate root marker
-- ✅ `ValueObject.cs` - Base class for value objects
-
-### Domain Services
-- ✅ `MessageIdGenerator.cs` - Generates unique message IDs with legacy-compatible hash
-
-### Domain Events
-- ✅ `EmailProcessedEvent.cs` - MediatR event for email processing
-
-### Exceptions
-- ✅ `DomainException.cs` - Base domain exception
-- ✅ `ValidationException.cs` - Validation errors
-- ✅ `AttachmentProcessingException.cs` - Attachment-specific errors
-
-### NuGet Packages
-- ✅ Domain project has MediatR 12.2.0
+### ⚠️ What's Missing
+- Limilabs.Mail NuGet package (for email operations)
+- GdPicture.NET 14 or DevExpress.Pdf NuGet (for PDF processing)
+- windream COM Interop DLLs (for DMS integration)
+- API Controllers and Background Workers
+- Unit and integration tests
 
 ---
 
-## 🚧 IN PROGRESS (Phase 2: Application Layer - 5%)
+## Phase Breakdown
 
-### DTOs
-- ✅ `CommonDtos.cs` - EmailProfileDto, EmailAccountDto, EmailHistoryDto, EmailAttachmentDto
+### Phase 1: Domain Layer ✅ COMPLETE (100%)
 
-### NuGet Packages
-- ✅ Application project has:
-  - MediatR 14.2.0
-  - AutoMapper.Extensions.Microsoft.DependencyInjection 12.0.1
-  - FluentValidation.DependencyInjectionExtensions 12.1.1
+**Entities** (8 total):
+- ✅ `EmailAccount` - Email server configuration (IMAP/SMTP/OAuth2)
+- ✅ `EmailProfile` - Email polling profiles with archiving rules
+- ✅ `EmailHistory` - Email import history with duplicate detection
+- ✅ `EmailAttachment` - Attachment metadata and file paths
+- ✅ `EmailFilterKeyword` - Keyword-based filtering rules
+- ✅ `EmailFilterRule` - Sender/recipient filtering rules
+- ✅ `WindreamArchive` - windream DMS archive metadata
+- ✅ `LogEmailOut` - Outgoing email queue
+
+**Value Objects** (3 total):
+- ✅ `MessageId` - SHA256-based message ID with duplicate detection
+- ✅ `EmailAddress` - Validated email address with display name
+- ✅ `FilePathValue` - Validated file system paths
+
+**Enums** (5 total):
+- ✅ `ArchiveMode` - Email archiving strategies
+- ✅ `EmailAccountType` - Account types (Exchange/IMAP/Office365)
+- ✅ `EmailProtocol` - Email protocols (POP3/IMAP)
+- ✅ `FilterActionType` - Filter actions (Delete/MoveFolder)
+- ✅ `ProcessingStatus` - Processing states (Pending/Success/Error)
+
+**Domain Events** (2 total):
+- ✅ `EmailProcessedEvent` - Published after successful email processing
+- ✅ `EmailArchivedEvent` - Published after windream archiving
+
+**Domain Services** (1 total):
+- ✅ `MessageIdGenerator` - Generates SHA256 message IDs (legacy-compatible)
+
+**Key Features**:
+- All entities use `[Table]` and `[Column]` attributes for legacy database mapping
+- NO database modifications allowed (read-only schema)
+- DateTime fields use `DateTime.Now` (local server time, not UTC)
+- Entities handle all configuration (NO Fluent API in DbContext)
+
+**Files**:
+```
+src/DigitalData.MessagingService.Domain/
+├── Entities/ (8 files)
+├── ValueObjects/ (3 files)
+├── Enums/ (5 files)
+├── Events/ (2 files)
+└── Services/ (1 file)
+```
 
 ---
 
-## ❌ TODO (Phase 2: Application Layer - 95%)
+### Phase 2: Application Layer ✅ COMPLETE (100%)
 
-### Repository Interfaces
-- ❌ `IEmailProfileRepository.cs`
-- ❌ `IEmailAccountRepository.cs`
-- ❌ `IEmailHistoryRepository.cs`
-- ❌ `IEmailProcessRepository.cs`
-- ❌ `IEmailOutboxRepository.cs`
+**Commands** (5 total):
+- ✅ `CreateEmailProfileCommand` - Create new email profile
+- ✅ `UpdateEmailProfileCommand` - Update existing profile
+- ✅ `DeleteEmailProfileCommand` - Delete profile
+- ✅ `CreateEmailAccountCommand` - Create email account
+- ✅ `ProcessEmailCommand` - Process incoming email
 
-### Service Interfaces
-- ❌ `IEmailService.cs`
-- ❌ `IPdfProcessingService.cs`
-- ❌ `IDmsService.cs`
-- ❌ `IEncryptionService.cs`
-- ❌ `IEmailQueue.cs`
+**Queries** (7 total):
+- ✅ `GetEmailProfilesQuery` - Get all profiles
+- ✅ `GetEmailProfileByIdQuery` - Get profile by ID
+- ✅ `GetEmailAccountsQuery` - Get all accounts
+- ✅ `GetEmailAccountByIdQuery` - Get account by ID
+- ✅ `GetEmailHistoryQuery` - Get email history with filters
+- ✅ `GetWindreamArchivesQuery` - Get windream archives
+- ✅ `GetLogEmailOutQuery` - Get outgoing email queue
 
-### MediatR Commands
-- ❌ `CreateEmailProfileCommand.cs`
-- ❌ `UpdateEmailProfileCommand.cs`
-- ❌ `DeleteEmailProfileCommand.cs`
-- ❌ `ActivateProfileCommand.cs`
-- ❌ `DeactivateProfileCommand.cs`
-- ❌ Similar commands for EmailAccount, EmailProcess, etc.
+**Validators** (4 total):
+- ✅ `CreateEmailProfileCommandValidator` - FluentValidation for CreateEmailProfileCommand
+- ✅ `UpdateEmailProfileCommandValidator` - FluentValidation for UpdateEmailProfileCommand
+- ✅ `CreateEmailAccountCommandValidator` - FluentValidation for CreateEmailAccountCommand
+- ✅ `ProcessEmailCommandValidator` - FluentValidation for ProcessEmailCommand
 
-### MediatR Queries
-- ❌ `GetEmailProfilesQuery.cs`
-- ❌ `GetEmailProfileByIdQuery.cs`
-- ❌ `GetActiveProfilesQuery.cs`
-- ❌ `GetProfilesDueForPollingQuery.cs`
-- ❌ Similar queries for other entities
+**AutoMapper Profiles** (4 total):
+- ✅ `EmailProfileMappingProfile` - Maps EmailProfile DTOs ↔ Entities
+- ✅ `EmailAccountMappingProfile` - Maps EmailAccount DTOs ↔ Entities
+- ✅ `EmailHistoryMappingProfile` - Maps EmailHistory DTOs ↔ Entities
+- ✅ `WindreamArchiveMappingProfile` - Maps WindreamArchive DTOs ↔ Entities
 
-### Validators
-- ❌ `CreateEmailProfileCommandValidator.cs`
-- ❌ `UpdateEmailProfileCommandValidator.cs`
-- ❌ Similar validators for all commands
+**DTOs** (8 total):
+- ✅ `EmailAccountDto` - Email account configuration
+- ✅ `EmailProfileDto` - Email profile configuration
+- ✅ `CreateEmailProfileDto` - Create profile request
+- ✅ `UpdateEmailProfileDto` - Update profile request
+- ✅ `EmailHistoryDto` - Email history record
+- ✅ `EmailAttachmentDto` - Attachment metadata
+- ✅ `WindreamArchiveDto` - windream archive record
+- ✅ `LogEmailOutDto` - Outgoing email record
 
-### Mappings
-- ❌ `MappingProfile.cs` - AutoMapper configuration
+**Interfaces** (6 total):
+- ✅ `IRepository<T>` - Generic repository with AutoMapper CRUD
+- ✅ `IEmailService` - Email operations (IMAP/SMTP/OAuth2)
+- ✅ `IPdfProcessingService` - PDF validation and embedded file extraction
+- ✅ `IDmsService` - windream DMS integration
+- ✅ `IEncryptionService` - Encryption/decryption for passwords
+- ✅ `IEmailQueue` - Outgoing email queue
 
-### DI Configuration
-- ❌ `DependencyInjection.cs` - Application layer DI setup
+**Key Features**:
+- Commands/Queries/Handlers in SAME file (MediatR pattern)
+- AutoMapper-based repository operations (no manual mapping)
+- FluentValidation for all commands
+- Direct folder structure: `Application/{Entity}/Commands`, `Application/{Entity}/Queries` (NO Features/ parent)
+- DTOs organized: Single DTOs at root (`Common/Dtos/EmailAccountDto.cs`), Multiple DTOs in subfolders (`Common/Dtos/EmailHistories/`)
+
+**Files**:
+```
+src/DigitalData.MessagingService.Application/
+├── EmailProfiles/Commands/ (3 files)
+├── EmailProfiles/Queries/ (2 files)
+├── EmailProfiles/Validators/ (2 files)
+├── EmailAccounts/Commands/ (1 file)
+├── EmailAccounts/Queries/ (2 files)
+├── EmailAccounts/Validators/ (1 file)
+├── EmailProcessing/Commands/ (1 file)
+├── EmailProcessing/Validators/ (1 file)
+├── EmailHistory/Queries/ (1 file)
+├── WindreamArchives/Queries/ (1 file)
+├── LogEmailOut/Queries/ (1 file)
+└── Common/
+    ├── Dtos/ (8 files)
+    ├── Interfaces/ (6 files)
+    └── Mappings/ (4 files)
+```
 
 ---
 
-## ❌ TODO (Phase 3: Infrastructure Layer - 0%)
+### Phase 3: Infrastructure Layer ✅ COMPLETE (100%)
 
-### NuGet Packages
-- ❌ Microsoft.EntityFrameworkCore.SqlServer
-- ❌ Microsoft.EntityFrameworkCore.Tools
-- ❌ MailKit
-- ❌ MimeKit
-- ❌ PdfSharp
-- ❌ Microsoft.Identity.Client
-- ❌ Microsoft.AspNetCore.DataProtection
+**Database**:
+- ✅ `MessagingServiceDbContext` - EF Core DbContext with 8 DbSets
+  - NO `OnModelCreating` override (attribute-only configuration)
+  - NO `SaveChangesAsync` override (Repository handles this)
+  - Connection string: `DefaultConnection` from appsettings
 
-### Persistence
-- ❌ `EmailProfilerDbContext.cs`
-- ❌ EF Core migrations
+**Repository**:
+- ✅ `Repository<T>` - Generic repository implementing `IRepository<T>`
+  - AutoMapper-based CRUD: `CreateAsync<TDto>`, `UpdateAsync<TDto>`, `DeleteAsync`
+  - Safe single-record operations: `UpdateSingleAsync`, `DeleteSingleAsync` (throw if 0 or 2+ records)
+  - Query methods: `GetByIdAsync`, `GetAllAsync`, `FindAsync`, `FindFirstAsync`, `FindSingleAsync`
+  - All operations auto-save changes (NO explicit SaveChangesAsync needed)
 
-### Repositories
-- ❌ `EmailProfileRepository.cs`
-- ❌ `EmailAccountRepository.cs`
-- ❌ `EmailHistoryRepository.cs`
-- ❌ `EmailProcessRepository.cs`
-- ❌ `EmailOutboxRepository.cs`
+**Services** (6 total):
+- ✅ `LimilabsEmailService` - Email operations using Limilabs Mail.dll
+  - IMAP: `ConnectSSLAsync`, `LoginOAUTH2Async`, `Search(Flag.Unseen)`, `GetMessageByUID`
+  - SMTP: `SendMessageAsync`
+  - OAuth2: `GetOAuth2TokenAsync` via `Microsoft.Identity.Client` (MSAL)
+  - **TODO**: Add Limilabs.Mail NuGet package to uncomment implementation
 
-### External Services
-- ❌ `MailKitEmailService.cs` - IMAP/SMTP with OAuth2
-- ❌ `PdfSharpProcessingService.cs` - PDF validation and embedded file extraction
-- ❌ `WindreamDmsService.cs` - windream DMS integration (COM Interop)
-- ❌ `DataProtectionEncryptionService.cs` - Password encryption
-- ❌ `InMemoryEmailQueue.cs` - Email queue (Channel-based)
+- ✅ `GdPicturePdfProcessingService` - PDF processing using GdPicture.NET 14
+  - `ValidatePdfAsync` - PDF validation
+  - `ExtractEmbeddedFilesAsync` - Extract embedded files via `GetAttachmentCount`, `ExtractEmbeddedFile`
+  - `GetPageCountAsync` - Get PDF page count
+  - **TODO**: Add GdPicture.NET.14 NuGet package and license key
 
-### DI Configuration
-- ❌ `DependencyInjection.cs` - Infrastructure layer DI setup
+- ✅ `WindreamDmsService` - windream DMS integration using COM Interop
+  - `ImportDocumentAsync` - Import document with metadata (WMSession, WMConnect, WMObjects)
+  - `DocumentExistsAsync` - Check if document exists
+  - `UpdateMetadataAsync` - Update document metadata
+  - **TODO**: Add windream COM Interop DLL references (WINDREAMLib, WMOBRWSLib)
+
+- ✅ `DataProtectionEncryptionService` - Encryption using ASP.NET Core Data Protection
+  - `Encrypt(plainText)` - Encrypt passwords/secrets
+  - `Decrypt(cipherText)` - Decrypt passwords/secrets
+
+- ✅ `InMemoryEmailQueue` - Temporary in-memory queue for outgoing emails
+  - `EnqueueAsync` - Add email to queue
+  - `DequeueAsync` - Get next email from queue
+  - **TODO**: Replace with `RabbitMqEmailQueue` for production
+
+- ✅ `RabbitMqCommandPublisher` - Publishes commands to RabbitMQ
+  - Implements `ICommandPublisher`
+  - Serializes commands to JSON with metadata envelope
+  - Publishes to `emailprofiler.commands` exchange
+
+- ✅ `RabbitMqCommandConsumer` - Consumes commands from RabbitMQ (BackgroundService)
+  - Consumes from `emailprofiler.command.queue`
+  - Deserializes and executes commands via MediatR
+  - Acknowledges or requeues messages
+
+**Configuration**:
+- ✅ `RabbitMqConfiguration` - RabbitMQ connection settings (binds to `appsettings.json`)
+
+**Dependency Injection**:
+- ✅ `DependencyInjection.cs` - Infrastructure service registration
+  - DbContext with SQL Server retry policy
+  - Generic repository (scoped)
+  - All services (scoped)
+  - RabbitMQ publisher (singleton) and consumer (hosted service)
+  - Data Protection with default key storage
+
+**NuGet Packages**:
+- ✅ Microsoft.EntityFrameworkCore.SqlServer 8.0.11
+- ✅ Microsoft.EntityFrameworkCore.Tools 8.0.11
+- ✅ Microsoft.AspNetCore.DataProtection 8.0.11
+- ✅ Microsoft.Identity.Client 4.65.0
+- ✅ AutoMapper 12.0.1 (warning: vulnerability in 12.0.0-12.0.1 - acceptable for internal use)
+- ✅ RabbitMQ.Client 7.2.1
+- ⚠️ Limilabs.Mail (NOT YET ADDED - required for LimilabsEmailService)
+- ⚠️ GdPicture.NET.14 (NOT YET ADDED - required for GdPicturePdfProcessingService)
+
+**Files**:
+```
+src/DigitalData.MessagingService.Infrastructure/
+├── Persistence/MessagingServiceDbContext.cs
+├── Repositories/Repository.cs
+├── Services/ (6 files)
+├── Messaging/ (3 files)
+├── Queue/InMemoryEmailQueue.cs
+└── DependencyInjection.cs
+```
 
 ---
 
-## ❌ TODO (Phase 4: API Layer - 0%)
+### Phase 4: API Layer ⚠️ IN PROGRESS (30%)
 
-### NuGet Packages
-- ❌ Serilog.AspNetCore
-- ❌ Serilog.Sinks.File
-- ❌ Serilog.Sinks.MSSqlServer
-- ❌ Scalar.AspNetCore
+**Controllers** (3 total):
+- ✅ `EmailProfilesController` - CRUD operations for email profiles
+  - GET /api/emailprofiles - Get all profiles (synchronous via MediatR)
+  - GET /api/emailprofiles/{id} - Get profile by ID
+  - POST /api/emailprofiles - Create profile (async via RabbitMQ, returns HTTP 202)
+  - PUT /api/emailprofiles/{id} - Update profile (async via RabbitMQ, returns HTTP 202)
+  - DELETE /api/emailprofiles/{id} - Delete profile (async via RabbitMQ, returns HTTP 202)
 
-### Controllers
-- ❌ `EmailProfilesController.cs`
-- ❌ `EmailAccountsController.cs`
-- ❌ `EmailHistoryController.cs`
-- ❌ `DashboardController.cs`
+- ✅ `EmailAccountsController` - CRUD operations for email accounts
+  - GET /api/emailaccounts - Get all accounts
+  - GET /api/emailaccounts/{id} - Get account by ID
+  - POST /api/emailaccounts - Create account (async via RabbitMQ)
 
-### Background Workers
-- ❌ `EmailPollingWorker.cs` - Monitors email accounts
-- ❌ `EmailSenderWorker.cs` - Sends queued emails
+- ✅ `EmailHistoryController` - Query email history
+  - GET /api/emailhistory - Get email history with filters
 
-### Middleware
-- ❌ `ExceptionHandlingMiddleware.cs`
+**Workers** (Background Services):
+- ❌ `EmailPollingWorker` - Polls email accounts for new messages (NOT STARTED)
+- ❌ `EmailSenderWorker` - Sends outgoing emails from queue (NOT STARTED)
 
-### Configuration
-- ❌ Update `Program.cs` - Serilog, Scalar, DI, Windows Service support
-- ❌ Update `appsettings.json` - Complete configuration
+**Configuration**:
+- ✅ `appsettings.json` - Application configuration
+- ✅ `appsettings.Secrets.json` - External secrets file (ignored by Git)
+- ✅ RabbitMQ configuration section
+- ❌ Serilog configuration (NOT CONFIGURED)
+- ❌ Worker configuration (NOT CONFIGURED)
+
+**Middleware**:
+- ❌ Exception Handling Middleware (NOT IMPLEMENTED)
+- ❌ Request Logging Middleware (NOT IMPLEMENTED)
+
+**Documentation**:
+- ❌ Scalar OpenAPI documentation (NOT CONFIGURED)
+
+**TODO**:
+- [ ] Create `EmailPollingWorker` - Background service to poll email accounts
+- [ ] Create `EmailSenderWorker` - Background service to send outgoing emails
+- [ ] Configure Serilog for structured logging
+- [ ] Configure Scalar for OpenAPI documentation
+- [ ] Add exception handling middleware
+- [ ] Add request logging middleware
+- [ ] Add worker configuration to `appsettings.json`
+- [ ] Add IIS and Windows Service hosting support
+
+**Files**:
+```
+src/DigitalData.MessagingService.API/
+├── Controllers/ (3 files)
+├── appsettings.json
+├── appsettings.Secrets.json
+└── Program.cs
+```
 
 ---
 
-## ❌ TODO (Phase 5: Testing - 0%)
+### Phase 5: Testing ❌ NOT STARTED (0%)
 
-### NuGet Packages
-- ❌ FakeItEasy
-- ❌ Bogus
-- ❌ FluentAssertions
-- ❌ Microsoft.AspNetCore.Mvc.Testing
-- ❌ Testcontainers.MsSql
+**TODO**:
+- [ ] Unit tests for Domain entities (MessageIdGenerator, Value Objects)
+- [ ] Unit tests for Application handlers (using FakeItEasy for mocks)
+- [ ] Integration tests for Repository (using Testcontainers for SQL Server)
+- [ ] Integration tests for EmailService (using test email account)
+- [ ] API tests (using WebApplicationFactory)
+- [ ] Generate fake test data (using Bogus library)
 
-### Unit Tests
-- ❌ Domain entity tests
-- ❌ Value object tests
-- ❌ MessageIdGenerator tests
-- ❌ Command handler tests
-- ❌ Query handler tests
-
-### Integration Tests
-- ❌ Repository tests (with Testcontainers)
-- ❌ API tests (with WebApplicationFactory)
+**Test Structure**:
+```
+tests/DigitalData.MessagingService.Tests/
+├── Domain/
+│   ├── Services/MessageIdGeneratorTests.cs
+│   ├── ValueObjects/EmailAddressTests.cs
+│   └── ValueObjects/MessageIdTests.cs
+├── Application/
+│   ├── EmailProfiles/CreateEmailProfileCommandHandlerTests.cs
+│   ├── EmailProfiles/GetEmailProfilesQueryHandlerTests.cs
+│   └── EmailProcessing/ProcessEmailCommandHandlerTests.cs
+├── Infrastructure/
+│   ├── Repositories/RepositoryTests.cs
+│   ├── Services/LimilabsEmailServiceTests.cs
+│   └── Services/GdPicturePdfProcessingServiceTests.cs
+└── API/
+    ├── Controllers/EmailProfilesControllerTests.cs
+    └── Workers/EmailPollingWorkerTests.cs
+```
 
 ---
 
-## ❌ TODO (Phase 6: Documentation - 0%)
+## External Dependencies Status
 
-- ❌ `README.md` - Comprehensive documentation in German
-  - Application overview
-  - API endpoints
-  - Workers documentation
-  - Database tables
-  - Configuration guide
-  - Deployment guide (IIS + Windows Service)
+### 1. Limilabs.Mail ⚠️ REQUIRED
+**Status**: Not added  
+**Action**: `dotnet add package Limilabs.Mail`  
+**Impact**: Email operations (IMAP/SMTP/OAuth2) will not work  
+**Files Affected**: `LimilabsEmailService.cs`
+
+### 2. GdPicture.NET 14 ⚠️ REQUIRED
+**Status**: Not added  
+**Action**: Add GdPicture.NET.14 NuGet package + license key  
+**Impact**: PDF processing and embedded file extraction will not work  
+**Files Affected**: `GdPicturePdfProcessingService.cs`  
+**Alternative**: Use DevExpress.Pdf (already licensed)
+
+### 3. windream COM Interop ⚠️ REQUIRED
+**Status**: DLLs not referenced  
+**Action**: Add COM references for WINDREAMLib, WMOBRWSLib  
+**Impact**: windream DMS archiving will not work  
+**Files Affected**: `WindreamDmsService.cs`  
+**Legacy Path**: `M:\Bibliotheken\3rdParty\windream\Interop.WINDREAMLib.dll`
+
+### 4. RabbitMQ Server ✅ AVAILABLE
+**Status**: Running at `172.24.12.56:5672`  
+**Management UI**: `http://172.24.12.56:15672`  
+**Action**: None - already configured  
+**Files Affected**: `RabbitMqCommandPublisher.cs`, `RabbitMqCommandConsumer.cs`
+
+### 5. SQL Server Database ✅ AVAILABLE
+**Status**: Legacy database exists  
+**Action**: Update connection string in `appsettings.Secrets.json`  
+**Files Affected**: `MessagingServiceDbContext.cs`
 
 ---
 
 ## Build Status
 
-✅ **Solution builds successfully** (as of 2026-07-07)
+**Last Build**: 2026-07-20  
+**Result**: ✅ Success  
+**Warnings**: 1  
+**Errors**: 0
 
-```
-Build succeeded.
-    0 Warning(s)
-    0 Error(s)
+**Warnings**:
+- `CS9113`: Parameter 'dmsService' is unread in `ProcessEmailCommandHandler`
+  - **Reason**: Service implementation pending windream COM Interop integration
+  - **Action**: Will be used when windream integration is complete
+
+**Build Command**:
+```bash
+dotnet build src/DigitalData.MessagingService.Infrastructure/DigitalData.MessagingService.Infrastructure.csproj
 ```
 
 ---
 
-## Key Files for Reference
+## Next Steps (Priority Order)
 
-- ✅ `agents.md` - Important notes for future development
-- ✅ `IMPLEMENTATION_GUIDE.md` - Step-by-step implementation guide
-- ✅ `STATUS.md` - This file (current status)
-- ❌ `MIGRATION_PLAN.md` - Full migration plan (not created yet)
+### 1. Add External Dependencies (HIGH PRIORITY)
+- [ ] Add Limilabs.Mail NuGet package
+- [ ] Add GdPicture.NET 14 (or DevExpress.Pdf) NuGet package
+- [ ] Add windream COM Interop DLL references
+- [ ] Uncomment service implementations once dependencies are available
+
+### 2. Complete API Layer (HIGH PRIORITY)
+- [ ] Create `EmailPollingWorker` background service
+- [ ] Create `EmailSenderWorker` background service
+- [ ] Configure Serilog for structured logging
+- [ ] Configure Scalar for OpenAPI documentation
+- [ ] Add exception handling middleware
+- [ ] Test API endpoints with Postman/Swagger
+
+### 3. Integration Testing (MEDIUM PRIORITY)
+- [ ] Set up test SQL Server database (or use Testcontainers)
+- [ ] Write repository integration tests
+- [ ] Write email service integration tests (with test account)
+- [ ] Write API integration tests
+
+### 4. Unit Testing (MEDIUM PRIORITY)
+- [ ] Write Domain entity tests
+- [ ] Write Application handler tests (with FakeItEasy mocks)
+- [ ] Write validation tests
+
+### 5. Deployment Preparation (LOW PRIORITY)
+- [ ] Configure IIS hosting
+- [ ] Configure Windows Service hosting
+- [ ] Set up production appsettings
+- [ ] Configure Azure Key Vault (if needed)
+- [ ] Create deployment scripts
 
 ---
 
-## Next Agent Tasks
+## Known Issues and Limitations
 
-**Priority 1**: Complete Application Layer
-1. Create all repository interfaces
-2. Create all service interfaces
-3. Create MediatR commands and handlers
-4. Create MediatR queries and handlers
-5. Create FluentValidation validators
-6. Create AutoMapper profile
-7. Create DependencyInjection.cs
+### 1. AutoMapper Vulnerability Warning
+**Issue**: NuGet package `AutoMapper 12.0.1` has a known vulnerability  
+**Severity**: Moderate (only affects 12.0.0-12.0.1)  
+**Impact**: Internal application - acceptable risk  
+**Resolution**: Upgrade to AutoMapper 13.0+ when stable
 
-**Priority 2**: Complete Infrastructure Layer
-1. Add NuGet packages
-2. Create EmailProfilerDbContext
-3. Create all repositories
-4. Create all external services
-5. Create DependencyInjection.cs
-6. Create initial EF Core migration
+### 2. RabbitMQ Email Queue Not Implemented
+**Issue**: Using `InMemoryEmailQueue` instead of `RabbitMqEmailQueue`  
+**Impact**: Outgoing emails lost on application restart  
+**Resolution**: Implement `RabbitMqEmailQueue` before production deployment
 
-**Priority 3**: Complete API Layer
-1. Add NuGet packages
-2. Update Program.cs
-3. Create all controllers
-4. Create background workers
-5. Update appsettings.json
+### 3. No Database Migrations
+**Issue**: EF Core migrations disabled (legacy database must not be modified)  
+**Impact**: Cannot use `dotnet ef database update`  
+**Resolution**: All schema changes must be done manually in legacy system
 
-**Priority 4**: Testing
-1. Add test NuGet packages
-2. Create unit tests
-3. Create integration tests
+### 4. DateTime.Now vs DateTime.UtcNow
+**Issue**: Must use `DateTime.Now` (local server time) throughout application  
+**Impact**: Non-standard practice (industry standard is UTC)  
+**Reason**: Legacy database stores local time, not UTC  
+**Resolution**: Document clearly and enforce in code reviews
 
-**Priority 5**: Documentation
-1. Create README.md (German)
+### 5. windream COM Interop Windows-Only
+**Issue**: windream DMS integration uses COM Interop (Windows-only)  
+**Impact**: Application cannot be deployed on Linux/Docker  
+**Resolution**: windream must provide REST API, or accept Windows-only deployment
 
 ---
 
-**Total Progress**: ~15% complete
-- Phase 1 (Domain): 100% ✅
-- Phase 2 (Application): 5% 🚧
-- Phase 3 (Infrastructure): 0% ❌
-- Phase 4 (API): 0% ❌
-- Phase 5 (Testing): 0% ❌
-- Phase 6 (Documentation): 0% ❌
+## Documentation
+
+### Files Created
+- ✅ `AGENTS.md` - Agent notes, decisions, and future enhancements
+- ✅ `STATUS.md` - This file - implementation status report
+- ✅ `README.md` - Project overview and getting started guide (German)
+
+### Code Documentation
+- ✅ XML comments on all public classes, methods, and properties
+- ✅ TODO comments in service implementations for external dependencies
+- ✅ Example usage in command/query handlers
+
+---
+
+## Team Handoff Notes
+
+### For Developers Continuing This Project
+
+**What You Can Do Right Now**:
+1. Build the solution: `dotnet build`
+2. Review the Domain layer: `src/DigitalData.MessagingService.Domain/`
+3. Review the Application layer: `src/DigitalData.MessagingService.Application/`
+4. Review the Infrastructure layer: `src/DigitalData.MessagingService.Infrastructure/`
+5. Review the API layer: `src/DigitalData.MessagingService.API/`
+
+**What You Need to Complete**:
+1. Add Limilabs.Mail NuGet package: `dotnet add package Limilabs.Mail`
+2. Add GdPicture.NET 14 or DevExpress.Pdf NuGet package
+3. Add windream COM Interop DLL references (from legacy project)
+4. Uncomment service implementations in:
+   - `LimilabsEmailService.cs`
+   - `GdPicturePdfProcessingService.cs`
+   - `WindreamDmsService.cs`
+5. Create background workers:
+   - `EmailPollingWorker.cs`
+   - `EmailSenderWorker.cs`
+6. Write tests
+
+**Important Files to Read**:
+- `AGENTS.md` - Critical decisions and constraints
+- `legacy/PROJECT_ANALYSIS.md` - Legacy system analysis
+- This file - Current status and next steps
+
+**Questions? Issues?**
+- Check `AGENTS.md` for design decisions
+- Check legacy code in `legacy/` folder for reference implementations
+- All database operations use generic repository pattern (see `Repository.cs`)
+- All external service interfaces documented in `Application/Common/Interfaces/`
+
+---
+
+**End of Status Report**

agents.md

@@ -1,424 +0,0 @@
-# EmailProfiler - Agent Notes and Future Enhancements
-
-## Purpose
-This document contains important notes, decisions, and future enhancement plans for the EmailProfiler application. This is intended for AI agents and developers who will continue development.
-
----
-
-## Important Notes
-
-### 1. Database Schema - DO NOT MODIFY
-**CRITICAL**: The database schema must NEVER be modified. All Entity Framework entities must map to existing legacy tables using `[Table]` and `[Column]` attributes.
-
-**Naming Convention**:
-- Database: `SNAKE_CASE` with prefixes (TBEMLP_, TBDD_)
-- C# Entities: `PascalCase` without prefixes
-- Use `[Table("TBDD_FOO")]` and `[Column("COLUMN_NAME")]` attributes
-
-**Example**:
-```csharp
-[Table("TBDD_EMAIL_ACCOUNT")]
-public class EmailAccount
-{
-    [Column("EMAIL_ACCOUNT_ID")]
-    public int Id { get; set; }
-    
-    [Column("ACCOUNT_NAME")]
-    public string AccountName { get; set; }
-}
-```
-
-### 2. Message ID Hash Algorithm
-The `MessageIdGenerator` in `Domain.Services` must use **exactly the same algorithm** as the legacy system to ensure duplicate detection works correctly.
-
-**Algorithm**: SHA256 hash of `{originalMessageId}|{sender}|{date:yyyyMMddHHmmss}|{subject}`
-
-### 3. DateTime Usage - ALWAYS Use Local Time
-**CRITICAL**: Always use `DateTime.Now` instead of `DateTime.UtcNow` throughout the entire application.
-
-**Reason**: The legacy system uses local server time, and the database stores all timestamps as local time. Using UTC would break compatibility and cause incorrect time comparisons.
-
-**Examples**:
-```csharp
-// ✅ CORRECT
-profile.CreatedDate = DateTime.Now;
-var lastPoll = DateTime.Now.AddMinutes(-profile.PollIntervalMinutes);
-
-// ❌ WRONG - DO NOT USE
-profile.CreatedDate = DateTime.UtcNow;  // NEVER USE UTC
-var lastPoll = DateTime.UtcNow.AddMinutes(-profile.PollIntervalMinutes);  // NEVER USE UTC
-```
-
-**Important**: This applies to:
-- All entity audit fields (CreatedDate, ModifiedDate, LastPollDate, etc.)
-- All date comparisons in business logic
-- All timestamps in logs and error messages
-- All date parameters in queries
-
-### 4. No Commits Without Permission
-**NEVER** commit changes to git automatically. Always wait for explicit user instruction to commit.
-
----
-
-## Future Enhancements
-
-### HIGH PRIORITY: RabbitMQ Queue Implementation
-
-**Current State**: 
-- Email queue is implemented using in-memory `Channel<T>` in `InMemoryEmailQueue.cs`
-- Location: `src/DigitalData.EmailProfiler.Infrastructure/Queue/InMemoryEmailQueue.cs`
-
-**Future Enhancement**:
-Replace the in-memory queue with **RabbitMQ** for production resilience and scalability.
-
-**Implementation Steps**:
-
-1. **Add NuGet Package**:
-   ```bash
-   dotnet add package RabbitMQ.Client
-   ```
-
-2. **Create RabbitMqEmailQueue.cs**:
-   ```csharp
-   // src/DigitalData.EmailProfiler.Infrastructure/Queue/RabbitMqEmailQueue.cs
-   public class RabbitMqEmailQueue : IEmailQueue
-   {
-       private readonly IConnection _connection;
-       private readonly IModel _channel;
-       private const string QueueName = "email-outbox";
-       
-       public RabbitMqEmailQueue(IOptions<RabbitMqConfiguration> config)
-       {
-           var factory = new ConnectionFactory
-           {
-               HostName = config.Value.HostName,
-               Port = config.Value.Port,
-               UserName = config.Value.UserName,
-               Password = config.Value.Password
-           };
-           
-           _connection = factory.CreateConnection();
-           _channel = _connection.CreateModel();
-           
-           _channel.QueueDeclare(
-               queue: QueueName,
-               durable: true,
-               exclusive: false,
-               autoDelete: false,
-               arguments: null);
-       }
-       
-       public async Task EnqueueAsync(OutgoingEmail email, CancellationToken cancellationToken)
-       {
-           var json = JsonSerializer.Serialize(email);
-           var body = Encoding.UTF8.GetBytes(json);
-           
-           var properties = _channel.CreateBasicProperties();
-           properties.Persistent = true;
-           
-           _channel.BasicPublish(
-               exchange: "",
-               routingKey: QueueName,
-               basicProperties: properties,
-               body: body);
-           
-           await Task.CompletedTask;
-       }
-       
-       public async Task<OutgoingEmail?> DequeueAsync(CancellationToken cancellationToken)
-       {
-           var result = _channel.BasicGet(QueueName, autoAck: false);
-           
-           if (result == null)
-               return null;
-           
-           var json = Encoding.UTF8.GetString(result.Body.ToArray());
-           var email = JsonSerializer.Deserialize<OutgoingEmail>(json);
-           
-           _channel.BasicAck(result.DeliveryTag, false);
-           
-           return await Task.FromResult(email);
-       }
-   }
-   ```
-
-3. **Configuration** (appsettings.json):
-   ```json
-   {
-     "RabbitMq": {
-       "HostName": "localhost",
-       "Port": 5672,
-       "UserName": "guest",
-       "Password": "guest"
-     }
-   }
-   ```
-
-4. **Dependency Injection** (Program.cs):
-   ```csharp
-   // Replace InMemoryEmailQueue with RabbitMqEmailQueue
-   // builder.Services.AddSingleton<IEmailQueue, InMemoryEmailQueue>();
-   builder.Services.AddSingleton<IEmailQueue, RabbitMqEmailQueue>();
-   ```
-
-**Benefits**:
-- Message persistence (survives application restarts)
-- Scalability (multiple worker instances can consume from queue)
-- Reliability (automatic retries, dead letter queues)
-- Monitoring (RabbitMQ management UI)
-
-**Migration Path**:
-1. Deploy RabbitMQ server (Docker recommended)
-2. Test RabbitMqEmailQueue in staging environment
-3. Switch DI registration from InMemoryEmailQueue to RabbitMqEmailQueue
-4. Monitor queue depth and worker performance
-
----
-
-## Pending Implementation Tasks
-
-### Phase 2: Application Layer (IN PROGRESS)
-**Status**: Partially complete - DTOs created, Commands/Queries needed
-
-**TODO**:
-- [ ] Create MediatR Commands (CreateEmailProfileCommand, ProcessEmailCommand, etc.)
-- [ ] Create MediatR Queries (GetEmailProfilesQuery, GetEmailHistoryQuery, etc.)
-- [ ] Create Command/Query Handlers
-- [ ] Create FluentValidation Validators
-- [ ] Create AutoMapper Profiles
-- [ ] Create Application Interfaces (IEmailService, IPdfProcessingService, IDmsService, etc.)
-
-**Example Command**:
-```csharp
-// src/DigitalData.EmailProfiler.Application/EmailProfiles/Commands/CreateEmailProfileCommand.cs
-public record CreateEmailProfileCommand(string ProfileName, int EmailAccountId) : IRequest<int>;
-
-public class CreateEmailProfileCommandHandler : IRequestHandler<CreateEmailProfileCommand, int>
-{
-    private readonly IEmailProfileRepository _repository;
-    
-    public async Task<int> Handle(CreateEmailProfileCommand request, CancellationToken cancellationToken)
-    {
-        var profile = new EmailProfile
-        {
-            ProfileName = request.ProfileName,
-            EmailAccountId = request.EmailAccountId,
-            IsActive = true
-        };
-        
-        await _repository.AddAsync(profile, cancellationToken);
-        return profile.Id;
-    }
-}
-```
-
-### Phase 3: Infrastructure Layer
-**Status**: Not started
-
-**TODO**:
-- [ ] Create EmailProfilerDbContext with DbSet<T> for all entities
-- [ ] Create Entity Configurations (Fluent API) for all entities
-- [ ] Create Repositories implementing Application interfaces
-- [ ] Create MailKitEmailService (IMAP/SMTP with OAuth2)
-- [ ] Create PdfSharpProcessingService
-- [ ] Create WindreamDmsService (COM Interop)
-- [ ] Create EncryptionService (Data Protection API)
-- [ ] Create initial EF Core migration
-
-**DbContext Example**:
-```csharp
-public class EmailProfilerDbContext : DbContext
-{
-    public DbSet<EmailAccount> EmailAccounts { get; set; }
-    public DbSet<EmailProfile> EmailProfiles { get; set; }
-    // ... other DbSets
-    
-    protected override void OnModelCreating(ModelBuilder modelBuilder)
-    {
-        modelBuilder.ApplyConfigurationsFromAssembly(Assembly.GetExecutingAssembly());
-        
-        // Important: Check for triggers
-        modelBuilder.Entity<EmailHistory>().ToTable(tb => tb.HasTrigger("TR_TBEMLP_HISTORY_AUDIT"));
-    }
-}
-```
-
-### Phase 4: API Layer
-**Status**: Minimal structure exists
-
-**TODO**:
-- [ ] Create Controllers (ProfilesController, EmailAccountsController, HistoryController)
-- [ ] Create Background Workers (EmailPollingWorker, EmailSenderWorker)
-- [ ] Configure Serilog
-- [ ] Configure Scalar (OpenAPI documentation)
-- [ ] Add Exception Handling Middleware
-- [ ] Configure DI for all layers
-- [ ] Support both IIS and Windows Service hosting
-
-**Worker Configuration** (appsettings.json):
-```json
-{
-  "Workers": {
-    "EmailPolling": {
-      "Enabled": true,
-      "IntervalSeconds": 60
-    },
-    "EmailSender": {
-      "Enabled": true,
-      "IntervalSeconds": 5
-    }
-  },
-  "Hosting": {
-    "Mode": "IIS"  // or "WindowsService"
-  }
-}
-```
-
-### Phase 5: Testing
-**Status**: Not started
-
-**TODO**:
-- [ ] Unit tests for Domain entities
-- [ ] Unit tests for Application handlers (using FakeItEasy)
-- [ ] Integration tests for Repositories (using Testcontainers)
-- [ ] API tests (using WebApplicationFactory)
-- [ ] Generate fake test data (using Bogus)
-
-**Test Example**:
-```csharp
-public class MessageIdGeneratorTests
-{
-    [Fact]
-    public void Generate_ShouldProduceSameHashAsLegacy()
-    {
-        // Arrange
-        var generator = new MessageIdGenerator();
-        var original = "msg-123";
-        var sender = "test@example.com";
-        var date = new DateTime(2026, 1, 1, 12, 0, 0);
-        var subject = "Test Subject";
-        
-        // Act
-        var messageId = generator.Generate(original, sender, date, subject);
-        
-        // Assert
-        messageId.Hash.Should().NotBeNullOrEmpty();
-        // TODO: Verify against known legacy hash
-    }
-}
-```
-
----
-
-## Architecture Decisions
-
-### Clean Architecture Layers
-1. **Domain**: Core business logic, no dependencies
-2. **Application**: Use cases, depends on Domain
-3. **Infrastructure**: External concerns, depends on Domain + Application
-4. **API**: Entry point, depends on all
-
-### CQRS Pattern with MediatR
-- **Commands**: Modify state (Create, Update, Delete)
-- **Queries**: Read data (Get, List)
-- Separate models for read and write operations
-
-### Repository Pattern
-- Interface in Application layer
-- Implementation in Infrastructure layer
-- One repository per Aggregate Root
-
----
-
-## Known Issues and Limitations
-
-### 1. PdfSharp Embedded File Extraction
-PdfSharp has limited support for embedded file extraction from PDFs. If advanced PDF processing is needed, consider:
-- **iText7** (AGPL or commercial license)
-- **Aspose.PDF** (commercial license)
-- Custom PDF parsing using PDF specification
-
-### 2. windream COM Interop
-The windream DMS integration uses COM Interop which is Windows-only. The application cannot be fully cross-platform unless windream provides a REST API alternative.
-
-### 3. OAuth2 Token Refresh
-Current implementation acquires new tokens on each request. Consider implementing token caching:
-- Use `Microsoft.Identity.Web` for automatic token management
-- Cache tokens in memory or distributed cache (Redis)
-
----
-
-## Development Guidelines
-
-### 1. Code Style
-- All code and comments: **English**
-- README.md and user documentation: **German**
-- Follow C# naming conventions (PascalCase, camelCase)
-- Use nullable reference types (`#nullable enable`)
-
-### 2. Logging
-Use Serilog with structured logging:
-```csharp
-_logger.LogInformation("Processing email {MessageId} from profile {ProfileId}", messageId, profileId);
-```
-
-### 3. Configuration
-- Development: `appsettings.Development.json` + User Secrets
-- Production: `appsettings.json` + Environment Variables + Azure Key Vault
-
-### 4. Error Handling
-- Domain: Throw `DomainException` for business rule violations
-- Application: Use `FluentValidation` for input validation
-- API: Use exception handling middleware to return proper HTTP status codes
-
----
-
-## Deployment Scenarios
-
-### IIS Hosting (Default)
-```json
-{
-  "Hosting": {
-    "Mode": "IIS"
-  }
-}
-```
-
-### Windows Service Hosting
-```json
-{
-  "Hosting": {
-    "Mode": "WindowsService"
-  }
-}
-```
-
-In `Program.cs`:
-```csharp
-var builder = WebApplication.CreateBuilder(args);
-
-if (builder.Configuration["Hosting:Mode"] == "WindowsService")
-{
-    builder.Host.UseWindowsService();
-}
-```
-
-Install as Windows Service:
-```bash
-sc create EmailProfiler binPath="C:\Path\To\DigitalData.EmailProfiler.API.exe"
-```
-
----
-
-## Contact and Support
-
-For questions about this implementation, consult:
-- Legacy system analysis: `legacy/PROJECT_ANALYSIS.md`
-- Migration plan: `MIGRATION_PLAN.md` (if created)
-- This document: `agents.md`
-
----
-
-**Last Updated**: 2026-07-07
-**Version**: 1.0
-**Status**: Phase 1 Complete (Domain Layer), Phase 2-8 Pending

src/DigitalData.EmailProfiler.API/DigitalData.EmailProfiler.API.csproj

@@ -1,25 +0,0 @@
-<Project Sdk="Microsoft.NET.Sdk.Web">
-
-  <PropertyGroup>
-    <TargetFramework>net8.0</TargetFramework>
-    <Nullable>enable</Nullable>
-    <ImplicitUsings>enable</ImplicitUsings>
-	<UserSecretsId>dotnet-DigitalData.EmailProfiler.Service-e7ef6a9a-436f-48a1-b4f6-ec9381c8cb47</UserSecretsId>
-  </PropertyGroup>
-
-  <ItemGroup>
-    <PackageReference Include="Swashbuckle.AspNetCore" Version="6.6.2" />
-	<PackageReference Include="Microsoft.Extensions.Hosting" Version="8.0.1" />
-  </ItemGroup>
-
-  <ItemGroup>
-    <Folder Include="Properties\" />
-  </ItemGroup>
-
-  <ItemGroup>
-    <ProjectReference Include="..\DigitalData.EmailProfiler.Application\DigitalData.EmailProfiler.Application.csproj" />
-    <ProjectReference Include="..\DigitalData.EmailProfiler.Domain\DigitalData.EmailProfiler.Domain.csproj" />
-    <ProjectReference Include="..\DigitalData.EmailProfiler.Infrastructure\DigitalData.EmailProfiler.Infrastructure.csproj" />
-  </ItemGroup>
-
-</Project>

src/DigitalData.EmailProfiler.API/Program.cs

@@ -1,26 +0,0 @@
-using DigitalData.EmailProfiler.API;
-
-var builder = WebApplication.CreateBuilder(args);
-builder.Services.AddHostedService<Worker>();
-
-builder.Services.AddControllers();
-
-builder.Services.AddEndpointsApiExplorer();
-builder.Services.AddSwaggerGen();
-
-var app = builder.Build();
-
-// Configure the HTTP request pipeline.
-if (app.Environment.IsDevelopment())
-{
-    app.UseSwagger();
-    app.UseSwaggerUI();
-}
-
-app.UseHttpsRedirection();
-
-app.UseAuthorization();
-
-app.MapControllers();
-
-app.Run();

src/DigitalData.EmailProfiler.API/Worker.cs

@@ -1,16 +0,0 @@
-namespace DigitalData.EmailProfiler.API;
-
-public class Worker(ILogger<Worker> Logger) : BackgroundService
-{
-    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
-    {
-        while (!stoppingToken.IsCancellationRequested)
-        {
-            if (Logger.IsEnabled(LogLevel.Information))
-            {
-                Logger.LogInformation("Worker running at: {time}", DateTimeOffset.Now);
-            }
-            await Task.Delay(1000, stoppingToken);
-        }
-    }
-}

src/DigitalData.EmailProfiler.API/appsettings.Development.json

@@ -1,8 +0,0 @@
-{
-  "Logging": {
-    "LogLevel": {
-      "Default": "Information",
-      "Microsoft.AspNetCore": "Warning"
-    }
-  }
-}

src/DigitalData.EmailProfiler.API/appsettings.json

@@ -1,9 +0,0 @@
-{
-  "Logging": {
-    "LogLevel": {
-      "Default": "Information",
-      "Microsoft.AspNetCore": "Warning"
-    }
-  },
-  "AllowedHosts": "*"
-}

src/DigitalData.EmailProfiler.Application/Common/Dtos/CommonDtos.cs

@@ -1,54 +0,0 @@
-namespace DigitalData.EmailProfiler.Application.Common.Dtos;
-
-public class EmailProfileDto
-{
-    public int Id { get; set; }
-    public string ProfileName { get; set; } = string.Empty;
-    public int EmailAccountId { get; set; }
-    public string? EmailAccountName { get; set; }
-    public int? ProcessId { get; set; }
-    public string? ProcessName { get; set; }
-    public int PollIntervalMinutes { get; set; }
-    public DateTime? LastPollTime { get; set; }
-    public bool IsActive { get; set; }
-    public string? Comment { get; set; }
-}
-
-public class EmailAccountDto
-{
-    public int Id { get; set; }
-    public string AccountName { get; set; } = string.Empty;
-    public string ImapServer { get; set; } = string.Empty;
-    public int ImapPort { get; set; }
-    public string SmtpServer { get; set; } = string.Empty;
-    public int SmtpPort { get; set; }
-    public string Username { get; set; } = string.Empty;
-    public bool UseOAuth2 { get; set; }
-    public bool IsActive { get; set; }
-}
-
-public class EmailHistoryDto
-{
-    public int Id { get; set; }
-    public int? ProfileId { get; set; }
-    public string? ProfileName { get; set; }
-    public string? SenderAddress { get; set; }
-    public string? Subject { get; set; }
-    public DateTime? EmailDate { get; set; }
-    public DateTime? ProcessedDate { get; set; }
-    public string? Status { get; set; }
-    public int? ErrorCodeValue { get; set; }
-    public string? ErrorMessage { get; set; }
-    public List<EmailAttachmentDto> Attachments { get; set; } = new();
-}
-
-public class EmailAttachmentDto
-{
-    public int Id { get; set; }
-    public string OriginalFileName { get; set; } = string.Empty;
-    public string FilePath { get; set; } = string.Empty;
-    public long FileSize { get; set; }
-    public bool IsEmbeddedFile { get; set; }
-    public string? Status { get; set; }
-    public string? ValidationErrorMessage { get; set; }
-}

src/DigitalData.EmailProfiler.Application/DigitalData.EmailProfiler.Application.csproj

@@ -1,20 +0,0 @@
-<Project Sdk="Microsoft.NET.Sdk">
-
-  <PropertyGroup>
-    <TargetFramework>net8.0</TargetFramework>
-    <ImplicitUsings>enable</ImplicitUsings>
-    <Nullable>enable</Nullable>
-  </PropertyGroup>
-
-  <ItemGroup>
-    <ProjectReference Include="..\DigitalData.EmailProfiler.Domain\DigitalData.EmailProfiler.Domain.csproj" />
-  </ItemGroup>
-
-  <ItemGroup>
-    <PackageReference Include="AutoMapper.Extensions.Microsoft.DependencyInjection" Version="12.0.1" />
-    <PackageReference Include="FluentValidation.DependencyInjectionExtensions" Version="12.1.1" />
-    <PackageReference Include="MediatR" Version="14.2.0" />
-    <PackageReference Include="MimeKit" Version="4.17.0" />
-  </ItemGroup>
-
-</Project>

src/DigitalData.EmailProfiler.Application/Features/EmailAccounts/Commands/CreateEmailAccountCommand.cs

@@ -1,24 +0,0 @@
-using MediatR;
-
-namespace DigitalData.EmailProfiler.Application.Features.EmailAccounts.Commands;
-
-/// <summary>
-/// Command to create a new email account.
-/// </summary>
-public record CreateEmailAccountCommand : IRequest<int>
-{
-    public string AccountName { get; init; } = string.Empty;
-    public string Username { get; init; } = string.Empty;
-    public string ImapServer { get; init; } = string.Empty;
-    public int ImapPort { get; init; } = 993;
-    public bool ImapUseSsl { get; init; } = true;
-    public string SmtpServer { get; init; } = string.Empty;
-    public int SmtpPort { get; init; } = 587;
-    public bool SmtpUseSsl { get; init; } = true;
-    public bool UseOAuth2 { get; init; }
-    public string? EncryptedPassword { get; init; } // Already encrypted by client
-    public string? TenantId { get; init; }
-    public string? ClientId { get; init; }
-    public string? EncryptedClientSecret { get; init; } // Already encrypted by client
-    public bool IsActive { get; init; } = true;
-}

src/DigitalData.EmailProfiler.Application/Features/EmailAccounts/Commands/CreateEmailAccountCommandHandler.cs

@@ -1,37 +0,0 @@
-using DigitalData.EmailProfiler.Application.Interfaces.Repositories;
-using DigitalData.EmailProfiler.Domain.Entities;
-using MediatR;
-
-namespace DigitalData.EmailProfiler.Application.Features.EmailAccounts.Commands;
-
-public class CreateEmailAccountCommandHandler(IUnitOfWork unitOfWork) 
-    : IRequestHandler<CreateEmailAccountCommand, int>
-{
-    public async Task<int> Handle(CreateEmailAccountCommand request, CancellationToken cancellationToken)
-    {
-        var account = new EmailAccount
-        {
-            AccountName = request.AccountName,
-            Username = request.Username,
-            ImapServer = request.ImapServer,
-            ImapPort = request.ImapPort,
-            ImapUseSsl = request.ImapUseSsl,
-            SmtpServer = request.SmtpServer,
-            SmtpPort = request.SmtpPort,
-            SmtpUseSsl = request.SmtpUseSsl,
-            UseOAuth2 = request.UseOAuth2,
-            EncryptedPassword = request.EncryptedPassword,
-            TenantId = request.TenantId,
-            ClientId = request.ClientId,
-            EncryptedClientSecret = request.EncryptedClientSecret,
-            IsActive = request.IsActive,
-            AddedWhen = DateTime.Now,
-            AddedWho = "System" // TODO: Get from current user context
-        };
-
-        var createdAccount = await unitOfWork.EmailAccounts.AddAsync(account, cancellationToken);
-        await unitOfWork.SaveChangesAsync(cancellationToken);
-
-        return createdAccount.Id;
-    }
-}

src/DigitalData.EmailProfiler.Application/Features/EmailProcessing/Commands/ProcessEmailCommand.cs

@@ -1,28 +0,0 @@
-using MediatR;
-
-namespace DigitalData.EmailProfiler.Application.Features.EmailProcessing.Commands;
-
-/// <summary>
-/// Command to process a single email from a profile.
-/// This is the core email processing logic.
-/// </summary>
-public record ProcessEmailCommand : IRequest<int>
-{
-    public int ProfileId { get; init; }
-    public string MessageId { get; init; } = string.Empty;
-    public string Sender { get; init; } = string.Empty;
-    public DateTime ReceivedDate { get; init; }
-    public string Subject { get; init; } = string.Empty;
-    public string? BodyText { get; init; }
-    public string? BodyHtml { get; init; }
-    public List<AttachmentData> Attachments { get; init; } = new();
-}
-
-/// <summary>
-/// Attachment data for email processing.
-/// </summary>
-public record AttachmentData(
-    string FileName,
-    byte[] Content,
-    string ContentType,
-    long SizeBytes);

src/DigitalData.EmailProfiler.Application/Features/EmailProcessing/Commands/ProcessEmailCommandHandler.cs

@@ -1,127 +0,0 @@
-using DigitalData.EmailProfiler.Application.Interfaces.Repositories;
-using DigitalData.EmailProfiler.Application.Interfaces.Services;
-using DigitalData.EmailProfiler.Domain.Entities;
-using DigitalData.EmailProfiler.Domain.Enums;
-using DigitalData.EmailProfiler.Domain.Events;
-using DigitalData.EmailProfiler.Domain.Exceptions;
-using DigitalData.EmailProfiler.Domain.Services;
-using MediatR;
-
-namespace DigitalData.EmailProfiler.Application.Features.EmailProcessing.Commands;
-
-public class ProcessEmailCommandHandler(
-    IUnitOfWork unitOfWork,
-    IPublisher publisher,
-    MessageIdGenerator messageIdGenerator,
-    IPdfProcessingService pdfService,
-    IDmsService dmsService)
-    : IRequestHandler<ProcessEmailCommand, int>
-{
-    public async Task<int> Handle(ProcessEmailCommand request, CancellationToken cancellationToken)
-    {
-        // 1. Get profile with related entities
-        var profile = await unitOfWork.EmailProfiles.GetWithRelatedEntitiesAsync(request.ProfileId, cancellationToken)
-            ?? throw new DomainException($"Profile with ID {request.ProfileId} not found");
-
-        // 2. Generate message ID hash for duplicate detection
-        var messageId = messageIdGenerator.Generate(
-            request.MessageId,
-            request.Sender,
-            request.ReceivedDate,
-            request.Subject);
-
-        // 3. Check for duplicates
-        var isDuplicate = await unitOfWork.EmailHistories.IsDuplicateAsync(messageId.Hash, cancellationToken);
-        if (isDuplicate)
-        {
-            throw new ValidationException("Email already processed (duplicate detected)", ErrorCode.DuplicateMessageId);
-        }
-
-        // 4. Create email history record
-        var emailHistory = new EmailHistory
-        {
-            ProfileId = profile.Id,
-            MessageIdHash = messageId.Hash,
-            OriginalMessageId = request.MessageId,
-            SenderAddress = request.Sender,
-            EmailDate = request.ReceivedDate,
-            Subject = request.Subject,
-            EmailBodyText = request.BodyText,
-            EmailBodyHtml = request.BodyHtml,
-            Status = EmailStatus.Processing.ToString(),
-            AddedWhen = DateTime.Now
-        };
-
-        var createdHistory = await unitOfWork.EmailHistories.AddAsync(emailHistory, cancellationToken);
-        await unitOfWork.SaveChangesAsync(cancellationToken);
-
-        try
-        {
-            // 5. Process attachments
-            foreach (var attachmentData in request.Attachments)
-            {
-                var attachment = new EmailAttachment
-                {
-                    EmailHistoryId = createdHistory.Id,
-                    OriginalFileName = attachmentData.FileName,
-                    SavedFileName = attachmentData.FileName, // TODO: Generate unique name
-                    FilePath = string.Empty, // TODO: Save to disk and get path
-                    FileSize = attachmentData.SizeBytes,
-                    Extension = Path.GetExtension(attachmentData.FileName),
-                    Status = AttachmentStatus.Pending.ToString(),
-                    AddedWhen = DateTime.Now
-                };
-
-                // Validate PDF attachments
-                if (attachmentData.ContentType.Contains("pdf", StringComparison.OrdinalIgnoreCase))
-                {
-                    using var stream = new MemoryStream(attachmentData.Content);
-                    var isValidPdf = await pdfService.IsValidPdfAsync(stream, cancellationToken);
-                    
-                    if (isValidPdf)
-                    {
-                        attachment.MarkAsValid();
-                    }
-                    else
-                    {
-                        attachment.MarkAsCorrupt(ErrorCode.PdfStructureInvalid, "Invalid PDF structure");
-                    }
-                }
-
-                createdHistory.Attachments.Add(attachment);
-            }
-
-            // 6. Archive to DMS if configured
-            if (profile.EmailProcess != null && profile.EmailProcess.EnableWindreamImport)
-            {
-                // TODO: Implement DMS archiving with indexing steps
-                // This will be implemented based on ProcessSteps and IndexingSteps
-            }
-
-            // 7. Mark as processed
-            createdHistory.MarkAsProcessed();
-            await unitOfWork.EmailHistories.UpdateAsync(createdHistory, cancellationToken);
-            await unitOfWork.SaveChangesAsync(cancellationToken);
-
-            // 8. Publish domain event
-            await publisher.Publish(
-                new EmailProcessedEvent(
-                    createdHistory.Id,
-                    profile.Id,
-                    messageId.Hash,
-                    EmailStatus.Processed),
-                cancellationToken);
-
-            return createdHistory.Id;
-        }
-        catch (Exception ex)
-        {
-            // Mark as failed
-            createdHistory.MarkAsFailed(ErrorCode.AttachmentExtractionFailed, ex.Message);
-            await unitOfWork.EmailHistories.UpdateAsync(createdHistory, cancellationToken);
-            await unitOfWork.SaveChangesAsync(cancellationToken);
-
-            throw;
-        }
-    }
-}

src/DigitalData.EmailProfiler.Application/Features/EmailProfiles/Commands/CreateEmailProfileCommand.cs

@@ -1,16 +0,0 @@
-using MediatR;
-
-namespace DigitalData.EmailProfiler.Application.Features.EmailProfiles.Commands;
-
-/// <summary>
-/// Command to create a new email profile.
-/// </summary>
-public record CreateEmailProfileCommand : IRequest<int>
-{
-    public string ProfileName { get; init; } = string.Empty;
-    public int EmailAccountId { get; init; }
-    public int? ProcessId { get; init; }
-    public string? ValidationSql { get; init; }
-    public int PollIntervalMinutes { get; init; } = 15;
-    public bool IsActive { get; init; } = true;
-}

src/DigitalData.EmailProfiler.Application/Features/EmailProfiles/Commands/CreateEmailProfileCommandHandler.cs

@@ -1,29 +0,0 @@
-using DigitalData.EmailProfiler.Application.Interfaces.Repositories;
-using DigitalData.EmailProfiler.Domain.Entities;
-using MediatR;
-
-namespace DigitalData.EmailProfiler.Application.Features.EmailProfiles.Commands;
-
-public class CreateEmailProfileCommandHandler(IUnitOfWork unitOfWork) 
-    : IRequestHandler<CreateEmailProfileCommand, int>
-{
-    public async Task<int> Handle(CreateEmailProfileCommand request, CancellationToken cancellationToken)
-    {
-        var profile = new EmailProfile
-        {
-            ProfileName = request.ProfileName,
-            EmailAccountId = request.EmailAccountId,
-            ProcessId = request.ProcessId,
-            ValidationSql = request.ValidationSql,
-            PollIntervalMinutes = request.PollIntervalMinutes,
-            IsActive = request.IsActive,
-            AddedWhen = DateTime.Now,
-            AddedWho = "System" // TODO: Get from current user context
-        };
-
-        var createdProfile = await unitOfWork.EmailProfiles.AddAsync(profile, cancellationToken);
-        await unitOfWork.SaveChangesAsync(cancellationToken);
-
-        return createdProfile.Id;
-    }
-}

src/DigitalData.EmailProfiler.Application/Features/EmailProfiles/Commands/DeleteEmailProfileCommand.cs

@@ -1,8 +0,0 @@
-using MediatR;
-
-namespace DigitalData.EmailProfiler.Application.Features.EmailProfiles.Commands;
-
-/// <summary>
-/// Command to delete an email profile.
-/// </summary>
-public record DeleteEmailProfileCommand(int Id) : IRequest<Unit>;

src/DigitalData.EmailProfiler.Application/Features/EmailProfiles/Commands/DeleteEmailProfileCommandHandler.cs

@@ -1,20 +0,0 @@
-using DigitalData.EmailProfiler.Application.Interfaces.Repositories;
-using DigitalData.EmailProfiler.Domain.Exceptions;
-using MediatR;
-
-namespace DigitalData.EmailProfiler.Application.Features.EmailProfiles.Commands;
-
-public class DeleteEmailProfileCommandHandler(IUnitOfWork unitOfWork) 
-    : IRequestHandler<DeleteEmailProfileCommand, Unit>
-{
-    public async Task<Unit> Handle(DeleteEmailProfileCommand request, CancellationToken cancellationToken)
-    {
-        var profile = await unitOfWork.EmailProfiles.GetByIdAsync(request.Id, cancellationToken)
-            ?? throw new DomainException($"Email profile with ID {request.Id} not found");
-
-        await unitOfWork.EmailProfiles.DeleteAsync(profile, cancellationToken);
-        await unitOfWork.SaveChangesAsync(cancellationToken);
-
-        return Unit.Value;
-    }
-}

src/DigitalData.EmailProfiler.Application/Features/EmailProfiles/Commands/UpdateEmailProfileCommand.cs

@@ -1,15 +0,0 @@
-using MediatR;
-
-namespace DigitalData.EmailProfiler.Application.Features.EmailProfiles.Commands;
-
-/// <summary>
-/// Command to update an existing email profile.
-/// </summary>
-public record UpdateEmailProfileCommand : IRequest<Unit>
-{
-    public int Id { get; init; }
-    public string ProfileName { get; init; } = string.Empty;
-    public string? ValidationSql { get; init; }
-    public int PollIntervalMinutes { get; init; }
-    public bool IsActive { get; init; }
-}

src/DigitalData.EmailProfiler.Application/Features/EmailProfiles/Commands/UpdateEmailProfileCommandHandler.cs

@@ -1,27 +0,0 @@
-using DigitalData.EmailProfiler.Application.Interfaces.Repositories;
-using DigitalData.EmailProfiler.Domain.Exceptions;
-using MediatR;
-
-namespace DigitalData.EmailProfiler.Application.Features.EmailProfiles.Commands;
-
-public class UpdateEmailProfileCommandHandler(IUnitOfWork unitOfWork) 
-    : IRequestHandler<UpdateEmailProfileCommand, Unit>
-{
-    public async Task<Unit> Handle(UpdateEmailProfileCommand request, CancellationToken cancellationToken)
-    {
-        var profile = await unitOfWork.EmailProfiles.GetByIdAsync(request.Id, cancellationToken)
-            ?? throw new DomainException($"Email profile with ID {request.Id} not found");
-
-        profile.ProfileName = request.ProfileName;
-        profile.ValidationSql = request.ValidationSql;
-        profile.PollIntervalMinutes = request.PollIntervalMinutes;
-        profile.IsActive = request.IsActive;
-        profile.ChangedWhen = DateTime.Now;
-        profile.ChangedWho = "System"; // TODO: Get from current user context
-
-        await unitOfWork.EmailProfiles.UpdateAsync(profile, cancellationToken);
-        await unitOfWork.SaveChangesAsync(cancellationToken);
-
-        return Unit.Value;
-    }
-}

src/DigitalData.EmailProfiler.Application/Interfaces/Repositories/IEmailAccountRepository.cs

@@ -1,24 +0,0 @@
-using DigitalData.EmailProfiler.Domain.Entities;
-
-namespace DigitalData.EmailProfiler.Application.Interfaces.Repositories;
-
-/// <summary>
-/// Repository interface for EmailAccount entity.
-/// </summary>
-public interface IEmailAccountRepository : IRepository<EmailAccount>
-{
-    /// <summary>
-    /// Get all active email accounts.
-    /// </summary>
-    Task<IEnumerable<EmailAccount>> GetActiveAccountsAsync(CancellationToken cancellationToken = default);
-
-    /// <summary>
-    /// Get email account by account name.
-    /// </summary>
-    Task<EmailAccount?> GetByAccountNameAsync(string accountName, CancellationToken cancellationToken = default);
-
-    /// <summary>
-    /// Get email account with its profiles.
-    /// </summary>
-    Task<EmailAccount?> GetWithProfilesAsync(int id, CancellationToken cancellationToken = default);
-}

src/DigitalData.EmailProfiler.Application/Interfaces/Repositories/IEmailHistoryRepository.cs

@@ -1,47 +0,0 @@
-using DigitalData.EmailProfiler.Domain.Entities;
-
-namespace DigitalData.EmailProfiler.Application.Interfaces.Repositories;
-
-/// <summary>
-/// Repository interface for EmailHistory entity.
-/// </summary>
-public interface IEmailHistoryRepository : IRepository<EmailHistory>
-{
-    /// <summary>
-    /// Get email history by message ID hash.
-    /// </summary>
-    Task<EmailHistory?> GetByMessageIdHashAsync(string messageIdHash, CancellationToken cancellationToken = default);
-
-    /// <summary>
-    /// Get email history with attachments.
-    /// </summary>
-    Task<EmailHistory?> GetWithAttachmentsAsync(int id, CancellationToken cancellationToken = default);
-
-    /// <summary>
-    /// Get email history by profile ID with pagination.
-    /// </summary>
-    Task<(IEnumerable<EmailHistory> Items, int TotalCount)> GetByProfileIdAsync(
-        int profileId, 
-        int pageNumber = 1, 
-        int pageSize = 50, 
-        CancellationToken cancellationToken = default);
-
-    /// <summary>
-    /// Get failed emails that need retry.
-    /// </summary>
-    Task<IEnumerable<EmailHistory>> GetFailedEmailsAsync(int? profileId = null, CancellationToken cancellationToken = default);
-
-    /// <summary>
-    /// Get emails processed within date range.
-    /// </summary>
-    Task<IEnumerable<EmailHistory>> GetByDateRangeAsync(
-        DateTime startDate, 
-        DateTime endDate, 
-        int? profileId = null, 
-        CancellationToken cancellationToken = default);
-
-    /// <summary>
-    /// Check if email with given message ID hash already exists.
-    /// </summary>
-    Task<bool> IsDuplicateAsync(string messageIdHash, CancellationToken cancellationToken = default);
-}

src/DigitalData.EmailProfiler.Application/Interfaces/Repositories/IEmailOutboxRepository.cs

@@ -1,34 +0,0 @@
-using DigitalData.EmailProfiler.Domain.Entities;
-
-namespace DigitalData.EmailProfiler.Application.Interfaces.Repositories;
-
-/// <summary>
-/// Repository interface for EmailOutbox entity.
-/// </summary>
-public interface IEmailOutboxRepository : IRepository<EmailOutbox>
-{
-    /// <summary>
-    /// Get all pending emails (not yet sent).
-    /// </summary>
-    Task<IEnumerable<EmailOutbox>> GetPendingEmailsAsync(int maxCount = 100, CancellationToken cancellationToken = default);
-
-    /// <summary>
-    /// Get failed emails that need retry (RetryCount < MaxRetryCount).
-    /// </summary>
-    Task<IEnumerable<EmailOutbox>> GetFailedEmailsForRetryAsync(int maxCount = 100, CancellationToken cancellationToken = default);
-
-    /// <summary>
-    /// Mark email as sent.
-    /// </summary>
-    Task MarkAsSentAsync(int id, CancellationToken cancellationToken = default);
-
-    /// <summary>
-    /// Mark email as failed with error details.
-    /// </summary>
-    Task MarkAsFailedAsync(int id, string errorMessage, CancellationToken cancellationToken = default);
-
-    /// <summary>
-    /// Delete old sent emails (cleanup).
-    /// </summary>
-    Task DeleteOldSentEmailsAsync(int daysToKeep, CancellationToken cancellationToken = default);
-}

src/DigitalData.EmailProfiler.Application/Interfaces/Repositories/IEmailProcessRepository.cs

@@ -1,24 +0,0 @@
-using DigitalData.EmailProfiler.Domain.Entities;
-
-namespace DigitalData.EmailProfiler.Application.Interfaces.Repositories;
-
-/// <summary>
-/// Repository interface for EmailProcess entity.
-/// </summary>
-public interface IEmailProcessRepository : IRepository<EmailProcess>
-{
-    /// <summary>
-    /// Get process with all steps (ProcessSteps and IndexingSteps).
-    /// </summary>
-    Task<EmailProcess?> GetWithStepsAsync(int id, CancellationToken cancellationToken = default);
-
-    /// <summary>
-    /// Get process by profile ID.
-    /// </summary>
-    Task<EmailProcess?> GetByProfileIdAsync(int profileId, CancellationToken cancellationToken = default);
-
-    /// <summary>
-    /// Get all processes by type.
-    /// </summary>
-    Task<IEnumerable<EmailProcess>> GetByProcessTypeAsync(string processType, CancellationToken cancellationToken = default);
-}

src/DigitalData.EmailProfiler.Application/Interfaces/Repositories/IEmailProfileRepository.cs

@@ -1,29 +0,0 @@
-using DigitalData.EmailProfiler.Domain.Entities;
-
-namespace DigitalData.EmailProfiler.Application.Interfaces.Repositories;
-
-/// <summary>
-/// Repository interface for EmailProfile entity.
-/// </summary>
-public interface IEmailProfileRepository : IRepository<EmailProfile>
-{
-    /// <summary>
-    /// Get all active profiles.
-    /// </summary>
-    Task<IEnumerable<EmailProfile>> GetActiveProfilesAsync(CancellationToken cancellationToken = default);
-
-    /// <summary>
-    /// Get profiles that should be polled now (based on PollIntervalMinutes).
-    /// </summary>
-    Task<IEnumerable<EmailProfile>> GetProfilesDueForPollingAsync(CancellationToken cancellationToken = default);
-
-    /// <summary>
-    /// Get profile with all related entities (EmailAccount, EmailProcess, ProcessSteps).
-    /// </summary>
-    Task<EmailProfile?> GetWithRelatedEntitiesAsync(int id, CancellationToken cancellationToken = default);
-
-    /// <summary>
-    /// Get profiles by email account ID.
-    /// </summary>
-    Task<IEnumerable<EmailProfile>> GetByEmailAccountIdAsync(int emailAccountId, CancellationToken cancellationToken = default);
-}

src/DigitalData.EmailProfiler.Application/Interfaces/Repositories/IRepository.cs

@@ -1,19 +0,0 @@
-using System.Linq.Expressions;
-
-namespace DigitalData.EmailProfiler.Application.Interfaces.Repositories;
-
-/// <summary>
-/// Base repository interface for common CRUD operations.
-/// </summary>
-/// <typeparam name="T">Entity type</typeparam>
-public interface IRepository<T> where T : class
-{
-    Task<T?> GetByIdAsync(int id, CancellationToken cancellationToken = default);
-    Task<IEnumerable<T>> GetAllAsync(CancellationToken cancellationToken = default);
-    Task<IEnumerable<T>> FindAsync(Expression<Func<T, bool>> predicate, CancellationToken cancellationToken = default);
-    Task<T> AddAsync(T entity, CancellationToken cancellationToken = default);
-    Task UpdateAsync(T entity, CancellationToken cancellationToken = default);
-    Task DeleteAsync(T entity, CancellationToken cancellationToken = default);
-    Task<bool> ExistsAsync(Expression<Func<T, bool>> predicate, CancellationToken cancellationToken = default);
-    Task<int> CountAsync(Expression<Func<T, bool>>? predicate = null, CancellationToken cancellationToken = default);
-}

src/DigitalData.EmailProfiler.Application/Interfaces/Repositories/IUnitOfWork.cs

@@ -1,33 +0,0 @@
-namespace DigitalData.EmailProfiler.Application.Interfaces.Repositories;
-
-/// <summary>
-/// Unit of Work pattern for transaction management.
-/// </summary>
-public interface IUnitOfWork : IDisposable
-{
-    IEmailAccountRepository EmailAccounts { get; }
-    IEmailProfileRepository EmailProfiles { get; }
-    IEmailProcessRepository EmailProcesses { get; }
-    IEmailHistoryRepository EmailHistories { get; }
-    IEmailOutboxRepository EmailOutbox { get; }
-
-    /// <summary>
-    /// Save all changes to the database.
-    /// </summary>
-    Task<int> SaveChangesAsync(CancellationToken cancellationToken = default);
-
-    /// <summary>
-    /// Begin a database transaction.
-    /// </summary>
-    Task BeginTransactionAsync(CancellationToken cancellationToken = default);
-
-    /// <summary>
-    /// Commit the current transaction.
-    /// </summary>
-    Task CommitTransactionAsync(CancellationToken cancellationToken = default);
-
-    /// <summary>
-    /// Rollback the current transaction.
-    /// </summary>
-    Task RollbackTransactionAsync(CancellationToken cancellationToken = default);
-}

src/DigitalData.EmailProfiler.Application/Interfaces/Services/IDmsService.cs

@@ -1,71 +0,0 @@
-namespace DigitalData.EmailProfiler.Application.Interfaces.Services;
-
-/// <summary>
-/// windream DMS integration service interface.
-/// </summary>
-public interface IDmsService
-{
-    /// <summary>
-    /// Connect to windream DMS.
-    /// </summary>
-    Task ConnectAsync(string server, string username, string password, CancellationToken cancellationToken = default);
-
-    /// <summary>
-    /// Archive document to windream DMS with indexing fields.
-    /// </summary>
-    Task<string> ArchiveDocumentAsync(
-        string filePath,
-        string documentType,
-        Dictionary<string, object> indexFields,
-        CancellationToken cancellationToken = default);
-
-    /// <summary>
-    /// Archive document from stream to windream DMS.
-    /// </summary>
-    Task<string> ArchiveDocumentAsync(
-        Stream fileStream,
-        string fileName,
-        string documentType,
-        Dictionary<string, object> indexFields,
-        CancellationToken cancellationToken = default);
-
-    /// <summary>
-    /// Check if document already exists in windream DMS.
-    /// </summary>
-    Task<bool> DocumentExistsAsync(string documentId, CancellationToken cancellationToken = default);
-
-    /// <summary>
-    /// Get document from windream DMS.
-    /// </summary>
-    Task<Stream> GetDocumentAsync(string documentId, CancellationToken cancellationToken = default);
-
-    /// <summary>
-    /// Update document indexing fields.
-    /// </summary>
-    Task UpdateIndexFieldsAsync(
-        string documentId,
-        Dictionary<string, object> indexFields,
-        CancellationToken cancellationToken = default);
-
-    /// <summary>
-    /// Search documents by index fields.
-    /// </summary>
-    Task<IEnumerable<DmsSearchResult>> SearchDocumentsAsync(
-        Dictionary<string, object> searchCriteria,
-        int maxResults = 100,
-        CancellationToken cancellationToken = default);
-
-    /// <summary>
-    /// Disconnect from windream DMS.
-    /// </summary>
-    Task DisconnectAsync(CancellationToken cancellationToken = default);
-}
-
-/// <summary>
-/// Represents a windream DMS search result.
-/// </summary>
-public record DmsSearchResult(
-    string DocumentId,
-    string FileName,
-    DateTime CreatedDate,
-    Dictionary<string, object> IndexFields);

src/DigitalData.EmailProfiler.Application/Interfaces/Services/IEmailQueue.cs

@@ -1,27 +0,0 @@
-using DigitalData.EmailProfiler.Domain.Entities;
-
-namespace DigitalData.EmailProfiler.Application.Interfaces.Services;
-
-/// <summary>
-/// Email queue interface for asynchronous email sending.
-/// Current implementation: In-memory Channel&lt;T&gt;
-/// Future: RabbitMQ (see agents.md)
-/// </summary>
-public interface IEmailQueue
-{
-    /// <summary>
-    /// Enqueue an email for sending.
-    /// </summary>
-    Task EnqueueAsync(EmailOutbox email, CancellationToken cancellationToken = default);
-
-    /// <summary>
-    /// Dequeue an email for sending.
-    /// Returns null if queue is empty.
-    /// </summary>
-    Task<EmailOutbox?> DequeueAsync(CancellationToken cancellationToken = default);
-
-    /// <summary>
-    /// Get current queue depth (number of pending emails).
-    /// </summary>
-    Task<int> GetQueueDepthAsync(CancellationToken cancellationToken = default);
-}

src/DigitalData.EmailProfiler.Application/Interfaces/Services/IEmailService.cs

@@ -1,59 +0,0 @@
-using MimeKit;
-
-namespace DigitalData.EmailProfiler.Application.Interfaces.Services;
-
-/// <summary>
-/// Email service interface for IMAP/SMTP operations with OAuth2 support.
-/// </summary>
-public interface IEmailService
-{
-    /// <summary>
-    /// Connect to IMAP server and authenticate.
-    /// </summary>
-    Task ConnectImapAsync(string server, int port, string username, string password, bool useSsl = true, CancellationToken cancellationToken = default);
-
-    /// <summary>
-    /// Connect to IMAP server using OAuth2.
-    /// </summary>
-    Task ConnectImapOAuth2Async(string server, int port, string username, string accessToken, bool useSsl = true, CancellationToken cancellationToken = default);
-
-    /// <summary>
-    /// Fetch unread emails from inbox.
-    /// </summary>
-    Task<IEnumerable<MimeMessage>> FetchUnreadEmailsAsync(int maxCount = 100, CancellationToken cancellationToken = default);
-
-    /// <summary>
-    /// Mark email as read.
-    /// </summary>
-    Task MarkAsReadAsync(int uid, CancellationToken cancellationToken = default);
-
-    /// <summary>
-    /// Move email to specified folder.
-    /// </summary>
-    Task MoveToFolderAsync(int uid, string folderName, CancellationToken cancellationToken = default);
-
-    /// <summary>
-    /// Delete email.
-    /// </summary>
-    Task DeleteEmailAsync(int uid, CancellationToken cancellationToken = default);
-
-    /// <summary>
-    /// Disconnect from IMAP server.
-    /// </summary>
-    Task DisconnectImapAsync(CancellationToken cancellationToken = default);
-
-    /// <summary>
-    /// Send email via SMTP.
-    /// </summary>
-    Task SendEmailAsync(MimeMessage message, string smtpServer, int smtpPort, string username, string password, bool useSsl = true, CancellationToken cancellationToken = default);
-
-    /// <summary>
-    /// Send email via SMTP using OAuth2.
-    /// </summary>
-    Task SendEmailOAuth2Async(MimeMessage message, string smtpServer, int smtpPort, string username, string accessToken, bool useSsl = true, CancellationToken cancellationToken = default);
-
-    /// <summary>
-    /// Get OAuth2 access token for Microsoft 365.
-    /// </summary>
-    Task<string> GetOAuth2AccessTokenAsync(string tenantId, string clientId, string clientSecret, string[] scopes, CancellationToken cancellationToken = default);
-}

src/DigitalData.EmailProfiler.Application/Interfaces/Services/IEncryptionService.cs

@@ -1,28 +0,0 @@
-namespace DigitalData.EmailProfiler.Application.Interfaces.Services;
-
-/// <summary>
-/// Encryption service interface for sensitive data (passwords, OAuth tokens).
-/// Uses ASP.NET Core Data Protection API.
-/// </summary>
-public interface IEncryptionService
-{
-    /// <summary>
-    /// Encrypt a string value.
-    /// </summary>
-    string Encrypt(string plainText);
-
-    /// <summary>
-    /// Decrypt an encrypted string value.
-    /// </summary>
-    string Decrypt(string cipherText);
-
-    /// <summary>
-    /// Encrypt a byte array.
-    /// </summary>
-    byte[] Encrypt(byte[] plainData);
-
-    /// <summary>
-    /// Decrypt an encrypted byte array.
-    /// </summary>
-    byte[] Decrypt(byte[] cipherData);
-}

src/DigitalData.EmailProfiler.Application/Interfaces/Services/IPdfProcessingService.cs

@@ -1,59 +0,0 @@
-namespace DigitalData.EmailProfiler.Application.Interfaces.Services;
-
-/// <summary>
-/// PDF processing service interface for validation and embedded file extraction.
-/// </summary>
-public interface IPdfProcessingService
-{
-    /// <summary>
-    /// Validate if file is a valid PDF.
-    /// </summary>
-    Task<bool> IsValidPdfAsync(string filePath, CancellationToken cancellationToken = default);
-
-    /// <summary>
-    /// Validate if stream contains a valid PDF.
-    /// </summary>
-    Task<bool> IsValidPdfAsync(Stream stream, CancellationToken cancellationToken = default);
-
-    /// <summary>
-    /// Extract embedded files from PDF (e.g., ZUGFeRD XML).
-    /// </summary>
-    Task<IEnumerable<EmbeddedFile>> ExtractEmbeddedFilesAsync(string pdfPath, CancellationToken cancellationToken = default);
-
-    /// <summary>
-    /// Extract embedded files from PDF stream.
-    /// </summary>
-    Task<IEnumerable<EmbeddedFile>> ExtractEmbeddedFilesAsync(Stream pdfStream, CancellationToken cancellationToken = default);
-
-    /// <summary>
-    /// Check if PDF contains ZUGFeRD data.
-    /// </summary>
-    Task<bool> HasZugFeRDDataAsync(string pdfPath, CancellationToken cancellationToken = default);
-
-    /// <summary>
-    /// Extract ZUGFeRD XML from PDF.
-    /// </summary>
-    Task<string?> ExtractZugFeRDXmlAsync(string pdfPath, CancellationToken cancellationToken = default);
-
-    /// <summary>
-    /// Get PDF metadata (title, author, creation date, etc.).
-    /// </summary>
-    Task<PdfMetadata> GetMetadataAsync(string pdfPath, CancellationToken cancellationToken = default);
-}
-
-/// <summary>
-/// Represents an embedded file extracted from a PDF.
-/// </summary>
-public record EmbeddedFile(string FileName, byte[] Content, string? Description = null);
-
-/// <summary>
-/// Represents PDF metadata.
-/// </summary>
-public record PdfMetadata(
-    string? Title,
-    string? Author,
-    string? Subject,
-    string? Keywords,
-    DateTime? CreationDate,
-    DateTime? ModificationDate,
-    int PageCount);

src/DigitalData.EmailProfiler.Domain/Common/BaseEntity.cs

@@ -1,9 +0,0 @@
-namespace DigitalData.EmailProfiler.Domain.Common;
-
-public abstract class BaseEntity
-{
-    public DateTime? CreatedDate { get; set; }
-    public string? CreatedBy { get; set; }
-    public DateTime? ModifiedDate { get; set; }
-    public string? ModifiedBy { get; set; }
-}

src/DigitalData.EmailProfiler.Domain/Common/IAggregateRoot.cs

@@ -1,8 +0,0 @@
-namespace DigitalData.EmailProfiler.Domain.Common;
-
-/// <summary>
-/// Marker interface for aggregate roots in DDD
-/// </summary>
-public interface IAggregateRoot
-{
-}

src/DigitalData.EmailProfiler.Domain/Common/ValueObject.cs

@@ -1,43 +0,0 @@
-namespace DigitalData.EmailProfiler.Domain.Common;
-
-/// <summary>
-/// Base class for value objects that implement equality by value
-/// </summary>
-public abstract class ValueObject
-{
-    protected abstract IEnumerable<object> GetEqualityComponents();
-
-    public override bool Equals(object? obj)
-    {
-        if (obj == null || obj.GetType() != GetType())
-        {
-            return false;
-        }
-
-        var other = (ValueObject)obj;
-        return GetEqualityComponents().SequenceEqual(other.GetEqualityComponents());
-    }
-
-    public override int GetHashCode()
-    {
-        return GetEqualityComponents()
-            .Select(x => x?.GetHashCode() ?? 0)
-            .Aggregate((x, y) => x ^ y);
-    }
-
-    public static bool operator ==(ValueObject? left, ValueObject? right)
-    {
-        if (left is null && right is null)
-            return true;
-
-        if (left is null || right is null)
-            return false;
-
-        return left.Equals(right);
-    }
-
-    public static bool operator !=(ValueObject? left, ValueObject? right)
-    {
-        return !(left == right);
-    }
-}

src/DigitalData.EmailProfiler.Domain/Entities/EmailAccount.cs

@@ -1,107 +0,0 @@
-using System.ComponentModel.DataAnnotations;
-using System.ComponentModel.DataAnnotations.Schema;
-using DigitalData.EmailProfiler.Domain.Common;
-using DigitalData.EmailProfiler.Domain.Enums;
-
-namespace DigitalData.EmailProfiler.Domain.Entities;
-
-[Table("TBDD_EMAIL_ACCOUNT")]
-public class EmailAccount : BaseEntity, IAggregateRoot
-{
-    [Key]
-    [Column("EMAIL_ACCOUNT_ID", Order = 0)]
-    [DatabaseGenerated(DatabaseGeneratedOption.Identity)]
-    public int Id { get; set; }
-
-    [Column("ACCOUNT_NAME", TypeName = "varchar(100)")]
-    [Required]
-    [MaxLength(100)]
-    public string AccountName { get; set; } = string.Empty;
-
-    // IMAP Configuration
-    [Column("IMAP_SERVER", TypeName = "varchar(200)")]
-    [Required]
-    [MaxLength(200)]
-    public string ImapServer { get; set; } = string.Empty;
-
-    [Column("IMAP_PORT")]
-    [Required]
-    public int ImapPort { get; set; }
-
-    [Column("IMAP_USE_SSL")]
-    public bool ImapUseSsl { get; set; } = true;
-
-    // SMTP Configuration
-    [Column("SMTP_SERVER", TypeName = "varchar(200)")]
-    [Required]
-    [MaxLength(200)]
-    public string SmtpServer { get; set; } = string.Empty;
-
-    [Column("SMTP_PORT")]
-    [Required]
-    public int SmtpPort { get; set; }
-
-    [Column("SMTP_USE_SSL")]
-    public bool SmtpUseSsl { get; set; } = true;
-
-    // Authentication
-    [Column("USERNAME", TypeName = "varchar(200)")]
-    [Required]
-    [MaxLength(200)]
-    public string Username { get; set; } = string.Empty;
-
-    [Column("PASSWORD", TypeName = "varchar(500)")]
-    [MaxLength(500)]
-    public string? EncryptedPassword { get; set; }
-
-    [Column("USE_OAUTH2")]
-    public bool UseOAuth2 { get; set; }
-
-    // OAuth2 (nullable)
-    [Column("CLIENT_ID", TypeName = "varchar(200)")]
-    [MaxLength(200)]
-    public string? ClientId { get; set; }
-
-    [Column("TENANT_ID", TypeName = "varchar(200)")]
-    [MaxLength(200)]
-    public string? TenantId { get; set; }
-
-    [Column("CLIENT_SECRET", TypeName = "varchar(500)")]
-    [MaxLength(500)]
-    public string? EncryptedClientSecret { get; set; }
-
-    // Status
-    [Column("ACTIVE")]
-    public bool IsActive { get; set; } = true;
-
-    [Column("SEQUENCE")]
-    public int? Sequence { get; set; }
-
-    [Column("COMMENT", TypeName = "varchar(500)")]
-    [MaxLength(500)]
-    public string? Comment { get; set; }
-
-    // Audit fields
-    [Column("ADDED_WHO", TypeName = "varchar(50)")]
-    [MaxLength(50)]
-    public string? AddedWho { get; set; }
-
-    [Column("ADDED_WHEN")]
-    public DateTime? AddedWhen { get; set; }
-
-    [Column("CHANGED_WHO", TypeName = "varchar(50)")]
-    [MaxLength(50)]
-    public string? ChangedWho { get; set; }
-
-    [Column("CHANGED_WHEN")]
-    public DateTime? ChangedWhen { get; set; }
-
-    // Navigation properties
-    public virtual ICollection<EmailProfile> Profiles { get; set; } = new List<EmailProfile>();
-
-    // Domain methods
-    public AuthenticationType GetAuthenticationType() => UseOAuth2 ? AuthenticationType.OAuth2 : AuthenticationType.UsernamePassword;
-
-    public void Activate() => IsActive = true;
-    public void Deactivate() => IsActive = false;
-}

src/DigitalData.EmailProfiler.Domain/Entities/EmailAttachment.cs

@@ -1,93 +0,0 @@
-using System.ComponentModel.DataAnnotations;
-using System.ComponentModel.DataAnnotations.Schema;
-using DigitalData.EmailProfiler.Domain.Common;
-using DigitalData.EmailProfiler.Domain.Enums;
-
-namespace DigitalData.EmailProfiler.Domain.Entities;
-
-[Table("TBEMLP_HISTORY_ATTACHMENT")]
-public class EmailAttachment : BaseEntity
-{
-    [Key]
-    [Column("GUID", Order = 0)]
-    [DatabaseGenerated(DatabaseGeneratedOption.Identity)]
-    public int Id { get; set; }
-
-    [Column("EMAIL_HISTORY_ID")]
-    [Required]
-    public int EmailHistoryId { get; set; }
-
-    // File information
-    [Column("ORIGINAL_FILE_NAME", TypeName = "varchar(500)")]
-    [Required]
-    [MaxLength(500)]
-    public string OriginalFileName { get; set; } = string.Empty;
-
-    [Column("SAVED_FILE_NAME", TypeName = "varchar(500)")]
-    [Required]
-    [MaxLength(500)]
-    public string SavedFileName { get; set; } = string.Empty;
-
-    [Column("FILE_PATH", TypeName = "varchar(1000)")]
-    [Required]
-    [MaxLength(1000)]
-    public string FilePath { get; set; } = string.Empty;
-
-    [Column("FILE_SIZE")]
-    public long FileSize { get; set; }
-
-    [Column("EXTENSION", TypeName = "varchar(20)")]
-    [MaxLength(20)]
-    public string Extension { get; set; } = string.Empty;
-
-    // Attachment hierarchy
-    [Column("IS_EMBEDDED_FILE")]
-    public bool IsEmbeddedFile { get; set; }
-
-    [Column("PARENT_ATTACHMENT_ID")]
-    public int? ParentAttachmentId { get; set; }
-
-    [Column("ATTACHMENT_POSITION")]
-    public int AttachmentPosition { get; set; }
-
-    // Validation
-    [Column("STATUS", TypeName = "varchar(50)")]
-    [MaxLength(50)]
-    public string? Status { get; set; }
-
-    [Column("VALIDATION_ERROR_CODE")]
-    public int? ValidationErrorCode { get; set; }
-
-    [Column("VALIDATION_ERROR_MESSAGE", TypeName = "nvarchar(max)")]
-    public string? ValidationErrorMessage { get; set; }
-
-    [Column("COMMENT", TypeName = "varchar(500)")]
-    [MaxLength(500)]
-    public string? Comment { get; set; }
-
-    // Audit field
-    [Column("ADDED_WHEN")]
-    public DateTime? AddedWhen { get; set; }
-
-    // Navigation properties
-    [ForeignKey("EmailHistoryId")]
-    public virtual EmailHistory? EmailHistory { get; set; }
-
-    [ForeignKey("ParentAttachmentId")]
-    public virtual EmailAttachment? ParentAttachment { get; set; }
-
-    public virtual ICollection<EmailAttachment> EmbeddedFiles { get; set; } = new List<EmailAttachment>();
-
-    // Domain methods
-    public void MarkAsValid()
-    {
-        Status = AttachmentStatus.Valid.ToString();
-    }
-
-    public void MarkAsCorrupt(ErrorCode errorCode, string message)
-    {
-        Status = AttachmentStatus.Corrupt.ToString();
-        ValidationErrorCode = (int)errorCode;
-        ValidationErrorMessage = message;
-    }
-}

src/DigitalData.EmailProfiler.Domain/Entities/EmailHistory.cs

@@ -1,112 +0,0 @@
-using System.ComponentModel.DataAnnotations;
-using System.ComponentModel.DataAnnotations.Schema;
-using DigitalData.EmailProfiler.Domain.Common;
-using DigitalData.EmailProfiler.Domain.Enums;
-
-namespace DigitalData.EmailProfiler.Domain.Entities;
-
-[Table("TBEMLP_HISTORY")]
-public class EmailHistory : BaseEntity
-{
-    [Key]
-    [Column("GUID", Order = 0)]
-    [DatabaseGenerated(DatabaseGeneratedOption.Identity)]
-    public int Id { get; set; }
-
-    [Column("PROFILE_ID")]
-    public int? ProfileId { get; set; }
-
-    [Column("WORK_PROCESS", TypeName = "varchar(100)")]
-    [MaxLength(100)]
-    public string? WorkProcess { get; set; }
-
-    // Email identification
-    [Column("EMAIL_MSGID")]
-    [Required]
-    public int EmailMessageId { get; set; }
-
-    [Column("EMAIL_MSGID_HASH", TypeName = "varchar(100)")]
-    [MaxLength(100)]
-    public string? MessageIdHash { get; set; }
-
-    [Column("EMAIL_MSGID_ORIGINAL", TypeName = "varchar(500)")]
-    [MaxLength(500)]
-    public string? OriginalMessageId { get; set; }
-
-    [Column("IMAP_UID")]
-    public int? ImapUid { get; set; }
-
-    // Email metadata
-    [Column("EMAIL_SENDER", TypeName = "varchar(200)")]
-    [MaxLength(200)]
-    public string? SenderAddress { get; set; }
-
-    [Column("EMAIL_SUBJECT", TypeName = "varchar(500)")]
-    [MaxLength(500)]
-    public string? Subject { get; set; }
-
-    [Column("EMAIL_DATE")]
-    public DateTime? EmailDate { get; set; }
-
-    [Column("EMAIL_BODY", TypeName = "nvarchar(max)")]
-    public string? EmailBodyHtml { get; set; }
-
-    [Column("EMAIL_BODY_TEXT", TypeName = "nvarchar(max)")]
-    public string? EmailBodyText { get; set; }
-
-    [Column("EMAIL_SUBSTRING1", TypeName = "varchar(500)")]
-    [MaxLength(500)]
-    public string? EmailSubstring1 { get; set; }
-
-    [Column("EMAIL_SUBSTRING2", TypeName = "varchar(500)")]
-    [MaxLength(500)]
-    public string? EmailSubstring2 { get; set; }
-
-    // Processing
-    [Column("PROCESSED_DATE")]
-    public DateTime? ProcessedDate { get; set; }
-
-    [Column("STATUS", TypeName = "varchar(50)")]
-    [MaxLength(50)]
-    public string? Status { get; set; }
-
-    [Column("ERROR_CODE")]
-    public int? ErrorCodeValue { get; set; }
-
-    [Column("ERROR_MESSAGE", TypeName = "nvarchar(max)")]
-    public string? ErrorMessage { get; set; }
-
-    // windream
-    [Column("WINDREAM_DOCUMENT_ID", TypeName = "varchar(100)")]
-    [MaxLength(100)]
-    public string? WindreamDocumentId { get; set; }
-
-    [Column("COMMENT", TypeName = "varchar(500)")]
-    [MaxLength(500)]
-    public string? Comment { get; set; }
-
-    // Audit field
-    [Column("ADDED_WHEN")]
-    public DateTime? AddedWhen { get; set; }
-
-    // Navigation properties
-    [ForeignKey("ProfileId")]
-    public virtual EmailProfile? Profile { get; set; }
-
-    public virtual ICollection<EmailAttachment> Attachments { get; set; } = new List<EmailAttachment>();
-
-    // Domain methods
-    public void MarkAsProcessed()
-    {
-        Status = EmailStatus.Processed.ToString();
-        ProcessedDate = DateTime.Now;
-    }
-
-    public void MarkAsFailed(ErrorCode errorCode, string message)
-    {
-        Status = EmailStatus.Failed.ToString();
-        ErrorCodeValue = (int)errorCode;
-        ErrorMessage = message;
-        ProcessedDate = DateTime.Now;
-    }
-}

src/DigitalData.EmailProfiler.Domain/Entities/EmailOutbox.cs

@@ -1,60 +0,0 @@
-using System.ComponentModel.DataAnnotations;
-using System.ComponentModel.DataAnnotations.Schema;
-using DigitalData.EmailProfiler.Domain.Common;
-
-namespace DigitalData.EmailProfiler.Domain.Entities;
-
-[Table("TBEMLP_EMAIL_OUT")]
-public class EmailOutbox : BaseEntity
-{
-    [Key]
-    [Column("GUID", Order = 0)]
-    [DatabaseGenerated(DatabaseGeneratedOption.Identity)]
-    public int Id { get; set; }
-
-    [Column("EMAIL_ACCOUNT_ID")]
-    [Required]
-    public int EmailAccountId { get; set; }
-
-    [Column("RECIPIENT", TypeName = "varchar(200)")]
-    [Required]
-    [MaxLength(200)]
-    public string Recipient { get; set; } = string.Empty;
-
-    [Column("SUBJECT", TypeName = "nvarchar(500)")]
-    [Required]
-    [MaxLength(500)]
-    public string Subject { get; set; } = string.Empty;
-
-    [Column("BODY", TypeName = "nvarchar(max)")]
-    [Required]
-    public string Body { get; set; } = string.Empty;
-
-    [Column("IS_HTML")]
-    public bool IsHtml { get; set; } = true;
-
-    [Column("SENT")]
-    public bool Sent { get; set; }
-
-    [Column("SENT_DATE")]
-    public DateTime? SentDate { get; set; }
-
-    [Column("RETRY_COUNT")]
-    public int RetryCount { get; set; }
-
-    [Column("REFERENCE_STRING", TypeName = "varchar(200)")]
-    [MaxLength(200)]
-    public string? ReferenceId { get; set; }
-
-    [Column("COMMENT", TypeName = "varchar(500)")]
-    [MaxLength(500)]
-    public string? Comment { get; set; }
-
-    // Audit field
-    [Column("ADDED_WHEN")]
-    public DateTime? AddedWhen { get; set; }
-
-    // Navigation properties
-    [ForeignKey("EmailAccountId")]
-    public virtual EmailAccount? EmailAccount { get; set; }
-}

src/DigitalData.EmailProfiler.Domain/Entities/EmailProcess.cs

@@ -1,114 +0,0 @@
-using System.ComponentModel.DataAnnotations;
-using System.ComponentModel.DataAnnotations.Schema;
-using DigitalData.EmailProfiler.Domain.Common;
-using DigitalData.EmailProfiler.Domain.Enums;
-
-namespace DigitalData.EmailProfiler.Domain.Entities;
-
-[Table("TBEMLP_POLL_PROCESS")]
-public class EmailProcess : BaseEntity
-{
-    [Key]
-    [Column("GUID", Order = 0)]
-    [DatabaseGenerated(DatabaseGeneratedOption.Identity)]
-    public int Id { get; set; }
-
-    [Column("PROCESS_NAME", TypeName = "varchar(100)")]
-    [Required]
-    [MaxLength(100)]
-    public string ProcessName { get; set; } = string.Empty;
-
-    [Column("STEP_NAME", TypeName = "varchar(100)")]
-    [Required]
-    [MaxLength(100)]
-    public string StepName { get; set; } = string.Empty;
-
-    [Column("PROFILE_ID")]
-    public int? ProfileId { get; set; }
-
-    // Configuration
-    [Column("COPY_2_HDD")]
-    public bool CopyToHdd { get; set; }
-
-    [Column("DELETE_MAIL")]
-    public bool DeleteEmailAfterProcessing { get; set; }
-
-    // Paths
-    [Column("PATH_EMAIL_TEMP", TypeName = "varchar(500)")]
-    [Required]
-    [MaxLength(500)]
-    public string TempPath { get; set; } = string.Empty;
-
-    [Column("PATH_EMAIL_ERRORS", TypeName = "varchar(500)")]
-    [Required]
-    [MaxLength(500)]
-    public string ErrorPath { get; set; } = string.Empty;
-
-    [Column("PATH_ORIGINAL", TypeName = "varchar(500)")]
-    [MaxLength(500)]
-    public string? ArchivePath { get; set; }
-
-    // windream
-    [Column("WM_IMPORT")]
-    public bool EnableWindreamImport { get; set; }
-
-    [Column("WM_OBJEKTTYPE", TypeName = "varchar(100)")]
-    [MaxLength(100)]
-    public string? WindreamObjectType { get; set; }
-
-    [Column("WM_VECTOR_LOG", TypeName = "varchar(500)")]
-    [MaxLength(500)]
-    public string? WindreamVectorLog { get; set; }
-
-    [Column("WM_PATH", TypeName = "varchar(500)")]
-    [MaxLength(500)]
-    public string? WindreamPath { get; set; }
-
-    [Column("WM_FILE_NAME", TypeName = "varchar(200)")]
-    [MaxLength(200)]
-    public string? WindreamFileName { get; set; }
-
-    [Column("WM_REFERENCE_INDEX", TypeName = "varchar(100)")]
-    [MaxLength(100)]
-    public string? WindreamReferenceIndex { get; set; }
-
-    [Column("WM_IDX_BODY_TEXT", TypeName = "varchar(100)")]
-    [MaxLength(100)]
-    public string? WindreamIndexBodyText { get; set; }
-
-    [Column("WM_IDX_BODY_SUBSTR_LENGTH")]
-    public int WindreamIndexBodySubstrLength { get; set; }
-
-    [Column("ALLOW_XML_RECEIPTS")]
-    public bool? AllowXmlReceipts { get; set; }
-
-    // Status
-    [Column("ACTIVE")]
-    public bool IsActive { get; set; } = true;
-
-    [Column("SEQUENCE")]
-    public int? Sequence { get; set; }
-
-    [Column("COMMENT", TypeName = "varchar(500)")]
-    [MaxLength(500)]
-    public string? Comment { get; set; }
-
-    // Audit fields
-    [Column("ADDED_WHO", TypeName = "varchar(50)")]
-    [MaxLength(50)]
-    public string? AddedWho { get; set; }
-
-    [Column("ADDED_WHEN")]
-    public DateTime? AddedWhen { get; set; }
-
-    [Column("CHANGED_WHO", TypeName = "varchar(50)")]
-    [MaxLength(50)]
-    public string? ChangedWho { get; set; }
-
-    [Column("CHANGED_WHEN")]
-    public DateTime? ChangedWhen { get; set; }
-
-    // Navigation properties
-    public virtual ICollection<ProcessStep> Steps { get; set; } = new List<ProcessStep>();
-    public virtual ICollection<EmailProfile> Profiles { get; set; } = new List<EmailProfile>();
-}

src/DigitalData.EmailProfiler.Domain/Entities/EmailProfile.cs

@@ -1,88 +0,0 @@
-using System.ComponentModel.DataAnnotations;
-using System.ComponentModel.DataAnnotations.Schema;
-using DigitalData.EmailProfiler.Domain.Common;
-
-namespace DigitalData.EmailProfiler.Domain.Entities;
-
-[Table("TBEMLP_POLL_PROFILES")]
-public class EmailProfile : BaseEntity, IAggregateRoot
-{
-    [Key]
-    [Column("GUID", Order = 0)]
-    [DatabaseGenerated(DatabaseGeneratedOption.Identity)]
-    public int Id { get; set; }
-
-    [Column("PROFILE_NAME", TypeName = "varchar(100)")]
-    [Required]
-    [MaxLength(100)]
-    public string ProfileName { get; set; } = string.Empty;
-
-    [Column("POLL_TYPE", TypeName = "varchar(100)")]
-    [Required]
-    [MaxLength(100)]
-    public string PollType { get; set; } = "IMAP";
-
-    [Column("EMAIL_CONF_ID")]
-    [Required]
-    public int EmailAccountId { get; set; }
-
-    [Column("PROCESS_ID")]
-    public int? ProcessId { get; set; }
-
-    // Polling Configuration
-    [Column("POLL_INTERVAL")]
-    public int PollIntervalMinutes { get; set; } = 5;
-
-    [Column("LAST_TICK")]
-    public DateTime? LastPollTime { get; set; }
-
-    // Validation
-    [Column("VALIDATION_SQL", TypeName = "nvarchar(1024)")]
-    [MaxLength(1024)]
-    public string? ValidationSql { get; set; }
-
-    // Status
-    [Column("ACTIVE")]
-    public bool IsActive { get; set; }
-
-    [Column("SEQUENCE")]
-    public int? Sequence { get; set; }
-
-    [Column("COMMENT", TypeName = "varchar(500)")]
-    [MaxLength(500)]
-    public string? Comment { get; set; }
-
-    // Audit fields
-    [Column("ADDED_WHO", TypeName = "varchar(50)")]
-    [MaxLength(50)]
-    public string? AddedWho { get; set; }
-
-    [Column("ADDED_WHEN")]
-    public DateTime? AddedWhen { get; set; }
-
-    [Column("CHANGED_WHO", TypeName = "varchar(50)")]
-    [MaxLength(50)]
-    public string? ChangedWho { get; set; }
-
-    [Column("CHANGED_WHEN")]
-    public DateTime? ChangedWhen { get; set; }
-
-    // Navigation properties
-    [ForeignKey("EmailAccountId")]
-    public virtual EmailAccount? EmailAccount { get; set; }
-
-    [ForeignKey("ProcessId")]
-    public virtual EmailProcess? EmailProcess { get; set; }
-
-    public virtual ICollection<EmailHistory> EmailHistories { get; set; } = new List<EmailHistory>();
-
-    // Domain methods
-    public void UpdateLastPollTime() => LastPollTime = DateTime.Now;
-
-    public bool ShouldPoll()
-    {
-        if (!IsActive) return false;
-        if (!LastPollTime.HasValue) return true;
-        return DateTime.Now >= LastPollTime.Value.AddMinutes(PollIntervalMinutes);
-    }
-}

src/DigitalData.EmailProfiler.Domain/Entities/IndexingStep.cs

@@ -1,56 +0,0 @@
-using System.ComponentModel.DataAnnotations;
-using System.ComponentModel.DataAnnotations.Schema;
-using DigitalData.EmailProfiler.Domain.Common;
-
-namespace DigitalData.EmailProfiler.Domain.Entities;
-
-[Table("TBEMLP_POLL_INDEXING_STEPS")]
-public class IndexingStep : BaseEntity
-{
-    [Key]
-    [Column("GUID", Order = 0)]
-    [DatabaseGenerated(DatabaseGeneratedOption.Identity)]
-    public int Id { get; set; }
-
-    [Column("STEP_ID")]
-    [Required]
-    public int StepId { get; set; }
-
-    [Column("INDEXNAME", TypeName = "varchar(100)")]
-    [Required]
-    [MaxLength(100)]
-    public string IndexName { get; set; } = string.Empty;
-
-    [Column("INDEXVALUE", TypeName = "varchar(100)")]
-    [Required]
-    [MaxLength(100)]
-    public string IndexValue { get; set; } = string.Empty;
-
-    [Column("ACTIVE")]
-    public bool IsActive { get; set; } = true;
-
-    [Column("USE_FOR_DIRECT_ANSWER")]
-    public bool UseForDirectAnswer { get; set; }
-
-    [Column("SEQUENCE")]
-    public int? Sequence { get; set; }
-
-    // Audit fields
-    [Column("ADDED_WHO", TypeName = "varchar(50)")]
-    [MaxLength(50)]
-    public string? AddedWho { get; set; }
-
-    [Column("ADDED_WHEN")]
-    public DateTime? AddedWhen { get; set; }
-
-    [Column("CHANGED_WHO", TypeName = "varchar(50)")]
-    [MaxLength(50)]
-    public string? ChangedWho { get; set; }
-
-    [Column("CHANGED_WHEN")]
-    public DateTime? ChangedWhen { get; set; }
-
-    // Navigation properties
-    [ForeignKey("StepId")]
-    public virtual ProcessStep? ProcessStep { get; set; }
-}

src/DigitalData.EmailProfiler.Domain/Entities/ProcessStep.cs

@@ -1,58 +0,0 @@
-using System.ComponentModel.DataAnnotations;
-using System.ComponentModel.DataAnnotations.Schema;
-using DigitalData.EmailProfiler.Domain.Common;
-
-namespace DigitalData.EmailProfiler.Domain.Entities;
-
-[Table("TBEMLP_POLL_STEPS")]
-public class ProcessStep : BaseEntity
-{
-    [Key]
-    [Column("GUID", Order = 0)]
-    [DatabaseGenerated(DatabaseGeneratedOption.Identity)]
-    public int Id { get; set; }
-
-    [Column("PROCESS_ID")]
-    [Required]
-    public int ProcessId { get; set; }
-
-    [Column("STEP_NAME", TypeName = "varchar(50)")]
-    [Required]
-    [MaxLength(50)]
-    public string StepName { get; set; } = string.Empty;
-
-    [Column("KEYWORDS_BODY", TypeName = "varchar(1000)")]
-    [MaxLength(1000)]
-    public string? KeywordsBody { get; set; }
-
-    [Column("ACTIVE")]
-    public bool IsActive { get; set; } = true;
-
-    [Column("SEQUENCE")]
-    public int? Sequence { get; set; }
-
-    [Column("COMMENT", TypeName = "varchar(500)")]
-    [MaxLength(500)]
-    public string? Comment { get; set; }
-
-    // Audit fields
-    [Column("ADDED_WHO", TypeName = "varchar(50)")]
-    [MaxLength(50)]
-    public string? AddedWho { get; set; }
-
-    [Column("ADDED_WHEN")]
-    public DateTime? AddedWhen { get; set; }
-
-    [Column("CHANGED_WHO", TypeName = "varchar(50)")]
-    [MaxLength(50)]
-    public string? ChangedWho { get; set; }
-
-    [Column("CHANGED_WHEN")]
-    public DateTime? ChangedWhen { get; set; }
-
-    // Navigation properties
-    [ForeignKey("ProcessId")]
-    public virtual EmailProcess? EmailProcess { get; set; }
-
-    public virtual ICollection<IndexingStep> IndexingSteps { get; set; } = new List<IndexingStep>();
-}

src/DigitalData.EmailProfiler.Domain/Enums/AttachmentStatus.cs

@@ -1,9 +0,0 @@
-namespace DigitalData.EmailProfiler.Domain.Enums;
-
-public enum AttachmentStatus
-{
-    Pending = 1,
-    Valid = 2,
-    Corrupt = 3,
-    Skipped = 4
-}

src/DigitalData.EmailProfiler.Domain/Enums/AuthenticationType.cs

@@ -1,7 +0,0 @@
-namespace DigitalData.EmailProfiler.Domain.Enums;
-
-public enum AuthenticationType
-{
-    UsernamePassword = 1,
-    OAuth2 = 2
-}

src/DigitalData.EmailProfiler.Domain/Enums/EmailStatus.cs

@@ -1,11 +0,0 @@
-namespace DigitalData.EmailProfiler.Domain.Enums;
-
-public enum EmailStatus
-{
-    Pending = 1,
-    Processing = 2,
-    Processed = 3,
-    Failed = 4,
-    PartiallyProcessed = 5,
-    Rejected = 6
-}

src/DigitalData.EmailProfiler.Domain/Enums/ErrorCode.cs

@@ -1,16 +0,0 @@
-namespace DigitalData.EmailProfiler.Domain.Enums;
-
-public enum ErrorCode
-{
-    None = 0,
-    NoAttachments = 10001,
-    SenderValidationFailed = 10002,
-    EmbeddedFileAttachmentCorrupt = 10003,
-    NormalFileAttachmentCorrupt = 10004,
-    PdfStructureInvalid = 10005,
-    ImapConnectionFailed = 10006,
-    WindreamImportFailed = 10007,
-    DiskSpaceInsufficient = 10008,
-    DuplicateMessageId = 10009,
-    AttachmentExtractionFailed = 10010
-}

src/DigitalData.EmailProfiler.Domain/Enums/ProcessType.cs

@@ -1,8 +0,0 @@
-namespace DigitalData.EmailProfiler.Domain.Enums;
-
-public enum ProcessType
-{
-    ProcessManager = 1,      // Easy Approval workflow
-    AttachmentSniffer = 2,   // General attachment extraction
-    ZugFeRDParser = 3        // Electronic invoice processing
-}

src/DigitalData.EmailProfiler.Domain/Events/EmailProcessedEvent.cs

@@ -1,13 +0,0 @@
-using MediatR;
-using DigitalData.EmailProfiler.Domain.Enums;
-
-namespace DigitalData.EmailProfiler.Domain.Events;
-
-public class EmailProcessedEvent(int emailHistoryId, int profileId, string messageId, EmailStatus status) : INotification
-{
-    public int EmailHistoryId { get; } = emailHistoryId;
-    public int ProfileId { get; } = profileId;
-    public string MessageId { get; } = messageId;
-    public EmailStatus Status { get; } = status;
-    public DateTime ProcessedDate { get; } = DateTime.Now;
-}

src/DigitalData.EmailProfiler.Domain/Exceptions/AttachmentProcessingException.cs

@@ -1,15 +0,0 @@
-using DigitalData.EmailProfiler.Domain.Enums;
-
-namespace DigitalData.EmailProfiler.Domain.Exceptions;
-
-public class AttachmentProcessingException : DomainException
-{
-    public AttachmentProcessingException(ErrorCode errorCode, string message) : base(message, errorCode)
-    {
-    }
-
-    public AttachmentProcessingException(ErrorCode errorCode, string message, Exception innerException) 
-        : base(message, errorCode)
-    {
-    }
-}

src/DigitalData.EmailProfiler.Domain/Exceptions/DomainException.cs

@@ -1,21 +0,0 @@
-using DigitalData.EmailProfiler.Domain.Enums;
-
-namespace DigitalData.EmailProfiler.Domain.Exceptions;
-
-public class DomainException : Exception
-{
-    public ErrorCode? ErrorCode { get; }
-
-    public DomainException(string message) : base(message)
-    {
-    }
-
-    public DomainException(string message, ErrorCode errorCode) : base(message)
-    {
-        ErrorCode = errorCode;
-    }
-
-    public DomainException(string message, Exception innerException) : base(message, innerException)
-    {
-    }
-}

src/DigitalData.EmailProfiler.Domain/Exceptions/ValidationException.cs

@@ -1,18 +0,0 @@
-using DigitalData.EmailProfiler.Domain.Enums;
-
-namespace DigitalData.EmailProfiler.Domain.Exceptions;
-
-public class ValidationException : DomainException
-{
-    public ValidationException(string message) : base(message)
-    {
-    }
-
-    public ValidationException(string message, ErrorCode errorCode) : base(message, errorCode)
-    {
-    }
-
-    public ValidationException(string message, Exception innerException) : base(message, innerException)
-    {
-    }
-}

src/DigitalData.EmailProfiler.Domain/Services/MessageIdGenerator.cs

@@ -1,28 +0,0 @@
-using DigitalData.EmailProfiler.Domain.ValueObjects;
-
-namespace DigitalData.EmailProfiler.Domain.Services;
-
-public interface IMessageIdGenerator
-{
-    MessageId Generate(string originalMessageId, string sender, DateTime date, string subject);
-    List<string> GenerateFallbackHashes(MessageId messageId);
-}
-
-public class MessageIdGenerator : IMessageIdGenerator
-{
-    public MessageId Generate(string originalMessageId, string sender, DateTime date, string subject)
-    {
-        return MessageId.Create(originalMessageId, sender, date, subject);
-    }
-
-    public List<string> GenerateFallbackHashes(MessageId messageId)
-    {
-        // Legacy behavior: 10 variations for duplicate detection
-        var hashes = new List<string> { messageId.Hash };
-
-        // Add variations (this is simplified - legacy had 10 variations)
-        // TODO: Implement exact legacy fallback algorithm if needed
-        
-        return hashes;
-    }
-}

src/DigitalData.EmailProfiler.Domain/ValueObjects/EmailAddress.cs

@@ -1,45 +0,0 @@
-using System.ComponentModel.DataAnnotations;
-using DigitalData.EmailProfiler.Domain.Common;
-using DigitalData.EmailProfiler.Domain.Exceptions;
-
-namespace DigitalData.EmailProfiler.Domain.ValueObjects;
-
-/// <summary>
-/// Value object representing an email address with validation
-/// </summary>
-public class EmailAddress : ValueObject
-{
-    public string Value { get; private set; }
-    public string Domain { get; private set; }
-    public string LocalPart { get; private set; }
-
-    private EmailAddress(string value)
-    {
-        Value = value;
-        var parts = value.Split('@');
-        LocalPart = parts[0];
-        Domain = parts[1];
-    }
-
-    public static EmailAddress Create(string email)
-    {
-        if (!IsValid(email))
-            throw new DomainException($"Invalid email address: {email}");
-
-        return new EmailAddress(email.ToLowerInvariant());
-    }
-
-    private static bool IsValid(string email)
-    {
-        return !string.IsNullOrWhiteSpace(email) &&
-               email.Contains('@') &&
-               new EmailAddressAttribute().IsValid(email);
-    }
-
-    protected override IEnumerable<object> GetEqualityComponents()
-    {
-        yield return Value;
-    }
-
-    public override string ToString() => Value;
-}

src/DigitalData.EmailProfiler.Domain/ValueObjects/MessageId.cs

@@ -1,41 +0,0 @@
-using System.Security.Cryptography;
-using System.Text;
-using DigitalData.EmailProfiler.Domain.Common;
-
-namespace DigitalData.EmailProfiler.Domain.ValueObjects;
-
-/// <summary>
-/// Value object representing a unique message identifier with hash generation
-/// Uses the same algorithm as legacy system for compatibility
-/// </summary>
-public class MessageId : ValueObject
-{
-    public string Value { get; private set; }
-    public string Hash { get; private set; }
-
-    private MessageId(string value)
-    {
-        Value = value;
-        Hash = GenerateHash(value);
-    }
-
-    public static MessageId Create(string originalMessageId, string sender, DateTime date, string subject)
-    {
-        var combined = $"{originalMessageId}|{sender}|{date:yyyyMMddHHmmss}|{subject}";
-        return new MessageId(combined);
-    }
-
-    private static string GenerateHash(string input)
-    {
-        // Same algorithm as legacy: SHA256 hash
-        using var sha256 = SHA256.Create();
-        var bytes = Encoding.UTF8.GetBytes(input);
-        var hash = sha256.ComputeHash(bytes);
-        return Convert.ToBase64String(hash);
-    }
-
-    protected override IEnumerable<object> GetEqualityComponents()
-    {
-        yield return Value;
-    }
-}

src/DigitalData.EmailProfiler.Infrastructure/DigitalData.EmailProfiler.Infrastructure.csproj

@@ -1,13 +0,0 @@
-<Project Sdk="Microsoft.NET.Sdk">
-
-  <PropertyGroup>
-    <TargetFramework>net8.0</TargetFramework>
-    <ImplicitUsings>enable</ImplicitUsings>
-    <Nullable>enable</Nullable>
-  </PropertyGroup>
-
-  <ItemGroup>
-    <ProjectReference Include="..\DigitalData.EmailProfiler.Domain\DigitalData.EmailProfiler.Domain.csproj" />
-  </ItemGroup>
-
-</Project>

src/core/DigitalData.MessagingService.Application/Common/Dto/EmailAccounts/EmailAccountDto.cs

@@ -0,0 +1,46 @@
+namespace DigitalData.MessagingService.Application.Common.Dto.EmailAccounts;
+
+/// <summary>
+/// DTO for a single email account configuration.
+/// </summary>
+public record EmailAccountDto
+{
+    /// <summary>
+    /// Logical name to identify this account (e.g. "default", "support").
+    /// </summary>
+    public int Id { get; set; }
+
+#if NET
+    public required string Username { get; set; }
+#else
+    public string Username { get; set; } = null!;
+#endif
+
+#if NET
+    public required string SmtpServer { get; set; }
+#else
+    public string SmtpServer { get; set; } = null!;
+#endif
+
+    public int SmtpPort { get; set; }
+
+    public bool SmtpUseSsl { get; set; }
+
+    public bool UseOAuth2 { get; set; }
+
+    /// <summary>
+    /// IMAP server hostname (e.g. "imap.example.com").
+    /// Leave empty when this account is send-only.
+    /// </summary>
+    public string? ImapServer { get; set; }
+
+    /// <summary>
+    /// IMAP server port (993 for SSL, 143 for plain/STARTTLS).
+    /// </summary>
+    public int ImapPort { get; set; } = 993;
+
+    /// <summary>
+    /// Use SSL/TLS when connecting to the IMAP server.
+    /// </summary>
+    public bool ImapUseSsl { get; set; } = true;
+}

src/core/DigitalData.MessagingService.Application/Common/Dto/EmailAccounts/EmailAccountModificationDto.cs

@@ -0,0 +1,47 @@
+namespace DigitalData.MessagingService.Application.Common.Dto.EmailAccounts;
+
+/// <summary>
+/// DTO for a single email account configuration.
+/// </summary>
+public record EmailAccountModificationDto
+{
+#if NET
+    public required string Username { get; set; }
+#else
+    public string Username { get; set; } = null!;
+#endif
+
+#if NET
+    public required string Password { get; set; }
+#else
+    public string Password { get; set; } = null!;
+#endif
+
+#if NET
+    public required string SmtpServer { get; set; }
+#else
+    public string SmtpServer { get; set; } = null!;
+#endif
+
+    public int SmtpPort { get; set; }
+
+    public bool SmtpUseSsl { get; set; }
+
+    public bool UseOAuth2 { get; set; }
+
+    /// <summary>
+    /// IMAP server hostname (e.g. "imap.example.com").
+    /// Leave empty when this account is send-only.
+    /// </summary>
+    public string? ImapServer { get; set; }
+
+    /// <summary>
+    /// IMAP server port (993 for SSL, 143 for plain/STARTTLS).
+    /// </summary>
+    public int ImapPort { get; set; } = 993;
+
+    /// <summary>
+    /// Use SSL/TLS when connecting to the IMAP server.
+    /// </summary>
+    public bool ImapUseSsl { get; set; } = true;
+}

src/core/DigitalData.MessagingService.Application/Common/Dto/EmailAttachmentDto.cs

@@ -0,0 +1,45 @@
+namespace DigitalData.MessagingService.Application.Common.Dto;
+
+/// <summary>
+/// Represents a single email attachment.
+/// </summary>
+public sealed class EmailAttachmentDto
+{
+    /// <summary>
+    /// Display name of the attachment (e.g. "invoice.pdf").
+    /// </summary>
+#if NETFRAMEWORK
+    public string FileName { get; set; } = null!;
+#else
+    public required string FileName { get; init; }
+#endif
+
+    /// <summary>
+    /// Raw content of the attachment.
+    /// </summary>
+#if NETFRAMEWORK
+    public byte[] Content { get; set; } = null!;
+#else
+    public required byte[] Content { get; init; }
+#endif
+
+    /// <summary>
+    /// MIME content-type (e.g. "application/pdf", "image/png").
+    /// Defaults to "application/octet-stream" when not specified.
+    /// </summary>
+    public string ContentType { get; set; } = "application/octet-stream";
+
+    /// <summary>
+    /// When <see langword="true"/> the attachment is embedded inline and displayed
+    /// directly inside the email body via a CID reference (e.g. &lt;img src="cid:logo"&gt;).
+    /// When <see langword="false"/> (default) it appears as a regular downloadable attachment.
+    /// </summary>
+    public bool IsInline { get; set; } = false;
+
+    /// <summary>
+    /// Content-ID used when <see cref="IsInline"/> is <see langword="true"/>.
+    /// Reference it in HTML body as <c>cid:{ContentId}</c>.
+    /// Auto-generated from <see cref="FileName"/> when left empty.
+    /// </summary>
+    public string? ContentId { get; set; }
+}

src/core/DigitalData.MessagingService.Application/Common/Dto/EmailContext.cs

@@ -0,0 +1,57 @@
+using DigitalData.MessagingService.Domain.Entities;
+
+namespace DigitalData.MessagingService.Application.Common.Dto;
+
+public record EmailContext
+{
+#if NETFRAMEWORK
+    public EmailAccount Sender { get; set; } = null!;
+#else
+    public required EmailAccount Sender { get; init; }
+#endif
+
+    /// <summary>
+    /// Recipient email address
+    /// </summary>
+
+#if NETFRAMEWORK
+    public IEnumerable<string> Recipients { get; set; } = null!;
+#else
+    public required IEnumerable<string> Recipients { get; init; }
+#endif
+
+    /// <summary>
+    /// Email subject
+    /// </summary>
+
+#if NETFRAMEWORK
+    public string Subject { get; set; } = null!;
+#else
+    public required string Subject { get; init; }
+#endif
+
+    /// <summary>
+    /// Email body (HTML or plain text)
+    /// </summary>
+#if NETFRAMEWORK
+    public string Body { get; set; } = null!;
+#else
+    public required string Body { get; init; }
+#endif
+
+    /// <summary>
+    /// Is HTML email (default: true)
+    /// </summary>
+#if NETFRAMEWORK
+    public bool IsHtml { get; set; } = true;
+#else
+    public bool IsHtml { get; init; } = true;
+#endif
+
+    /// <summary>
+    /// Optional list of attachments to include with the email.
+    /// Each entry may carry its content as a byte array (<see cref="EmailAttachmentDto.Content"/>)
+    /// or reference a file on disk via <see cref="EmailAttachmentDto.FilePath"/>.
+    /// </summary>
+    public IEnumerable<EmailAttachmentDto> Attachments { get; set; } = [];
+}

src/core/DigitalData.MessagingService.Application/Common/Dto/EmailSyncResult.cs

@@ -0,0 +1,5 @@
+#if NET
+namespace DigitalData.MessagingService.Application.Common.Dto;
+
+public record EmailSyncResult(int ProcessedCount = 0, int FailedCount = 0);
+#endif

src/core/DigitalData.MessagingService.Application/Common/Dto/MailSearch/DateFilter.cs

@@ -0,0 +1,15 @@
+#if NET
+namespace DigitalData.MessagingService.Application.Common.Dto.MailSearch;
+
+/// <summary>
+/// Constrains the search to messages within an arrival-date range.
+/// </summary>
+/// <remarks>
+/// At least one of <see cref="After"/> or <see cref="Before"/> must be provided.
+/// When both are set <see cref="After"/> must be earlier than <see cref="Before"/>.
+/// Both bounds are <b>inclusive</b>.
+/// </remarks>
+/// <param name="After">Earliest date to include (inclusive). Maps to IMAP <c>SINCE</c>.</param>
+/// <param name="Before">Latest date to include (inclusive). Maps to IMAP <c>BEFORE</c> (next day is used internally).</param>
+public record DateFilter(DateTime? After = null, DateTime? Before = null);
+#endif

src/core/DigitalData.MessagingService.Application/Common/Dto/MailSearch/MailSearchFilter.cs

@@ -0,0 +1,80 @@
+#if NET
+namespace DigitalData.MessagingService.Application.Common.Dto.MailSearch;
+
+/// <summary>
+/// Describes all criteria and options used when searching an IMAP mailbox.
+/// </summary>
+/// <remarks>
+/// All text-match properties are <b>case-insensitive</b> substring searches performed server-side via IMAP SEARCH.
+/// Combine multiple criteria freely; an implicit AND is applied across all non-null fields.
+/// </remarks>
+public record MailSearchFilter
+{
+    /// <summary>
+    /// Mailbox folder to search. Defaults to <c>"INBOX"</c>.
+    /// </summary>
+    public string Folder { get; init; } = "INBOX";
+
+    /// <summary>
+    /// When <see langword="true"/>, only unread (UNSEEN) messages are returned.
+    /// </summary>
+    public bool UnseenOnly { get; init; } = false;
+
+    /// <summary>
+    /// When <see langword="true"/>, attachment data is included in the results; otherwise attachments are omitted.
+    /// Defaults to <see langword="false"/>.
+    /// </summary>
+    public bool WithAttachments { get; init; } = false;
+
+    /// <summary>
+    /// Maximum number of messages to retrieve. <c>0</c> means unlimited.
+    /// Applied after sorting; defaults to <c>50</c>.
+    /// </summary>
+    public int? MaxCount { get; init; } = null;
+
+    /// <summary>
+    /// Controls the order of the returned messages. Defaults to <see cref="MailSortOrder.NewestFirst"/>.
+    /// </summary>
+    public MailSortOrder SortOrder { get; init; } = MailSortOrder.NewestFirst;
+
+    // ── Text filters ───────────────────────────────────────────────────────────
+
+    /// <summary>
+    /// Case-insensitive substring the message subject must contain.
+    /// Maps to IMAP <c>SUBJECT</c>.
+    /// </summary>
+    public string? SubjectContains { get; init; } = null;
+
+    /// <summary>
+    /// Case-insensitive substring that must appear in the <c>From</c> header.
+    /// Maps to IMAP <c>FROM</c>.
+    /// </summary>
+    public string? SenderContains { get; init; } = null;
+
+    /// <summary>
+    /// Case-insensitive substring that must appear in <c>To</c> or <c>Cc</c>.
+    /// Maps to IMAP <c>TO</c>.
+    /// </summary>
+    public string? RecipientContains { get; init; } = null;
+
+    /// <summary>
+    /// Case-insensitive substring that must appear anywhere in the message body (text or HTML part).
+    /// Maps to IMAP <c>BODY</c>.
+    /// </summary>
+    public string? BodyContains { get; init; } = null;
+
+    // ── Structured filters ─────────────────────────────────────────────────────
+
+    /// <summary>
+    /// Constrains results to a specific UID or a UID range.
+    /// See <see cref="UidFilter"/> for mutual-exclusion rules between its fields.
+    /// </summary>
+    public UidFilter? Uid { get; init; } = null;
+
+    /// <summary>
+    /// Constrains results to messages received within a date range.
+    /// See <see cref="DateFilter"/> for rules between its fields.
+    /// </summary>
+    public DateFilter? Date { get; init; } = null;
+}
+#endif

src/core/DigitalData.MessagingService.Application/Common/Dto/MailSearch/MailSortOrder.cs

@@ -0,0 +1,17 @@
+namespace DigitalData.MessagingService.Application.Common.Dto.MailSearch;
+
+/// <summary>
+/// Controls the order in which fetched messages are returned.
+/// </summary>
+public enum MailSortOrder
+{
+    /// <summary>
+    /// Newest messages first (default).
+    /// </summary>
+    NewestFirst,
+
+    /// <summary>
+    /// Oldest messages first.
+    /// </summary>
+    OldestFirst
+}

src/core/DigitalData.MessagingService.Application/Common/Dto/MailSearch/UidFilter.cs

@@ -0,0 +1,16 @@
+#if NET
+namespace DigitalData.MessagingService.Application.Common.Dto.MailSearch;
+
+/// <summary>
+/// Constrains the search to a specific UID or a UID range.
+/// </summary>
+/// <remarks>
+/// Use <see cref="Absolute"/> for an exact single-message lookup.
+/// Use <see cref="Min"/> and/or <see cref="Max"/> for an open or closed range.
+/// Mixing <see cref="Absolute"/> with <see cref="Min"/> or <see cref="Max"/> is not allowed.
+/// </remarks>
+/// <param name="Min">Lower bound of the UID range (inclusive). Ignored when <see cref="Absolute"/> is set.</param>
+/// <param name="Max">Upper bound of the UID range (inclusive). Ignored when <see cref="Absolute"/> is set.</param>
+/// <param name="Absolute">Exact UID to match. When set, <see cref="Min"/> and <see cref="Max"/> must be <see langword="null"/>.</param>
+public record UidFilter(long? Min = null, long? Max = null, long? Absolute = null);
+#endif

src/core/DigitalData.MessagingService.Application/Common/Dto/ReceivedEmailDto.cs

@@ -0,0 +1,112 @@
+namespace DigitalData.MessagingService.Application.Common.Dto;
+
+/// <summary>
+/// Represents an email message received via IMAP.
+/// </summary>
+public sealed record ReceivedEmailDto
+{
+    /// <summary>
+    /// Unique identifier of the message on the IMAP server (UID).
+    /// </summary>
+#if NET
+    public long Uid { get; init; }
+#else
+    public long Uid { get; set; }
+#endif
+
+    /// <summary>
+    /// ID of the email account this message belongs to.
+    /// </summary>
+#if NET
+    public int AccountId { get; init; }
+#else
+    public int AccountId { get; set; }
+#endif
+
+    /// <summary>
+    /// Sender address (From header).
+    /// </summary>
+#if NET
+    public string From { get; init; } = string.Empty;
+#else
+    public string From { get; set; } = string.Empty;
+#endif
+
+    /// <summary>
+    /// Recipient addresses (To header).
+    /// </summary>
+#if NET
+    public IEnumerable<string> To { get; init; } = [];
+#else
+    public IEnumerable<string> To { get; set; } = [];
+#endif
+
+    /// <summary>
+    /// CC addresses.
+    /// </summary>
+#if NET
+    public IEnumerable<string> Cc { get; init; } = [];
+#else
+    public IEnumerable<string> Cc { get; set; } = [];
+#endif
+
+    /// <summary>
+    /// Email subject.
+    /// </summary>
+#if NET
+    public string Subject { get; init; } = string.Empty;
+#else
+    public string Subject { get; set; } = string.Empty;
+#endif
+
+    /// <summary>
+    /// Plain-text body (may be empty when only HTML is present).
+    /// </summary>
+#if NET
+    public string TextBody { get; init; } = string.Empty;
+#else
+    public string TextBody { get; set; } = string.Empty;
+#endif
+
+    /// <summary>
+    /// HTML body (may be empty when only plain-text is present).
+    /// </summary>
+#if NET
+    public string HtmlBody { get; init; } = string.Empty;
+#else
+    public string HtmlBody { get; set; } = string.Empty;
+#endif
+
+    /// <summary>
+    /// Date/time the message was sent (Date header).
+    /// </summary>
+#if NET
+    public DateTime Date { get; init; }
+#else
+    public DateTime Date { get; set; }
+#endif
+
+    /// <summary>
+    /// Attachments included with this message.
+    /// </summary>
+#if NET
+    public IEnumerable<EmailAttachmentDto> Attachments { get; init; } = [];
+#else
+    public IEnumerable<EmailAttachmentDto> Attachments { get; set; } = [];
+#endif
+
+    /// <summary>
+    /// Whether the message has been marked as seen/read on the server.
+    /// </summary>
+#if NET
+    public bool IsSeen { get; init; }
+#else
+    public bool IsSeen { get; set; }
+#endif
+
+#if NET
+    public required string Folder { get; init; }
+#else
+    public string Folder { get; set; } = null!;
+#endif
+}

src/core/DigitalData.MessagingService.Application/Common/Dto/SendingEmailCreateDto.cs

@@ -0,0 +1,26 @@
+namespace DigitalData.MessagingService.Application.Common.Dto;
+
+public record SendingEmailCreateDto
+{
+    /// <summary>
+    /// Recipient email address
+    /// </summary>
+    public string Recipient { get; set; } = null!;
+
+    /// <summary>
+    /// Email subject
+    /// </summary>
+    public string Subject { get; set; } = null!;
+
+    /// <summary>
+    /// Email body (HTML or plain text)
+    /// </summary>
+    public string Body { get; set; } = null!;
+
+    /// <summary>
+    /// Is HTML email (default: true)
+    /// </summary>
+    public bool IsHtml { get; set; } = true;
+
+    public DateTime QueuedAt { get; set; }
+}

src/core/DigitalData.MessagingService.Application/Common/Dto/SendingEmailEvent.cs

@@ -0,0 +1,22 @@
+namespace DigitalData.MessagingService.Application.Common.Dto;
+
+public record SendingEmailEvent
+{
+#if NETFRAMEWORK
+    public Guid Id { get; set; }
+#else
+    public required Guid Id { get; init; }
+#endif
+
+#if NETFRAMEWORK
+    public EmailContext Mail { get; set; } = null!;
+#else
+    public required EmailContext Mail { get; init; }
+#endif
+
+#if NETFRAMEWORK
+    public DateTime QueuedAt { get; set; }
+#else
+    public required DateTime QueuedAt { get; init; }
+#endif
+}

src/core/DigitalData.MessagingService.Application/Common/Interfaces/ICommandPublisher.cs

@@ -0,0 +1,19 @@
+using MediatR;
+
+namespace DigitalData.MessagingService.Application.Common.Interfaces;
+
+/// <summary>
+/// Interface for publishing commands to a message broker (e.g., RabbitMQ)
+/// </summary>
+public interface ICommandPublisher
+{
+    /// <summary>
+    /// Publishes a command to the message broker for asynchronous processing
+    /// </summary>
+    /// <typeparam name="TCommand">The command type (must implement IBaseRequest - covers both IRequest and IRequest<T>)</typeparam>
+    /// <param name="command">The command to publish</param>
+    /// <param name="cancellationToken">Cancellation token</param>
+    /// <returns>Task representing the publish operation</returns>
+    Task PublishAsync<TCommand>(TCommand command, CancellationToken cancellationToken = default) 
+        where TCommand : IBaseRequest;
+}

src/core/DigitalData.MessagingService.Application/Common/Interfaces/IEmailService.cs

@@ -0,0 +1,18 @@
+using DigitalData.MessagingService.Application.Common.Dto;
+
+namespace DigitalData.MessagingService.Application.Common.Interfaces;
+
+/// <summary>
+/// Email service interface for SMTP operations.
+/// Implementation uses Limilabs Mail.dll for production email sending.
+/// SMTP configuration is injected via IOptions&lt;EmailAccountDto&gt; in appsettings.json.
+/// Throws AuthenticationFailedException when SMTP authentication fails.
+/// </summary>
+public interface IEmailService
+{
+    /// <summary>
+    /// Sends an email using the configured SMTP account.
+    /// SMTP credentials are configured in appsettings.json (EmailAccount section).
+    /// </summary>
+    Task SendEmailAsync(EmailContext context, CancellationToken cancellationToken = default);
+}

src/core/DigitalData.MessagingService.Application/Common/Interfaces/IEncryptionService.cs

@@ -0,0 +1,10 @@
+namespace DigitalData.MessagingService.Application.Common.Interfaces;
+
+/// <summary>
+/// Encryption service interface for password encryption.
+/// </summary>
+public interface IEncryptionService
+{
+    string Encrypt(string plainText);
+    string Decrypt(string cipherText);
+}

src/core/DigitalData.MessagingService.Application/Common/Interfaces/IImapEmailService.cs

@@ -0,0 +1,41 @@
+#if NET
+using DigitalData.MessagingService.Application.Common.Dto;
+using DigitalData.MessagingService.Domain.Entities;
+
+namespace DigitalData.MessagingService.Application.Common.Interfaces;
+
+/// <summary>
+/// Service interface for reading emails via IMAP.
+/// </summary>
+public interface IImapEmailService
+{
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <param name="account"></param>
+    /// <param name="folder"></param>
+    /// <param name="cancel"></param>
+    /// <returns></returns>
+    Task<EmailSyncResult> SyncEmailsAsync(
+            EmailAccount account,
+            string folder = "INBOX",
+            CancellationToken cancel = default);
+
+    /// <summary>
+    /// Marks a message as seen (read) on the server.
+    /// </summary>
+    Task MarkAsSeenAsync(
+        EmailAccount account,
+        long uid,
+        string folder = "INBOX",
+        CancellationToken cancellationToken = default);
+
+    /// <summary>
+    /// Gets the last IMAP sync date for the specified account and folder.
+    /// </summary>
+    /// <param name="accountId"></param>
+    /// <param name="folder"></param>
+    /// <returns></returns>
+    DateTime? GetLastImapSyncDate(int accountId, string folder = "INBOX");
+}
+#endif

src/core/DigitalData.MessagingService.Application/Common/Interfaces/IPdfProcessingService.cs

@@ -0,0 +1,26 @@
+namespace DigitalData.MessagingService.Application.Common.Interfaces;
+
+/// <summary>
+/// PDF processing service interface.
+/// Operates on streams instead of file paths for flexibility.
+/// </summary>
+public interface IPdfProcessingService
+{
+    /// <summary>
+    /// Validates if the provided stream contains a valid PDF document.
+    /// Throws InvalidPdfException if the stream is not a valid PDF.
+    /// </summary>
+    Task<bool> ValidatePdfAsync(Stream pdfStream, CancellationToken cancellationToken = default);
+    
+    /// <summary>
+    /// Extracts embedded files from PDF stream to the specified output directory.
+    /// Returns a list of paths to extracted files.
+    /// </summary>
+    Task<IEnumerable<string>> ExtractEmbeddedFilesAsync(Stream pdfStream, string outputDirectory, CancellationToken cancellationToken = default);
+    
+    /// <summary>
+    /// Gets the page count of the PDF document.
+    /// Throws InvalidPdfException if the stream is not a valid PDF.
+    /// </summary>
+    Task<int> GetPageCountAsync(Stream pdfStream, CancellationToken cancellationToken = default);
+}

src/core/DigitalData.MessagingService.Application/Common/Interfaces/ISendingEmailPublisher.cs

@@ -0,0 +1,13 @@
+using DigitalData.MessagingService.Application.Common.Dto;
+
+namespace DigitalData.MessagingService.Application.Common.Interfaces;
+
+/// <summary>
+/// Email queue interface for outgoing emails.
+/// </summary>
+public interface ISendingEmailPublisher
+{
+    Task EnqueueAsync(SendingEmailEvent sendingEmailEvent, CancellationToken cancellationToken = default);
+
+    Task<int> GetQueueDepthAsync(CancellationToken cancellationToken = default);
+}

src/core/DigitalData.MessagingService.Application/Common/Interfaces/Repositories/IReceivedEmailRepository.cs

@@ -0,0 +1,11 @@
+#if NET
+using DigitalData.MessagingService.Application.Common.Dto.MailSearch;
+using DigitalData.MessagingService.Domain.Entities;
+
+namespace DigitalData.MessagingService.Application.Common.Interfaces.Repositories;
+
+public interface IReceivedEmailRepository : IRepository<ReceivedEmail>
+{
+    public Task<IEnumerable<ReceivedEmail>> FindAsync(MailSearchFilter mailSearchFilter, EmailAccount? accountQuery = null, CancellationToken cancellationToken = default);
+}
+#endif

src/core/DigitalData.MessagingService.Application/Common/Interfaces/Repositories/IRepository.cs

@@ -0,0 +1,37 @@
+using System.Linq.Expressions;
+
+namespace DigitalData.MessagingService.Application.Common.Interfaces.Repositories;
+
+/// <summary>
+/// Generic repository interface for CRUD operations.
+/// All operations auto-save changes - NO explicit SaveChangesAsync needed!
+/// </summary>
+public interface IRepository<TEntity> where TEntity : class
+{
+    // CREATE
+    Task<TEntity> CreateAsync<TDto>(TDto dto, CancellationToken cancellationToken = default);
+
+    Task<IEnumerable<TEntity>> CreateRangeAsync<TDto>(IEnumerable<TDto> dtos, CancellationToken cancellationToken = default);
+
+    // READ
+    Task<TEntity?> GetByIdAsync(int id, CancellationToken cancellationToken = default);
+    Task<IEnumerable<TEntity>> GetAllAsync(CancellationToken cancellationToken = default);
+    Task<IEnumerable<TEntity>> FindAsync(Expression<Func<TEntity, bool>> predicate, int? skip = null, int? take = null, CancellationToken cancellationToken = default);
+    Task<TEntity?> FindFirstAsync(Expression<Func<TEntity, bool>> predicate, CancellationToken cancellationToken = default);
+    Task<TEntity?> FindSingleAsync(Expression<Func<TEntity, bool>> predicate, CancellationToken cancellationToken = default);
+    Task<int> CountAsync(Expression<Func<TEntity, bool>>? predicate = null, CancellationToken cancellationToken = default);
+    Task<bool> AnyAsync(Expression<Func<TEntity, bool>> predicate, CancellationToken cancellationToken = default);
+
+    // UPSERT
+    Task<(TEntity Entity, bool Created)> UpsertAsync<TDto>(Expression<Func<TEntity, bool>> predicate, TDto dto, CancellationToken cancellationToken = default);
+    
+    Task<(TEntity Entity, bool Created)> UpsertSingleAsync<TDto>(Expression<Func<TEntity, bool>> predicate, TDto dto, CancellationToken cancellationToken = default);
+
+    // UPDATE
+    Task UpdateSingleAsync<TDto>(Expression<Func<TEntity, bool>> predicate, TDto dto, CancellationToken cancellationToken = default);
+    Task<int> UpdateAsync<TDto>(Expression<Func<TEntity, bool>> predicate, TDto dto, CancellationToken cancellationToken = default);
+
+    // DELETE
+    Task DeleteSingleAsync(Expression<Func<TEntity, bool>> predicate, CancellationToken cancellationToken = default);
+    Task<int> DeleteAsync(Expression<Func<TEntity, bool>> predicate, CancellationToken cancellationToken = default);
+}

src/core/DigitalData.MessagingService.Application/Common/Mappings/EmailMappingProfile.cs

@@ -0,0 +1,41 @@
+#if NET
+using AutoMapper;
+using DigitalData.MessagingService.Application.EmailSending.Commands;
+using DigitalData.MessagingService.Application.Common.Dto;
+using DigitalData.MessagingService.Domain.Entities;
+using DigitalData.MessagingService.Application.Common.Dto.EmailAccounts;
+
+namespace DigitalData.MessagingService.Application.Common.Mappings;
+
+/// <summary>
+/// AutoMapper profile for Emails
+/// </summary>
+public class EmailMappingProfile : Profile
+{
+    public EmailMappingProfile()
+    {
+        // PublishEmailCommand -> Email
+        // Sender is resolved via MediatR in the handler and set separately after mapping.
+        CreateMap<PublishEmailCommand, EmailContext>()
+            .ForMember(dest => dest.Sender, opt => opt.Ignore())
+            .ForMember(dest => dest.Attachments, opt => opt.MapFrom(src => src.Attachments));
+
+        // EmailAccountDto -> EmailAccount
+        CreateMap<EmailAccount, EmailAccountDto>();
+        CreateMap<EmailAccountModificationDto, EmailAccount>();
+
+        // ReceivedEmailDto <-> ReceivedEmail
+        CreateMap<ReceivedEmailDto, ReceivedEmail>()
+            .ForMember(dest => dest.Id, opt => opt.Ignore())
+            .ForMember(dest => dest.Account, opt => opt.Ignore());
+        CreateMap<ReceivedEmail, ReceivedEmailDto>();
+
+        // EmailAttachmentDto <-> EmailAttachment
+        CreateMap<EmailAttachmentDto, EmailAttachment>()
+            .ForMember(dest => dest.Id, opt => opt.Ignore())
+            .ForMember(dest => dest.EmailId, opt => opt.Ignore())
+            .ForMember(dest => dest.Email, opt => opt.Ignore());
+        CreateMap<EmailAttachment, EmailAttachmentDto>();
+    }
+}
+#endif

src/core/DigitalData.MessagingService.Application/Common/Options/EmailAccountsOptions.cs

@@ -0,0 +1,28 @@
+#if NET
+using DigitalData.MessagingService.Application.Common.Dto;
+using DigitalData.MessagingService.Application.Common.Dto.EmailAccounts;
+using DigitalData.MessagingService.Application.EmailAccounts.Commands;
+using DigitalData.MessagingService.Domain.Entities;
+
+namespace DigitalData.MessagingService.Application.Common.Options;
+
+/// <summary>
+/// Wrapper options class that holds a list of <see cref="Dto.EmailAccount"/> entries
+/// bound from the <c>EmailAccounts</c> configuration section.
+/// </summary>
+public class EmailAccountsOptions
+{
+    public const string SectionName = "EmailAccounts";
+
+    /// <summary>
+    /// The list of configured email accounts.
+    /// </summary>
+    public required IEnumerable<EmailAccountModificationDto> Accounts { get; init; } = [];
+
+    /// <summary>
+    /// How often the IMAP sync worker polls for new emails, in seconds.
+    /// Defaults to 300 seconds (5 minutes).
+    /// </summary>
+    public int SyncIntervalSeconds { get; init; } = 300;
+}
+#endif

src/core/DigitalData.MessagingService.Application/Common/ValueObjects/Modification.cs

@@ -0,0 +1,6 @@
+namespace DigitalData.MessagingService.Application.Common.ValueObjects;
+
+public enum Modification
+{
+    Upsert
+}

src/core/DigitalData.MessagingService.Application/DependencyInjection.cs

@@ -0,0 +1,46 @@
+#if NET
+using DigitalData.MessagingService.Application.Common.Options;
+using FluentValidation;
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.DependencyInjection;
+using System.Reflection;
+
+namespace DigitalData.MessagingService.Application;
+
+/// <summary>
+/// Dependency injection configuration for Application layer.
+/// </summary>
+public static class DependencyInjection
+{
+    public static IServiceCollection AddApplicationServices(this IServiceCollection services, IConfiguration configuration)
+    {
+        var assembly = Assembly.GetExecutingAssembly();
+
+        // Read LuckyPennySoft license key from appsettings.json
+        var licenseKey = configuration.GetValue<string>("LuckyPennySoftLicenseKey")
+            ?? throw new InvalidOperationException("LuckyPennySoftLicenseKey not found in configuration");
+
+        // MediatR - Register all handlers
+        services.AddMediatR(config =>
+        {
+            config.LicenseKey = licenseKey;
+            config.RegisterServicesFromAssembly(assembly);
+        });
+
+        // AutoMapper - Use built-in DI extension (AutoMapper 16.2.0+)
+        services.AddAutoMapper(config =>
+        {
+            config.LicenseKey = licenseKey;
+            config.AddMaps(assembly);
+        });
+
+        // FluentValidation - Register all validators
+        services.AddValidatorsFromAssembly(assembly);
+
+        // Register EmailAccounts configuration (IOptions<EmailAccountsOptions>)
+        services.Configure<EmailAccountsOptions>(configuration.GetSection(EmailAccountsOptions.SectionName));
+
+        return services;
+    }
+}
+#endif

src/core/DigitalData.MessagingService.Application/DigitalData.MessagingService.Application.csproj

@@ -0,0 +1,23 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+	  <TargetFrameworks>net462;net480;net8.0</TargetFrameworks>
+	  <ImplicitUsings>enable</ImplicitUsings>
+	  <Nullable>enable</Nullable>
+	  <LangVersion>latest</LangVersion>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\DigitalData.MessagingService.Domain\DigitalData.MessagingService.Domain.csproj" />
+  </ItemGroup>
+
+  <ItemGroup Condition="'$(TargetFramework)' == 'net8.0'">
+    <PackageReference Include="AutoMapper" Version="16.2.0" />
+    <PackageReference Include="FluentValidation.DependencyInjectionExtensions" Version="12.1.1" />
+    <PackageReference Include="MediatR" Version="14.2.0" />
+    <PackageReference Include="Microsoft.Extensions.Configuration.Abstractions" Version="10.0.10" />
+    <PackageReference Include="Microsoft.Extensions.Configuration.Binder" Version="10.0.10" />
+    <PackageReference Include="Microsoft.Extensions.Options.ConfigurationExtensions" Version="8.0.0" />
+  </ItemGroup>
+
+</Project>

src/core/DigitalData.MessagingService.Application/EmailAccounts/Commands/EmailAccountModificationCommand.cs

@@ -0,0 +1,36 @@
+#if NET
+using DigitalData.MessagingService.Application.Common.Dto.EmailAccounts;
+using DigitalData.MessagingService.Application.Common.Interfaces.Repositories;
+using DigitalData.MessagingService.Application.Common.ValueObjects;
+using DigitalData.MessagingService.Domain.Entities;
+using MediatR;
+using System.Security.Principal;
+
+namespace DigitalData.MessagingService.Application.EmailAccounts.Commands;
+
+/// <summary>
+/// DTO for a single email account configuration.
+/// </summary>
+public record EmailAccountModificationCommand : IRequest<(EmailAccount, bool)>
+{
+    public required EmailAccountModificationDto ModifiedAccount { get; init; }
+
+    public required Modification Modification { get; init; }
+}
+
+/// <summary>
+/// 
+/// </summary>
+/// <param name="Repo"></param>
+public class EmailAccountModificationCommandHandler(IRepository<EmailAccount> Repo) : IRequestHandler<EmailAccountModificationCommand, (EmailAccount, bool)>
+{
+    public async Task<(EmailAccount, bool)> Handle(EmailAccountModificationCommand request, CancellationToken cancellationToken)
+    {
+        return request.Modification switch
+        {
+            Modification.Upsert => await Repo.UpsertAsync(a => a.Username == request.ModifiedAccount.Username, request.ModifiedAccount, cancellationToken),
+            _ => throw new NotSupportedException($"Modification type '{request.Modification}' is not supported in email account modification."),
+        };
+    }
+}
+#endif

src/core/DigitalData.MessagingService.Application/EmailAccounts/Queries/GetEmailAccountQuery.cs

@@ -0,0 +1,37 @@
+#if NET
+using MediatR;
+using DigitalData.MessagingService.Domain.Entities;
+using DigitalData.MessagingService.Application.Common.Interfaces.Repositories;
+using AutoMapper;
+using DigitalData.MessagingService.Domain.Exceptions;
+using DigitalData.MessagingService.Application.Common.Dto.EmailAccounts;
+
+namespace DigitalData.MessagingService.Application.EmailAccounts.Queries;
+
+public record GetEmailAccountQuery : IRequest<IEnumerable<EmailAccountDto>>
+{
+    public int? Id { get; init; }
+
+    public string? Username { get; init; }
+}
+
+/// <summary>
+/// Handles queries for retrieving email accounts.
+/// </summary>
+/// <param name="Repo"></param>
+/// <param name="Mapper"></param>
+public class GetEmailAccountQueryHandler(IRepository<EmailAccount> Repo, IMapper Mapper) : IRequestHandler<GetEmailAccountQuery, IEnumerable<EmailAccountDto>>
+{
+    public async Task<IEnumerable<EmailAccountDto>> Handle(GetEmailAccountQuery request, CancellationToken cancellationToken)
+    {
+        var accounts = request.Id is null && request.Username is null 
+            ? await Repo.GetAllAsync(cancellationToken) 
+            : await Repo.FindAsync(request.Id is int id ? x => x.Id == id : x => x.Username == request.Username, cancellationToken: cancellationToken);
+
+        if (accounts.Any())
+            return Mapper.Map<IEnumerable<EmailAccountDto>>(accounts);
+        else
+            throw new NotFoundException($"No email account found for the given criteria ({(request.Id is not null ? $"Id: {request.Id}" : $"Username: {request.Username}")}).");
+    }
+}
+#endif

src/core/DigitalData.MessagingService.Application/EmailAccounts/Validators/GetSenderQueryValidator.cs

@@ -0,0 +1,25 @@
+#if NET
+using DigitalData.MessagingService.Application.EmailAccounts.Queries;
+using FluentValidation;
+
+namespace DigitalData.MessagingService.Application.EmailAccounts.Validators;
+
+/// <summary>
+/// Validator for <see cref="GetEmailAccountQuery"/>.
+/// Either <see cref="GetEmailAccountQuery.Id"/> or <see cref="GetEmailAccountQuery.Username"/> must be provided, but not both.
+/// </summary>
+public class GetSenderQueryValidator : AbstractValidator<GetEmailAccountQuery>
+{
+    public GetSenderQueryValidator()
+    {
+        When(x => x.Username is not null, () =>
+        {
+            RuleFor(x => x.Username)
+                .NotEmpty()
+                .WithMessage("Username must not be empty.")
+                .MaximumLength(200)
+                .WithMessage("Username must not exceed 200 characters.");
+        });
+    }
+}
+#endif

src/core/DigitalData.MessagingService.Application/EmailReceiving/Commands/MarkEmailAsSeenCommand.cs

@@ -0,0 +1,48 @@
+#if NET
+using DigitalData.MessagingService.Application.Common.Interfaces;
+using DigitalData.MessagingService.Application.Common.Interfaces.Repositories;
+using DigitalData.MessagingService.Application.EmailAccounts.Queries;
+using DigitalData.MessagingService.Domain.Entities;
+using DigitalData.MessagingService.Domain.Exceptions;
+using MediatR;
+using Microsoft.Extensions.Logging;
+
+namespace DigitalData.MessagingService.Application.EmailReceiving.Commands;
+
+/// <summary>
+/// Command to mark a single IMAP message as seen (read).
+/// </summary>
+public record MarkEmailAsSeenCommand : IRequest
+{
+    public required GetEmailAccountQuery Account { get; init; }
+
+    /// <summary>
+    /// UID of the message to mark as seen.
+    /// </summary>
+    public required long Uid { get; init; }
+
+    /// <summary>
+    /// Mailbox folder the message resides in (default: "INBOX").
+    /// </summary>
+    public string Folder { get; init; } = "INBOX";
+}
+
+public class MarkEmailAsSeenCommandHandler(IImapEmailService ImapService, ILogger<MarkEmailAsSeenCommandHandler> Logger, IRepository<EmailAccount> Repo) : IRequestHandler<MarkEmailAsSeenCommand>
+{
+    public async Task Handle(MarkEmailAsSeenCommand request, CancellationToken cancellationToken)
+    {
+        var accounts = await Repo.FindAsync(request.Account.Id is int id ? x => x.Id == id : x => x.Username == request.Account.Username, cancellationToken: cancellationToken);
+
+        if (accounts.Count() > 1)
+            Logger.LogWarning("Multiple email accounts found for the given criteria ({Criteria}). Returning the first one.", request.Account.Id is not null ? $"Id: {request.Account.Id}" : $"Username: {request.Account.Username}");
+
+        var account = accounts.FirstOrDefault()
+            ?? throw new NotFoundException($"No email account found for the given criteria (Id: {request.Account.Id}, Username: {request.Account.Username}).");
+
+        if (string.IsNullOrWhiteSpace(account.ImapServer))
+            throw new BadRequestException($"IMAP is not configured for account '{account.Username}' (Id: {account.Id}). Set ImapServer in EmailAccounts configuration.");
+
+        await ImapService.MarkAsSeenAsync(account, request.Uid, request.Folder, cancellationToken);
+    }
+}
+#endif

src/core/DigitalData.MessagingService.Application/EmailReceiving/Queries/ReadEmailQuery.cs

@@ -0,0 +1,51 @@
+#if NET
+using AutoMapper;
+using DigitalData.MessagingService.Application.Common.Dto;
+using DigitalData.MessagingService.Application.Common.Dto.MailSearch;
+using DigitalData.MessagingService.Application.Common.Interfaces;
+using DigitalData.MessagingService.Application.Common.Interfaces.Repositories;
+using DigitalData.MessagingService.Application.EmailAccounts.Queries;
+using DigitalData.MessagingService.Domain.Entities;
+using DigitalData.MessagingService.Domain.Exceptions;
+using MediatR;
+using Microsoft.Extensions.Logging;
+
+namespace DigitalData.MessagingService.Application.EmailReceiving.Queries;
+
+/// <summary>
+/// Query to fetch emails from an IMAP mailbox.
+/// </summary>
+public record ReadEmailQuery : IRequest<IEnumerable<ReceivedEmailDto>>
+{
+    /// <summary>
+    /// Identifies the email account to use.
+    /// </summary>
+    public required GetEmailAccountQuery Account { get; init; }
+
+    /// <summary>
+    /// Mail query used to filter and limit the emails retrieved.
+    /// </summary>
+    public MailSearchFilter Mail { get; init; } = new();
+}
+
+public class ReadEmailQueryHandler(IMapper Mapper, ILogger<ReadEmailQueryHandler> Logger, IRepository<EmailAccount> EmailAccountRepo, IReceivedEmailRepository MailRepo) : IRequestHandler<ReadEmailQuery, IEnumerable<ReceivedEmailDto>>
+{
+    public async Task<IEnumerable<ReceivedEmailDto>> Handle(ReadEmailQuery request, CancellationToken cancellationToken)
+    {
+        var accounts = await EmailAccountRepo.FindAsync(request.Account.Id is int id ? x => x.Id == id : x => x.Username == request.Account.Username, cancellationToken: cancellationToken);
+
+        if (accounts.Count() > 1)
+            Logger.LogWarning("Multiple email accounts found for the given criteria ({Criteria}). Returning the first one.", request.Account.Id is not null ? $"Id: {request.Account.Id}" : $"Username: {request.Account.Username}");
+
+        var account = accounts.FirstOrDefault()
+            ?? throw new NotFoundException($"No email account found for the given criteria (Id: {request.Account.Id}, Username: {request.Account.Username}).");
+
+        if (string.IsNullOrWhiteSpace(account.ImapServer))
+            throw new BadRequestException(
+                $"IMAP is not configured for account '{account.Username}' (Id: {account.Id}). Set ImapServer in EmailAccounts configuration.");
+
+        var mails = await MailRepo.FindAsync(request.Mail, account, cancellationToken);
+        return Mapper.Map<IEnumerable<ReceivedEmailDto>>(mails);
+    }
+}
+#endif

src/core/DigitalData.MessagingService.Application/EmailReceiving/Validators/DateFilterValidator.cs

@@ -0,0 +1,39 @@
+#if NET
+using DigitalData.MessagingService.Application.Common.Dto.MailSearch;
+using FluentValidation;
+
+namespace DigitalData.MessagingService.Application.EmailReceiving.Validators;
+
+/// <summary>
+/// Validates a <see cref="DateFilter"/> value object.
+/// </summary>
+public class DateFilterValidator : AbstractValidator<DateFilter>
+{
+    public DateFilterValidator()
+    {
+        // At least one field must be provided
+        RuleFor(x => x)
+            .Must(d => d.After is not null || d.Before is not null)
+            .WithName("Date")
+            .WithMessage("DateFilter must specify at least one of: After or Before.");
+
+        // Dates must not be in the future
+        RuleFor(x => x.After)
+            .LessThanOrEqualTo(DateTime.UtcNow)
+            .WithMessage("Date.After must not be in the future.")
+            .When(x => x.After is not null);
+
+        RuleFor(x => x.Before)
+            .LessThanOrEqualTo(DateTime.UtcNow)
+            .WithMessage("Date.Before must not be in the future.")
+            .When(x => x.Before is not null);
+
+        // Range coherence: After must be earlier than Before
+        RuleFor(x => x)
+            .Must(d => d.After!.Value < d.Before!.Value)
+            .WithName("Date.Range")
+            .WithMessage("Date.After must be earlier than Date.Before.")
+            .When(x => x.After is not null && x.Before is not null);
+    }
+}
+#endif

src/core/DigitalData.MessagingService.Application/EmailReceiving/Validators/FetchEmailsQueryValidator.cs

@@ -0,0 +1,24 @@
+#if NET
+using DigitalData.MessagingService.Application.EmailReceiving.Queries;
+using FluentValidation;
+
+namespace DigitalData.MessagingService.Application.EmailReceiving.Validators;
+
+/// <summary>
+/// Validates a <see cref="ReadEmailQuery"/> before it is handled by <see cref="ReadEmailQueryHandler"/>.
+/// </summary>
+public class FetchEmailsQueryValidator : AbstractValidator<ReadEmailQuery>
+{
+    public FetchEmailsQueryValidator()
+    {
+        RuleFor(x => x.Account)
+            .NotNull()
+            .WithMessage("Account query must not be null.");
+
+        RuleFor(x => x.Mail)
+            .NotNull()
+            .WithMessage("Mail search filter must not be null.")
+            .SetValidator(new MailSearchFilterValidator());
+    }
+}
+#endif

src/core/DigitalData.MessagingService.Application/EmailReceiving/Validators/MailSearchFilterValidator.cs

@@ -0,0 +1,53 @@
+#if NET
+using DigitalData.MessagingService.Application.Common.Dto.MailSearch;
+using FluentValidation;
+
+namespace DigitalData.MessagingService.Application.EmailReceiving.Validators;
+
+/// <summary>
+/// Validates a <see cref="MailSearchFilter"/> instance before it is dispatched to the IMAP service.
+/// </summary>
+public class MailSearchFilterValidator : AbstractValidator<MailSearchFilter>
+{
+    public MailSearchFilterValidator()
+    {
+        RuleFor(x => x.Folder)
+            .NotEmpty()
+            .WithMessage("Folder must not be empty.")
+            .MaximumLength(255)
+            .WithMessage("Folder name must not exceed 255 characters.");
+
+        RuleFor(x => x.MaxCount)
+            .GreaterThanOrEqualTo(0)
+            .WithMessage("MaxCount must be 0 (unlimited) or a positive number.");
+
+        RuleFor(x => x.SubjectContains)
+            .MaximumLength(500)
+            .WithMessage("SubjectContains must not exceed 500 characters.")
+            .When(x => x.SubjectContains is not null);
+
+        RuleFor(x => x.SenderContains)
+            .MaximumLength(320)
+            .WithMessage("SenderContains must not exceed 320 characters.")
+            .When(x => x.SenderContains is not null);
+
+        RuleFor(x => x.RecipientContains)
+            .MaximumLength(320)
+            .WithMessage("RecipientContains must not exceed 320 characters.")
+            .When(x => x.RecipientContains is not null);
+
+        RuleFor(x => x.BodyContains)
+            .MaximumLength(1000)
+            .WithMessage("BodyContains must not exceed 1000 characters.")
+            .When(x => x.BodyContains is not null);
+
+        RuleFor(x => x.Uid)
+            .SetValidator(new UidFilterValidator()!)
+            .When(x => x.Uid is not null);
+
+        RuleFor(x => x.Date)
+            .SetValidator(new DateFilterValidator()!)
+            .When(x => x.Date is not null);
+    }
+}
+#endif

src/core/DigitalData.MessagingService.Application/EmailReceiving/Validators/UidFilterValidator.cs

@@ -0,0 +1,50 @@
+#if NET
+using DigitalData.MessagingService.Application.Common.Dto.MailSearch;
+using FluentValidation;
+
+namespace DigitalData.MessagingService.Application.EmailReceiving.Validators;
+
+/// <summary>
+/// Validates a <see cref="UidFilter"/> value object.
+/// </summary>
+public class UidFilterValidator : AbstractValidator<UidFilter>
+{
+    public UidFilterValidator()
+    {
+        // Absolute and range are mutually exclusive
+        RuleFor(x => x)
+            .Must(u => u.Absolute is null || (u.Min is null && u.Max is null))
+            .WithName("Uid.Absolute")
+            .WithMessage("Uid.Absolute cannot be combined with Uid.Min or Uid.Max. Use either an exact UID or a range.");
+
+        // At least one field must be provided
+        RuleFor(x => x)
+            .Must(u => u.Absolute is not null || u.Min is not null || u.Max is not null)
+            .WithName("Uid")
+            .WithMessage("UidFilter must specify at least one of: Absolute, Min, or Max.");
+
+        // All UID values must be positive
+        RuleFor(x => x.Absolute)
+            .GreaterThan(0)
+            .WithMessage("Uid.Absolute must be a positive number.")
+            .When(x => x.Absolute is not null);
+
+        RuleFor(x => x.Min)
+            .GreaterThan(0)
+            .WithMessage("Uid.Min must be a positive number.")
+            .When(x => x.Min is not null);
+
+        RuleFor(x => x.Max)
+            .GreaterThan(0)
+            .WithMessage("Uid.Max must be a positive number.")
+            .When(x => x.Max is not null);
+
+        // Range coherence: Min must be less than or equal to Max
+        RuleFor(x => x)
+            .Must(u => u.Min!.Value <= u.Max!.Value)
+            .WithName("Uid.Range")
+            .WithMessage("Uid.Min must be less than or equal to Uid.Max.")
+            .When(x => x.Min is not null && x.Max is not null);
+    }
+}
+#endif

src/core/DigitalData.MessagingService.Application/EmailSending/Commands/PublishEmailCommand.cs

@@ -0,0 +1,82 @@
+#if NET
+using AutoMapper;
+using DigitalData.MessagingService.Application.Common.Dto;
+using DigitalData.MessagingService.Application.Common.Interfaces;
+using DigitalData.MessagingService.Application.Common.Interfaces.Repositories;
+using DigitalData.MessagingService.Application.EmailAccounts.Queries;
+using DigitalData.MessagingService.Domain.Entities;
+using DigitalData.MessagingService.Domain.Exceptions;
+using MediatR;
+using Microsoft.Extensions.Logging;
+using System.Text.Json.Serialization;
+
+namespace DigitalData.MessagingService.Application.EmailSending.Commands;
+
+/// <summary>
+/// Command to send an email (enqueue to RabbitMQ)
+/// </summary>
+public record PublishEmailCommand : IRequest<Guid>
+{
+    public required GetEmailAccountQuery Sender { get; init; }
+
+    /// <summary>
+    /// Recipient email addresses
+    /// </summary>
+    public required IEnumerable<string> Recipients { get; init; }
+
+    /// <summary>
+    /// Email subject
+    /// </summary>
+    public required string Subject { get; init; }
+
+    /// <summary>
+    /// Email body (HTML or plain text)
+    /// </summary>
+    public required string Body { get; init; }
+
+    /// <summary>
+    /// Is HTML email (default: true)
+    /// </summary>
+    public bool IsHtml { get; init; } = true;
+
+    [JsonIgnore]
+    internal IEnumerable<EmailAttachmentDto> Attachments { get; private init; } = [];
+
+    /// <summary>
+    /// Returns a new command instance with the supplied attachments.
+    /// Called by the controller after resolving uploaded files.
+    /// </summary>
+    public PublishEmailCommand WithAttachments(IEnumerable<EmailAttachmentDto> attachments)
+        => this with { Attachments = attachments };
+}
+
+/// <summary>
+/// Handler for PublishEmailCommand
+/// Resolves the sender account via MediatR, maps to SendingEmailEvent and enqueues to RabbitMQ
+/// </summary>
+public class PublishEmailCommandHandler(IRepository<EmailAccount> Repo, ISendingEmailPublisher Publisher, IMapper Mapper, ILogger<PublishEmailCommandHandler> Logger) : IRequestHandler<PublishEmailCommand, Guid>
+{
+    public async Task<Guid> Handle(PublishEmailCommand request, CancellationToken cancellationToken)
+    {
+        var senderAccounts = await Repo.FindAsync(request.Sender.Id is int id ? x => x.Id == id : x => x.Username == request.Sender.Username, cancellationToken: cancellationToken);
+
+        if (senderAccounts.Count() > 1)
+            Logger.LogWarning("Multiple email accounts found for the given criteria ({Criteria}). Returning the first one.", request.Sender.Id is not null ? $"Id: {request.Sender.Id}" : $"Username: {request.Sender.Username}");
+
+        var senderAccount = senderAccounts.FirstOrDefault()
+            ?? throw new NotFoundException($"No email account found for the given sender criteria (Id: {request.Sender.Id}, Username: {request.Sender.Username}).");
+
+        var email = Mapper.Map<EmailContext>(request) with { Sender = senderAccount };
+
+        // Enqueue to RabbitMQ
+        var sendingEmailEvent = new SendingEmailEvent()
+        {
+            Id = Guid.NewGuid(),
+            Mail = email,
+            QueuedAt = DateTime.Now
+        };
+        await Publisher.EnqueueAsync(sendingEmailEvent, cancellationToken);
+        return sendingEmailEvent.Id;
+    }
+}
+#endif

src/core/DigitalData.MessagingService.Application/EmailSending/Validators/SendEmailCommandValidator.cs

@@ -0,0 +1,36 @@
+#if NET
+using DigitalData.MessagingService.Application.EmailSending.Commands;
+using FluentValidation;
+
+namespace DigitalData.MessagingService.Application.EmailSending.Validators;
+
+/// <summary>
+/// Validator for PublishEmailCommand
+/// </summary>
+public class PublishEmailCommandValidator : AbstractValidator<PublishEmailCommand>
+{
+    public PublishEmailCommandValidator()
+    {
+        RuleFor(x => x.Recipients)
+            .NotEmpty()
+            .WithMessage("Recipients are required")
+            .Must(x => x.Any())
+            .WithMessage("At least one recipient is required")
+            .ForEach(recipient => recipient
+                .NotEmpty()
+                .WithMessage("Recipient email must not be empty")
+                .EmailAddress()
+                .WithMessage("Invalid email address format"));
+
+        RuleFor(x => x.Subject)
+            .NotEmpty()
+            .WithMessage("Subject is required")
+            .MaximumLength(500)
+            .WithMessage("Subject must not exceed 500 characters");
+
+        RuleFor(x => x.Body)
+            .NotEmpty()
+            .WithMessage("Body is required");
+    }
+}
+#endif

src/core/DigitalData.MessagingService.Domain/DigitalData.MessagingService.Domain.csproj

@@ -1,13 +1,18 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFramework>net8.0</TargetFramework>
+	<TargetFrameworks>net462;net8.0</TargetFrameworks>
     <ImplicitUsings>enable</ImplicitUsings>
     <Nullable>enable</Nullable>
+    <LangVersion>latest</LangVersion>
   </PropertyGroup>
 
   <ItemGroup>
     <PackageReference Include="MediatR" Version="12.2.0" />
   </ItemGroup>
 
+  <ItemGroup Condition="'$(TargetFramework)' == 'net462'">
+    <Reference Include="System.ComponentModel.DataAnnotations" />
+  </ItemGroup>
+
 </Project>