refactor(api): inject IEmailSyncService into SyncController; change OAuth2 authorize route to username param; add Swagger UI metadata and description links

Updated ReadEmailQuery to return a new response type,
ReadEmailQueryResponse, which includes both email data
and metadata (e.g., LastSync). Added the Account property
to ReadEmailQuery for specifying the email account.

Refactored ReadEmailQueryHandler to:
- Use IImapEmailService to fetch LastSync metadata.
- Return ReadEmailQueryResponse instead of a collection
  of ReceivedEmailDto.

Introduced ReadEmailQueryResponse class to encapsulate
LastSync and Emails properties.

Updated EmailController to handle the new response
structure, ensuring compatibility with the updated
ReadEmailQuery and its handler.

.gitignore

@@ -370,3 +370,7 @@ 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
+/src/presentation/DigitalData.MessagingService.API/oauth.htek0100@gmail.com.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,60 +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
-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.MessagingService.Domain.Entities;
-using DigitalData.EmailProfiler.Application.Common.Dtos;
+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.MessagingService.Domain.Entities;
-using DigitalData.EmailProfiler.Application.Interfaces.Repositories;
+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.MessagingService.Infrastructure.Persistence;
-using DigitalData.EmailProfiler.Application.Interfaces.Repositories;
+using DigitalData.MessagingService.Application.Interfaces.Repositories;
-using DigitalData.EmailProfiler.Infrastructure.Persistence.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.MessagingService.API;
-using DigitalData.EmailProfiler.Application;
+using DigitalData.MessagingService.Application;
-using DigitalData.EmailProfiler.Infrastructure;
+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.MessagingService.Application.EmailProfiles.Commands;
-using DigitalData.EmailProfiler.Application.EmailProfiles.Queries;
+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
+cd src/DigitalData.MessagingService.Infrastructure
-dotnet ef migrations add InitialCreate --startup-project ../DigitalData.EmailProfiler.API
+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,302 @@
-# DigitalData.EmailProfiler
+# DigitalData.MessagingService
+
+A .NET 8 messaging service for sending and receiving emails via SMTP, IMAP, POP3 and OAuth2, with RabbitMQ-based async delivery.
+
+---
+
+## Email Account Configuration
+
+Each account is configured under `EmailAccounts.Accounts` in `appsettings.Secrets.json`.
+
+> Different providers require different configuration fields. See provider-specific sections below.
+
+### Common fields (all providers)
+
+```json
+{
+  "Id": 1,
+  "Username": "user@example.com",
+  "Password": "your_password",
+  "SmtpServer": "smtp.example.com",
+  "SmtpPort": 465,
+  "SmtpUseSsl": true,
+  "UseOAuth2": false,
+  "ImapServer": "imap.example.com",
+  "ImapPort": 993,
+  "ImapUseSsl": true,
+  "Pop3Server": "pop.example.com",
+  "Pop3Port": 995,
+  "Pop3UseSsl": true,
+  "IncomingProtocol": 1
+}
+```
+
+> `Password` is always retained. When `UseOAuth2 = true`, SMTP/IMAP/POP3 connections use OAuth2 tokens
+> instead of the password. When `UseOAuth2 = false`, the password is used directly.
+> The `IncomingProtocol` field independently controls which protocol is used for receiving emails.
+
+#### `IncomingProtocol` values
+
+| Value | Meaning |
+|-------|---------|
+| `0`   | None — send-only account, skipped by sync worker |
+| `1`   | IMAP with username/password |
+| `2`   | POP3 with username/password |
+| `3`   | IMAP with OAuth2 |
+| `4`   | POP3 with OAuth2 |
+
+#### `OAuth2Provider` values
+
+| Value | Meaning |
+|-------|---------|
+| `0`   | None |
+| `1`   | Microsoft (Azure AD / Microsoft 365) |
+| `2`   | Google (Gmail / Google Workspace) |
+
+---
+
+## Provider-specific OAuth2 Configuration
+
+### Google (Gmail / Google Workspace)
+
+Google uses **user-delegated OAuth2** (authorization code flow). A one-time interactive authorization
+is required to obtain a refresh token. The refresh token is then stored in the database and reused
+automatically for all subsequent operations.
+
+> The refresh token survives application restarts. It will not be overwritten by the seed process
+> unless `OAuth2RefreshToken` is explicitly set to a non-empty value in `appsettings.Secrets.json`.
+
+#### Required fields
+
+```json
+{
+  "UseOAuth2": true,
+  "OAuth2ClientId": "YOUR_CLIENT_ID.apps.googleusercontent.com",
+  "OAuth2ClientSecret": "GOCSPX-YOUR_CLIENT_SECRET",
+  "OAuth2RefreshToken": "",
+  "OAuth2TenantId": "",
+  "OAuth2Provider": 2
+}
+```
+
+#### Google Cloud Console setup (one-time)
+
+1. Go to [console.cloud.google.com](https://console.cloud.google.com) and create or select a project.
+2. Enable the **Gmail API** under *APIs & Services ? Library*.
+3. Go to *APIs & Services ? Credentials* ? **+ Create Credentials** ? **OAuth 2.0 Client ID**:
+   - Application type: **Web application**
+   - **Authorized redirect URIs**: add `https://YOUR_HOST/api/oauth2/google/callback`
+     (e.g. `https://localhost:7261/api/oauth2/google/callback` for local development)
+4. Go to *APIs & Services ? OAuth consent screen*:
+   - Add the Gmail account under **Test users** (required while app is in Testing mode).
+
+#### Obtaining the refresh token via the built-in authorization endpoint
+
+The application provides a built-in OAuth2 flow — no external tools needed.
+
+1. Open a browser and navigate to:
+   ```
+   GET /api/oauth2/google/authorize/{accountId}
+   ```
+   Example: `https://localhost:7261/api/oauth2/google/authorize/3`
+
+2. You will be redirected to Google's consent screen. If you see **"Google hasn't verified this app"**,
+   click **Continue** — this is expected while the app is in Testing mode.
+
+3. Sign in with the Gmail account and grant access.
+
+4. Google redirects back to `/api/oauth2/google/callback` automatically.
+   The application exchanges the authorization code for a refresh token and saves it to the database.
+
+5. A success response is returned:
+   ```json
+   { "success": true, "username": "user@gmail.com", "message": "..." }
+   ```
+
+6. The sync worker and all IMAP/SMTP operations will now work automatically.
+
+> ?? The refresh token must be re-obtained if `invalid_grant` is returned.
+> This happens if the token is unused for 6 months or if the user revokes access.
+
+---
+
+### Microsoft 365 / Exchange Online (Azure AD)
+
+Microsoft uses **application-level OAuth2** (client credentials flow — no user interaction required).
+Tokens are acquired automatically using the client ID, secret and tenant ID. No authorization endpoint
+needs to be visited.
+
+#### Required fields
+
+```json
+{
+  "UseOAuth2": true,
+  "OAuth2ClientId": "YOUR_APP_CLIENT_ID",
+  "OAuth2ClientSecret": "YOUR_APP_CLIENT_SECRET_VALUE",
+  "OAuth2TenantId": "yourorg.onmicrosoft.com",
+  "OAuth2Provider": 1
+}
+```
+
+#### Azure Portal setup (one-time)
+
+1. Go to [portal.azure.com](https://portal.azure.com) ? **Azure Active Directory** ? **App registrations** ? **+ New registration**.
+2. Go to **Certificates & secrets** ? **+ New client secret** ? copy the **Value** (not the ID).
+   - Set this as `OAuth2ClientSecret`.
+3. Go to **API permissions** ? **+ Add a permission** ? **APIs my organization uses** ? **Office 365 Exchange Online**:
+   - Add **Application permissions**: `IMAP.AccessAsApp`, `SMTP.SendAsApp`, `POP.AccessAsApp`
+   - Click **Grant admin consent**
+4. In Exchange Online PowerShell, register the service principal for the mailbox:
+   ```powershell
+   New-ServicePrincipal -AppId <ClientId> -ServiceId <ObjectId> -DisplayName "MessagingService"
+   Add-MailboxPermission -Identity "user@yourorg.onmicrosoft.com" -User <ObjectId> -AccessRights FullAccess
+   ```
+5. Set `OAuth2TenantId` to the full domain (e.g. `yourorg.onmicrosoft.com`) or tenant GUID.
+
+> ?? `OAuth2ClientSecret` must be the **Value** shown at secret creation time, not the Secret ID (GUID).
+> The value is only visible once — if lost, create a new secret.
+
+> ?? `OAuth2TenantId` must be a full domain (`yourorg.onmicrosoft.com`), a tenant GUID,
+> or `common`. Short names like `yourorg` are not valid and will cause `AADSTS900023`.
+
+> No browser-based authorization is required for Microsoft — the application acquires tokens
+> automatically on first use and caches them in memory until 5 minutes before expiry.
+
+
+---
+
+## Email Account Configuration
+
+Each account is configured under `EmailAccounts.Accounts` in `appsettings.Secrets.json`.
+
+> Different providers require different configuration fields. See provider-specific sections below.
+
+### Common fields (all providers)
+
+```json
+{
+  "Id": 1,
+  "Username": "user@example.com",
+  "Password": "your_password",
+  "SmtpServer": "smtp.example.com",
+  "SmtpPort": 465,
+  "SmtpUseSsl": true,
+  "UseOAuth2": false,
+  "ImapServer": "imap.example.com",
+  "ImapPort": 993,
+  "ImapUseSsl": true,
+  "Pop3Server": "pop.example.com",
+  "Pop3Port": 995,
+  "Pop3UseSsl": true,
+  "IncomingProtocol": 1
+}
+```
+
+> `Password` is always retained. When `UseOAuth2 = true`, SMTP/IMAP/POP3 connections use OAuth2 tokens
+> instead of the password. When `UseOAuth2 = false`, the password is used directly.
+> The `IncomingProtocol` field independently controls which protocol is used for receiving emails.
+
+#### `IncomingProtocol` values
+
+| Value | Meaning |
+|-------|---------|
+| `0`   | None — send-only account, skipped by sync worker |
+| `1`   | IMAP with username/password |
+| `2`   | POP3 with username/password |
+| `3`   | IMAP with OAuth2 |
+| `4`   | POP3 with OAuth2 |
+
+#### `OAuth2Provider` values
+
+| Value | Meaning |
+|-------|---------|
+| `0`   | None |
+| `1`   | Microsoft (Azure AD / Microsoft 365) |
+| `2`   | Google (Gmail / Google Workspace) |
+
+---
+
+## Provider-specific OAuth2 Configuration
+
+### Google (Gmail / Google Workspace)
+
+Google uses **user-delegated OAuth2** (not client credentials). A one-time authorization flow is required to obtain a refresh token.
+
+#### Required fields
+
+```json
+{
+  "UseOAuth2": true,
+  "OAuth2ClientId": "YOUR_CLIENT_ID.apps.googleusercontent.com",
+  "OAuth2ClientSecret": "GOCSPX-YOUR_CLIENT_SECRET",
+  "OAuth2RefreshToken": "1//04YOUR_REFRESH_TOKEN",
+  "OAuth2TenantId": "",
+  "OAuth2Provider": 2
+}
+```
+
+#### Setup — obtaining the refresh token (one-time)
+
+1. Go to [console.cloud.google.com](https://console.cloud.google.com) and create or select a project.
+2. Enable the **Gmail API** under *APIs & Services ? Library*.
+3. Go to *APIs & Services ? Credentials* ? **+ Create Credentials** ? **OAuth 2.0 Client ID**.
+   - Application type: **Web application**
+   - Authorized redirect URIs: `https://developers.google.com/oauthplayground`
+4. Go to *APIs & Services ? OAuth consent screen*:
+   - Add the Gmail account under **Test users** (required while app is in Testing mode).
+5. Go to [developers.google.com/oauthplayground](https://developers.google.com/oauthplayground):
+   - Click **?? Settings** ? enable **"Use your own OAuth credentials"**
+   - Enter your **Client ID** and **Client Secret** (from step 3)
+   - Close settings
+6. In the scope input (Step 1), enter `https://mail.google.com/` ? **Authorize APIs**
+7. Sign in with the Gmail account ? grant access
+8. Click **Exchange authorization code for tokens** (Step 2)
+9. Copy the `refresh_token` value from the response
+10. Set `OAuth2RefreshToken` in `appsettings.Secrets.json`
+
+> ?? The refresh token must be obtained using **your own client credentials** in Playground settings.
+> If obtained with Playground's default credentials, it will not work with your client secret.
+
+> ?? Google refresh tokens expire if unused for 6 months, or if the user revokes access.
+> The token must be re-obtained if `invalid_grant` is returned.
+
+---
+
+### Microsoft 365 / Exchange Online (Azure AD)
+
+Microsoft uses **application-level OAuth2** (client credentials flow — no user interaction required).
+
+#### Required fields
+
+```json
+{
+  "UseOAuth2": true,
+  "OAuth2ClientId": "YOUR_APP_CLIENT_ID",
+  "OAuth2ClientSecret": "YOUR_APP_CLIENT_SECRET_VALUE",
+  "OAuth2TenantId": "yourorg.onmicrosoft.com",
+  "OAuth2Provider": 1
+}
+```
+
+#### Setup
+
+1. Go to [portal.azure.com](https://portal.azure.com) ? **Azure Active Directory** ? **App registrations** ? **+ New registration**.
+2. Go to **Certificates & secrets** ? **+ New client secret** ? copy the **Value** (not the ID).
+   - Set this as `OAuth2ClientSecret`.
+3. Go to **API permissions** ? **+ Add a permission** ? **APIs my organization uses** ? **Office 365 Exchange Online**:
+   - Add **Application permissions**: `IMAP.AccessAsApp`, `SMTP.SendAsApp`, `POP.AccessAsApp`
+   - Click **Grant admin consent**
+4. In Exchange Online PowerShell, register the service principal for the mailbox:
+   ```powershell
+   New-ServicePrincipal -AppId <ClientId> -ServiceId <ObjectId> -DisplayName "MessagingService"
+   Add-MailboxPermission -Identity "user@yourorg.onmicrosoft.com" -User <ObjectId> -AccessRights FullAccess
+   ```
+5. Set `OAuth2TenantId` to the full domain (e.g. `yourorg.onmicrosoft.com`) or tenant GUID.
+
+> ?? `OAuth2ClientSecret` must be the **Value** shown at secret creation time, not the Secret ID (GUID).
+> The value is only visible once — if lost, create a new secret.
+
+> ?? `OAuth2TenantId` must be a full domain (`yourorg.onmicrosoft.com`), a tenant GUID,
+> or `common`. Short names like `yourorg` are not valid and will cause `AADSTS900023`.
+
 

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)
+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.
-- ✅ `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`
 
-### Value Objects
+### ✅ What's Working
-- ✅ `MessageId.cs` - Uses SHA256 hash (legacy-compatible algorithm)
+- Complete Domain model with 8 entities mapped to legacy database
-- ✅ `EmailAddress.cs` - Email validation and parsing
+- 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
+### ⚠️ What's Missing
-- ✅ `ErrorCode.cs` - All error codes from legacy system
+- Limilabs.Mail NuGet package (for email operations)
-- ✅ `ProcessType.cs` - ProcessManager, AttachmentSniffer, ZugFeRDParser
+- GdPicture.NET 14 or DevExpress.Pdf NuGet (for PDF processing)
-- ✅ `AuthenticationType.cs` - UsernamePassword, OAuth2
+- windream COM Interop DLLs (for DMS integration)
-- ✅ `EmailStatus.cs` - Email processing status
+- API Controllers and Background Workers
-- ✅ `AttachmentStatus.cs` - Attachment validation status
+- Unit and integration tests
-
-### 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
 
 ---
 
-## 🚧 IN PROGRESS (Phase 2: Application Layer - 5%)
+## Phase Breakdown
 
-### DTOs
+### Phase 1: Domain Layer ✅ COMPLETE (100%)
-- ✅ `CommonDtos.cs` - EmailProfileDto, EmailAccountDto, EmailHistoryDto, EmailAttachmentDto
 
-### NuGet Packages
+**Entities** (8 total):
-- ✅ Application project has:
+- ✅ `EmailAccount` - Email server configuration (IMAP/SMTP/OAuth2)
-  - MediatR 14.2.0
+- ✅ `EmailProfile` - Email polling profiles with archiving rules
-  - AutoMapper.Extensions.Microsoft.DependencyInjection 12.0.1
+- ✅ `EmailHistory` - Email import history with duplicate detection
-  - FluentValidation.DependencyInjectionExtensions 12.1.1
+- ✅ `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
+**Commands** (5 total):
-- ❌ `IEmailProfileRepository.cs`
+- ✅ `CreateEmailProfileCommand` - Create new email profile
-- ❌ `IEmailAccountRepository.cs`
+- ✅ `UpdateEmailProfileCommand` - Update existing profile
-- ❌ `IEmailHistoryRepository.cs`
+- ✅ `DeleteEmailProfileCommand` - Delete profile
-- ❌ `IEmailProcessRepository.cs`
+- ✅ `CreateEmailAccountCommand` - Create email account
-- ❌ `IEmailOutboxRepository.cs`
+- ✅ `ProcessEmailCommand` - Process incoming email
 
-### Service Interfaces
+**Queries** (7 total):
-- ❌ `IEmailService.cs`
+- ✅ `GetEmailProfilesQuery` - Get all profiles
-- ❌ `IPdfProcessingService.cs`
+- ✅ `GetEmailProfileByIdQuery` - Get profile by ID
-- ❌ `IDmsService.cs`
+- ✅ `GetEmailAccountsQuery` - Get all accounts
-- ❌ `IEncryptionService.cs`
+- ✅ `GetEmailAccountByIdQuery` - Get account by ID
-- ❌ `IEmailQueue.cs`
+- ✅ `GetEmailHistoryQuery` - Get email history with filters
+- ✅ `GetWindreamArchivesQuery` - Get windream archives
+- ✅ `GetLogEmailOutQuery` - Get outgoing email queue
 
-### MediatR Commands
+**Validators** (4 total):
-- ❌ `CreateEmailProfileCommand.cs`
+- ✅ `CreateEmailProfileCommandValidator` - FluentValidation for CreateEmailProfileCommand
-- ❌ `UpdateEmailProfileCommand.cs`
+- ✅ `UpdateEmailProfileCommandValidator` - FluentValidation for UpdateEmailProfileCommand
-- ❌ `DeleteEmailProfileCommand.cs`
+- ✅ `CreateEmailAccountCommandValidator` - FluentValidation for CreateEmailAccountCommand
-- ❌ `ActivateProfileCommand.cs`
+- ✅ `ProcessEmailCommandValidator` - FluentValidation for ProcessEmailCommand
-- ❌ `DeactivateProfileCommand.cs`
-- ❌ Similar commands for EmailAccount, EmailProcess, etc.
 
-### MediatR Queries
+**AutoMapper Profiles** (4 total):
-- ❌ `GetEmailProfilesQuery.cs`
+- ✅ `EmailProfileMappingProfile` - Maps EmailProfile DTOs ↔ Entities
-- ❌ `GetEmailProfileByIdQuery.cs`
+- ✅ `EmailAccountMappingProfile` - Maps EmailAccount DTOs ↔ Entities
-- ❌ `GetActiveProfilesQuery.cs`
+- ✅ `EmailHistoryMappingProfile` - Maps EmailHistory DTOs ↔ Entities
-- ❌ `GetProfilesDueForPollingQuery.cs`
+- ✅ `WindreamArchiveMappingProfile` - Maps WindreamArchive DTOs ↔ Entities
-- ❌ Similar queries for other entities
 
-### Validators
+**DTOs** (8 total):
-- ❌ `CreateEmailProfileCommandValidator.cs`
+- ✅ `EmailAccountDto` - Email account configuration
-- ❌ `UpdateEmailProfileCommandValidator.cs`
+- ✅ `EmailProfileDto` - Email profile configuration
-- ❌ Similar validators for all commands
+- ✅ `CreateEmailProfileDto` - Create profile request
+- ✅ `UpdateEmailProfileDto` - Update profile request
+- ✅ `EmailHistoryDto` - Email history record
+- ✅ `EmailAttachmentDto` - Attachment metadata
+- ✅ `WindreamArchiveDto` - windream archive record
+- ✅ `LogEmailOutDto` - Outgoing email record
 
-### Mappings
+**Interfaces** (6 total):
-- ❌ `MappingProfile.cs` - AutoMapper configuration
+- ✅ `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
+**Key Features**:
-- ❌ `DependencyInjection.cs` - Application layer DI setup
+- 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
+**Database**:
-- ❌ Microsoft.EntityFrameworkCore.SqlServer
+- ✅ `MessagingServiceDbContext` - EF Core DbContext with 8 DbSets
-- ❌ Microsoft.EntityFrameworkCore.Tools
+  - NO `OnModelCreating` override (attribute-only configuration)
-- ❌ MailKit
+  - NO `SaveChangesAsync` override (Repository handles this)
-- ❌ MimeKit
+  - Connection string: `DefaultConnection` from appsettings
-- ❌ PdfSharp
-- ❌ Microsoft.Identity.Client
-- ❌ Microsoft.AspNetCore.DataProtection
 
-### Persistence
+**Repository**:
-- ❌ `EmailProfilerDbContext.cs`
+- ✅ `Repository<T>` - Generic repository implementing `IRepository<T>`
-- ❌ EF Core migrations
+  - 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
+**Services** (6 total):
-- ❌ `EmailProfileRepository.cs`
+- ✅ `LimilabsEmailService` - Email operations using Limilabs Mail.dll
-- ❌ `EmailAccountRepository.cs`
+  - IMAP: `ConnectSSLAsync`, `LoginOAUTH2Async`, `Search(Flag.Unseen)`, `GetMessageByUID`
-- ❌ `EmailHistoryRepository.cs`
+  - SMTP: `SendMessageAsync`
-- ❌ `EmailProcessRepository.cs`
+  - OAuth2: `GetOAuth2TokenAsync` via `Microsoft.Identity.Client` (MSAL)
-- ❌ `EmailOutboxRepository.cs`
+  - **TODO**: Add Limilabs.Mail NuGet package to uncomment implementation
 
-### External Services
+- ✅ `GdPicturePdfProcessingService` - PDF processing using GdPicture.NET 14
-- ❌ `MailKitEmailService.cs` - IMAP/SMTP with OAuth2
+  - `ValidatePdfAsync` - PDF validation
-- ❌ `PdfSharpProcessingService.cs` - PDF validation and embedded file extraction
+  - `ExtractEmbeddedFilesAsync` - Extract embedded files via `GetAttachmentCount`, `ExtractEmbeddedFile`
-- ❌ `WindreamDmsService.cs` - windream DMS integration (COM Interop)
+  - `GetPageCountAsync` - Get PDF page count
-- ❌ `DataProtectionEncryptionService.cs` - Password encryption
+  - **TODO**: Add GdPicture.NET.14 NuGet package and license key
-- ❌ `InMemoryEmailQueue.cs` - Email queue (Channel-based)
 
-### DI Configuration
+- ✅ `WindreamDmsService` - windream DMS integration using COM Interop
-- ❌ `DependencyInjection.cs` - Infrastructure layer DI setup
+  - `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
+**Controllers** (3 total):
-- ❌ Serilog.AspNetCore
+- ✅ `EmailProfilesController` - CRUD operations for email profiles
-- ❌ Serilog.Sinks.File
+  - GET /api/emailprofiles - Get all profiles (synchronous via MediatR)
-- ❌ Serilog.Sinks.MSSqlServer
+  - GET /api/emailprofiles/{id} - Get profile by ID
-- ❌ Scalar.AspNetCore
+  - 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
+- ✅ `EmailAccountsController` - CRUD operations for email accounts
-- ❌ `EmailProfilesController.cs`
+  - GET /api/emailaccounts - Get all accounts
-- ❌ `EmailAccountsController.cs`
+  - GET /api/emailaccounts/{id} - Get account by ID
-- ❌ `EmailHistoryController.cs`
+  - POST /api/emailaccounts - Create account (async via RabbitMQ)
-- ❌ `DashboardController.cs`
 
-### Background Workers
+- ✅ `EmailHistoryController` - Query email history
-- ❌ `EmailPollingWorker.cs` - Monitors email accounts
+  - GET /api/emailhistory - Get email history with filters
-- ❌ `EmailSenderWorker.cs` - Sends queued emails
 
-### Middleware
+**Workers** (Background Services):
-- ❌ `ExceptionHandlingMiddleware.cs`
+- ❌ `EmailPollingWorker` - Polls email accounts for new messages (NOT STARTED)
+- ❌ `EmailSenderWorker` - Sends outgoing emails from queue (NOT STARTED)
 
-### Configuration
+**Configuration**:
-- ❌ Update `Program.cs` - Serilog, Scalar, DI, Windows Service support
+- ✅ `appsettings.json` - Application configuration
-- ❌ Update `appsettings.json` - Complete 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
+**TODO**:
-- ❌ FakeItEasy
+- [ ] Unit tests for Domain entities (MessageIdGenerator, Value Objects)
-- ❌ Bogus
+- [ ] Unit tests for Application handlers (using FakeItEasy for mocks)
-- ❌ FluentAssertions
+- [ ] Integration tests for Repository (using Testcontainers for SQL Server)
-- ❌ Microsoft.AspNetCore.Mvc.Testing
+- [ ] Integration tests for EmailService (using test email account)
-- ❌ Testcontainers.MsSql
+- [ ] API tests (using WebApplicationFactory)
+- [ ] Generate fake test data (using Bogus library)
 
-### Unit Tests
+**Test Structure**:
-- ❌ Domain entity tests
+```
-- ❌ Value object tests
+tests/DigitalData.MessagingService.Tests/
-- ❌ MessageIdGenerator tests
+├── Domain/
-- ❌ Command handler tests
+│   ├── Services/MessageIdGeneratorTests.cs
-- ❌ Query handler tests
+│   ├── ValueObjects/EmailAddressTests.cs
-
+│   └── ValueObjects/MessageIdTests.cs
-### Integration Tests
+├── Application/
-- ❌ Repository tests (with Testcontainers)
+│   ├── EmailProfiles/CreateEmailProfileCommandHandlerTests.cs
-- ❌ API tests (with WebApplicationFactory)
+│   ├── 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
+### 1. Limilabs.Mail ⚠️ REQUIRED
-  - Application overview
+**Status**: Not added  
-  - API endpoints
+**Action**: `dotnet add package Limilabs.Mail`  
-  - Workers documentation
+**Impact**: Email operations (IMAP/SMTP/OAuth2) will not work  
-  - Database tables
+**Files Affected**: `LimilabsEmailService.cs`
-  - Configuration guide
+
-  - Deployment guide (IIS + Windows Service)
+### 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
 
-```
+**Warnings**:
-Build succeeded.
+- `CS9113`: Parameter 'dmsService' is unread in `ProcessEmailCommandHandler`
-    0 Warning(s)
+  - **Reason**: Service implementation pending windream COM Interop integration
-    0 Error(s)
+  - **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
+### 1. Add External Dependencies (HIGH PRIORITY)
-- ✅ `IMPLEMENTATION_GUIDE.md` - Step-by-step implementation guide
+- [ ] Add Limilabs.Mail NuGet package
-- ✅ `STATUS.md` - This file (current status)
+- [ ] Add GdPicture.NET 14 (or DevExpress.Pdf) NuGet package
-- ❌ `MIGRATION_PLAN.md` - Full migration plan (not created yet)
+- [ ] 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. AutoMapper Vulnerability Warning
-1. Create all repository interfaces
+**Issue**: NuGet package `AutoMapper 12.0.1` has a known vulnerability  
-2. Create all service interfaces
+**Severity**: Moderate (only affects 12.0.0-12.0.1)  
-3. Create MediatR commands and handlers
+**Impact**: Internal application - acceptable risk  
-4. Create MediatR queries and handlers
+**Resolution**: Upgrade to AutoMapper 13.0+ when stable
-5. Create FluentValidation validators
-6. Create AutoMapper profile
-7. Create DependencyInjection.cs
 
-**Priority 2**: Complete Infrastructure Layer
+### 2. RabbitMQ Email Queue Not Implemented
-1. Add NuGet packages
+**Issue**: Using `InMemoryEmailQueue` instead of `RabbitMqEmailQueue`  
-2. Create EmailProfilerDbContext
+**Impact**: Outgoing emails lost on application restart  
-3. Create all repositories
+**Resolution**: Implement `RabbitMqEmailQueue` before production deployment
-4. Create all external services
-5. Create DependencyInjection.cs
-6. Create initial EF Core migration
 
-**Priority 3**: Complete API Layer
+### 3. No Database Migrations
-1. Add NuGet packages
+**Issue**: EF Core migrations disabled (legacy database must not be modified)  
-2. Update Program.cs
+**Impact**: Cannot use `dotnet ef database update`  
-3. Create all controllers
+**Resolution**: All schema changes must be done manually in legacy system
-4. Create background workers
-5. Update appsettings.json
 
-**Priority 4**: Testing
+### 4. DateTime.Now vs DateTime.UtcNow
-1. Add test NuGet packages
+**Issue**: Must use `DateTime.Now` (local server time) throughout application  
-2. Create unit tests
+**Impact**: Non-standard practice (industry standard is UTC)  
-3. Create integration tests
+**Reason**: Legacy database stores local time, not UTC  
+**Resolution**: Document clearly and enforce in code reviews
 
-**Priority 5**: Documentation
+### 5. windream COM Interop Windows-Only
-1. Create README.md (German)
+**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
+## Documentation
-- Phase 1 (Domain): 100% ✅
+
-- Phase 2 (Application): 5% 🚧
+### Files Created
-- Phase 3 (Infrastructure): 0% ❌
+- ✅ `AGENTS.md` - Agent notes, decisions, and future enhancements
-- Phase 4 (API): 0% ❌
+- ✅ `STATUS.md` - This file - implementation status report
-- Phase 5 (Testing): 0% ❌
+- ✅ `README.md` - Project overview and getting started guide (German)
-- Phase 6 (Documentation): 0% ❌
+
+### 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,402 +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. 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,19 +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" />
-  </ItemGroup>
-
-</Project>

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.UtcNow;
-    }
-
-    public void MarkAsFailed(ErrorCode errorCode, string message)
-    {
-        Status = EmailStatus.Failed.ToString();
-        ErrorCodeValue = (int)errorCode;
-        ErrorMessage = message;
-        ProcessedDate = DateTime.UtcNow;
-    }
-}

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.UtcNow;
-
-    public bool ShouldPoll()
-    {
-        if (!IsActive) return false;
-        if (!LastPollTime.HasValue) return true;
-        return DateTime.UtcNow >= 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,22 +0,0 @@
-using MediatR;
-using DigitalData.EmailProfiler.Domain.Enums;
-
-namespace DigitalData.EmailProfiler.Domain.Events;
-
-public class EmailProcessedEvent : INotification
-{
-    public int EmailHistoryId { get; }
-    public int ProfileId { get; }
-    public string MessageId { get; }
-    public EmailStatus Status { get; }
-    public DateTime ProcessedDate { get; }
-
-    public EmailProcessedEvent(int emailHistoryId, int profileId, string messageId, EmailStatus status)
-    {
-        EmailHistoryId = emailHistoryId;
-        ProfileId = profileId;
-        MessageId = messageId;
-        Status = status;
-        ProcessedDate = DateTime.UtcNow;
-    }
-}

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

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

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

@@ -1,12 +0,0 @@
-namespace DigitalData.EmailProfiler.Domain.Exceptions;
-
-public class DomainException : Exception
-{
-    public DomainException(string message) : base(message)
-    {
-    }
-
-    public DomainException(string message, Exception innerException) : base(message, innerException)
-    {
-    }
-}

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

@@ -1,12 +0,0 @@
-namespace DigitalData.EmailProfiler.Domain.Exceptions;
-
-public class ValidationException : DomainException
-{
-    public ValidationException(string message) : base(message)
-    {
-    }
-
-    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,77 @@
+using DigitalData.MessagingService.Domain.Enums;
+
+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;
+
+    public string? Pop3Server { get; set; }
+
+    public int Pop3Port { get; set; } = 995;
+
+    public bool Pop3UseSsl { get; set; } = true;
+
+    public string? OAuth2ClientId { get; set; }
+
+    /// <summary>
+    /// OAuth2 refresh token (Google only). Obtained via OAuth Playground or authorization flow.
+    /// Leave empty for Microsoft.
+    /// </summary>
+    public string? OAuth2RefreshToken { get; set; }
+
+    /// <summary>
+    /// Tenant ID for Microsoft OAuth2 (GUID, full domain, or "common"). Not used for Google.
+    /// </summary>
+    public string? OAuth2TenantId { get; set; }
+
+    /// <summary>
+    /// Identifies which OAuth2 identity provider to use when <see cref="UseOAuth2"/> is true.
+    /// </summary>
+    public OAuth2Provider OAuth2Provider { get; set; } = OAuth2Provider.None;
+
+    /// <summary>
+    /// The protocol used to receive (sync) incoming emails.
+    /// </summary>
+    public IncomingProtocol IncomingProtocol { get; set; } = IncomingProtocol.None;
+}

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

@@ -0,0 +1,80 @@
+using DigitalData.MessagingService.Domain.Enums;
+
+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;
+
+    public string? Pop3Server { get; set; }
+
+    public int Pop3Port { get; set; } = 995;
+
+    public bool Pop3UseSsl { get; set; } = true;
+
+    public string? OAuth2ClientId { get; set; }
+
+    public string? OAuth2ClientSecret { get; set; }
+
+    /// <summary>
+    /// OAuth2 refresh token (Google only). Obtained via OAuth Playground or authorization flow.
+    /// Leave empty for Microsoft.
+    /// </summary>
+    public string? OAuth2RefreshToken { get; set; }
+
+    /// <summary>
+    /// Tenant ID for Microsoft OAuth2 (GUID, full domain, or "common"). Not used for Google.
+    /// </summary>
+    public string? OAuth2TenantId { get; set; }
+
+    /// <summary>
+    /// Identifies which OAuth2 identity provider to use when <see cref="UseOAuth2"/> is true.
+    /// </summary>
+    public OAuth2Provider OAuth2Provider { get; set; } = OAuth2Provider.None;
+
+    /// <summary>
+    /// The protocol used to receive (sync) incoming emails.
+    /// </summary>
+    public IncomingProtocol IncomingProtocol { get; set; } = IncomingProtocol.None;
+}

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,40 @@
+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
+
+    /// <summary>
+    /// When true, the sent message will be appended to the IMAP Sent folder after sending.
+    /// </summary>
+#if NETFRAMEWORK
+    public bool UseImapAppend { get; set; } = false;
+#else
+    public bool UseImapAppend { get; init; } = false;
+#endif
+
+    /// <summary>
+    /// IMAP folder to append the sent message to (used when <see cref="UseImapAppend"/> is true).
+    /// </summary>
+#if NETFRAMEWORK
+    public string SentFolder { get; set; } = "Sent";
+#else
+    public string SentFolder { get; init; } = "Sent";
+#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/IEmailSyncService.cs

@@ -0,0 +1,6 @@
+namespace DigitalData.MessagingService.Application.Common.Interfaces;
+
+public interface IEmailSyncService
+{
+    public DateTime ForceTriggerSync();
+}

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,50 @@
+#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");
+
+    /// <summary>
+    /// Sends an email via SMTP using the account credentials and appends the sent message
+    /// to the account's IMAP Sent Items folder.
+    /// </summary>
+    Task SendAndAppendAsync(
+        EmailContext context,
+        string sentFolder = "Sent",
+        CancellationToken cancellationToken = default);
+}
+#endif

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

@@ -0,0 +1,35 @@
+#if NET
+using DigitalData.MessagingService.Domain.Entities;
+
+namespace DigitalData.MessagingService.Application.Common.Interfaces;
+
+/// <summary>
+/// Manages the OAuth2 authorization code flow for providers that require
+/// user-delegated access (e.g. Google). Generates authorization URLs and
+/// exchanges authorization codes for refresh tokens.
+/// </summary>
+public interface IOAuth2AuthorizationService
+{
+    /// <summary>
+    /// Builds the authorization URL to redirect the user to for consent.
+    /// </summary>
+    /// <param name="account">The email account to authorize.</param>
+    /// <param name="redirectUri">The callback URI registered with the OAuth2 provider.</param>
+    /// <returns>The full authorization URL.</returns>
+    string GetAuthorizationUrl(EmailAccount account, string redirectUri);
+
+    /// <summary>
+    /// Exchanges an authorization code for tokens and returns the refresh token.
+    /// </summary>
+    /// <param name="account">The email account being authorized.</param>
+    /// <param name="code">The authorization code received from the provider callback.</param>
+    /// <param name="redirectUri">The same redirect URI used in <see cref="GetAuthorizationUrl"/>.</param>
+    /// <param name="cancellationToken">Cancellation token.</param>
+    /// <returns>The refresh token to be stored on the account.</returns>
+    Task<string> ExchangeCodeForRefreshTokenAsync(
+        EmailAccount account,
+        string code,
+        string redirectUri,
+        CancellationToken cancellationToken = default);
+}
+#endif

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

@@ -0,0 +1,18 @@
+#if NET
+using DigitalData.MessagingService.Domain.Entities;
+
+namespace DigitalData.MessagingService.Application.Common.Interfaces;
+
+/// <summary>
+/// Acquires and caches OAuth2 access tokens for email protocols (IMAP, POP3, SMTP).
+/// Uses the client credentials flow (application-level auth — no user interaction required).
+/// </summary>
+public interface IOAuth2TokenService
+{
+    /// <summary>
+    /// Returns a valid access token for the given email account.
+    /// Tokens are cached and refreshed automatically before expiry.
+    /// </summary>
+    Task<string> GetAccessTokenAsync(EmailAccount account, CancellationToken cancellationToken = default);
+}
+#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/IPop3EmailService.cs

@@ -0,0 +1,25 @@
+#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 POP3.
+/// </summary>
+public interface IPop3EmailService
+{
+    /// <summary>
+    /// Fetches new messages from the POP3 server and persists them locally.
+    /// Because POP3 has no folder concept, all messages are stored under the folder name "INBOX".
+    /// </summary>
+    Task<EmailSyncResult> SyncEmailsAsync(
+        EmailAccount account,
+        CancellationToken cancellationToken = default);
+
+    /// <summary>
+    /// Gets the last POP3 sync date for the specified account.
+    /// </summary>
+    DateTime? GetLastPop3SyncDate(int accountId);
+}
+#endif

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,56 @@
+#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));
+
+        // PublishEmailViaImapCommand -> EmailContext
+        CreateMap<PublishEmailViaImapCommand, EmailContext>()
+            .ForMember(dest => dest.Sender, opt => opt.Ignore())
+            .ForMember(dest => dest.Attachments, opt => opt.MapFrom(src => src.Attachments));
+
+        // PublishEmailViaOAuth2Command -> EmailContext
+        CreateMap<PublishEmailViaOAuth2Command, 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>()
+            // Do not overwrite OAuth2RefreshToken if the source value is null or empty.
+            // This prevents the seed process from erasing a token that was obtained via
+            // the OAuth2 authorization flow and saved to the database at runtime.
+            .ForMember(dest => dest.OAuth2RefreshToken,
+                opt => opt.Condition((src, dest, srcMember) => !string.IsNullOrEmpty(srcMember)));
+
+        // 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/Mappings/OAuth2MappingProfile.cs

@@ -0,0 +1,19 @@
+#if NET
+using AutoMapper;
+using DigitalData.MessagingService.Domain.Entities;
+
+namespace DigitalData.MessagingService.Application.Common.Mappings;
+
+/// <summary>
+/// AutoMapper profile for OAuth2 operations.
+/// Registers EmailAccount self-mapping so UpdateSingleAsync can update an account
+/// entity using another EmailAccount instance (e.g. after setting OAuth2RefreshToken).
+/// </summary>
+public class OAuth2MappingProfile : Profile
+{
+    public OAuth2MappingProfile()
+    {
+        CreateMap<EmailAccount, EmailAccount>();
+    }
+}
+#endif

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

@@ -0,0 +1,34 @@
+#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;
+
+    /// <summary>
+    /// The minimum interval, in seconds, between forced IMAP sync operations regardless of idle state.
+    /// Defaults to 30 seconds (0.5 minute).
+    /// </summary>
+    public int ForcedSyncIntervalSeconds { get; init; } = 30;
+}
+#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,58 @@
+#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<ReadEmailQueryResponse>
+{
+    /// <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, IImapEmailService imapEmailService) : IRequestHandler<ReadEmailQuery, ReadEmailQueryResponse>
+{
+    public async Task<ReadEmailQueryResponse> 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);
+
+        var lastSync = imapEmailService.GetLastImapSyncDate(account.Id, request.Mail.Folder);
+
+        return new ReadEmailQueryResponse
+        {
+            LastSync = lastSync,
+            Emails = Mapper.Map<IEnumerable<ReceivedEmailDto>>(mails)
+        };
+    }
+}
+#endif

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

@@ -0,0 +1,17 @@
+#if NET
+using DigitalData.MessagingService.Application.Common.Dto;
+
+namespace DigitalData.MessagingService.Application.EmailReceiving.Queries;
+
+/// <summary>
+/// 
+/// </summary>
+/// <param name="Emails"></param>
+/// <param name="LastSync"></param>
+public class ReadEmailQueryResponse
+{
+    public DateTime? LastSync { get; init; } = null;
+
+    public IEnumerable<ReceivedEmailDto> Emails { get; init; } = [];
+}
+#endif

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

@@ -0,0 +1,77 @@
+#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.Application.EmailReceiving.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 using OAuth2 authentication.
+/// The account must have <c>UseOAuth2 = true</c> and valid OAuth2 credentials configured.
+/// </summary>
+public record ReadEmailViaOAuth2Query : IRequest<ReadEmailQueryResponse>
+{
+    /// <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 ReadEmailViaOAuth2QueryHandler(
+    IMapper Mapper,
+    ILogger<ReadEmailViaOAuth2QueryHandler> Logger,
+    IRepository<EmailAccount> EmailAccountRepo,
+    IReceivedEmailRepository MailRepo,
+    IImapEmailService imapEmailService) : IRequestHandler<ReadEmailViaOAuth2Query, ReadEmailQueryResponse>
+{
+    public async Task<ReadEmailQueryResponse> Handle(ReadEmailViaOAuth2Query 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 ({Criteria}). Using first.",
+                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 (Id: {request.Account.Id}, Username: {request.Account.Username}).");
+
+        if (!account.UseOAuth2)
+            throw new BadRequestException(
+                $"Account '{account.Username}' (Id: {account.Id}) is not configured for OAuth2. Set UseOAuth2 = true.");
+
+        if (string.IsNullOrWhiteSpace(account.OAuth2ClientId) ||
+            string.IsNullOrWhiteSpace(account.OAuth2ClientSecret))
+            throw new BadRequestException(
+                $"OAuth2 credentials (ClientId, ClientSecret) are not configured for account '{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);
+
+        var lastSync = imapEmailService.GetLastImapSyncDate(account.Id, request.Mail.Folder);
+
+        return new ReadEmailQueryResponse
+        {
+            LastSync = lastSync,
+            Emails = Mapper.Map<IEnumerable<ReceivedEmailDto>>(mails)
+        };
+    }
+}
+#endif

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

@@ -0,0 +1,74 @@
+#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.Application.EmailReceiving.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 a POP3 mailbox.
+/// Triggers an on-demand sync and returns stored results filtered by <see cref="Mail"/>.
+/// </summary>
+public record ReadEmailViaPop3Query : IRequest<ReadEmailQueryResponse>
+{
+    /// <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 from local storage.
+    /// Note: POP3 has no folder concept — all messages are stored under "INBOX".
+    /// </summary>
+    public MailSearchFilter Mail { get; init; } = new();
+}
+
+public class ReadEmailViaPop3QueryHandler(
+    IMapper Mapper,
+    ILogger<ReadEmailViaPop3QueryHandler> Logger,
+    IRepository<EmailAccount> EmailAccountRepo,
+    IReceivedEmailRepository MailRepo,
+    IPop3EmailService pop3EmailService) : IRequestHandler<ReadEmailViaPop3Query, ReadEmailQueryResponse>
+{
+    public async Task<ReadEmailQueryResponse> Handle(ReadEmailViaPop3Query 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 ({Criteria}). Using first.",
+                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 (Id: {request.Account.Id}, Username: {request.Account.Username}).");
+
+        if (string.IsNullOrWhiteSpace(account.Pop3Server))
+            throw new BadRequestException(
+                $"POP3 is not configured for account '{account.Username}' (Id: {account.Id}). Set Pop3Server in EmailAccounts configuration.");
+
+        // Trigger on-demand POP3 sync before querying local storage
+        await pop3EmailService.SyncEmailsAsync(account, cancellationToken);
+
+        // POP3 has no folder concept — always query INBOX
+        var filter = request.Mail with { Folder = "INBOX" };
+        var mails = await MailRepo.FindAsync(filter, account, cancellationToken);
+
+        var lastSync = pop3EmailService.GetLastPop3SyncDate(account.Id);
+
+        return new ReadEmailQueryResponse
+        {
+            LastSync = lastSync,
+            Emails = 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/Commands/PublishEmailViaImapCommand.cs

@@ -0,0 +1,81 @@
+#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 using IMAP account credentials (queued via RabbitMQ).
+/// After processing, the sent message is appended to the IMAP Sent Items folder.
+/// </summary>
+public record PublishEmailViaImapCommand : IRequest<Guid>
+{
+    public required GetEmailAccountQuery Sender { get; init; }
+
+    public required IEnumerable<string> Recipients { get; init; }
+
+    public required string Subject { get; init; }
+
+    public required string Body { get; init; }
+
+    public bool IsHtml { get; init; } = true;
+
+    /// <summary>
+    /// IMAP folder to which the sent message will be appended (default: "Sent").
+    /// </summary>
+    public string SentFolder { get; init; } = "Sent";
+
+    [JsonIgnore]
+    internal IEnumerable<EmailAttachmentDto> Attachments { get; private init; } = [];
+
+    public PublishEmailViaImapCommand WithAttachments(IEnumerable<EmailAttachmentDto> attachments)
+        => this with { Attachments = attachments };
+}
+
+public class PublishEmailViaImapCommandHandler(
+    IRepository<EmailAccount> Repo,
+    ISendingEmailPublisher Publisher,
+    IMapper Mapper,
+    ILogger<PublishEmailViaImapCommandHandler> Logger) : IRequestHandler<PublishEmailViaImapCommand, Guid>
+{
+    public async Task<Guid> Handle(PublishEmailViaImapCommand 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 ({Criteria}). Using first.",
+                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 (Id: {request.Sender.Id}, Username: {request.Sender.Username}).");
+
+        if (string.IsNullOrWhiteSpace(senderAccount.ImapServer))
+            throw new BadRequestException(
+                $"IMAP is not configured for account '{senderAccount.Username}' (Id: {senderAccount.Id}). Set ImapServer in EmailAccounts configuration.");
+
+        var emailContext = Mapper.Map<EmailContext>(request) with { Sender = senderAccount };
+
+        var sendingEmailEvent = new SendingEmailEvent
+        {
+            Id = Guid.NewGuid(),
+            Mail = emailContext,
+            QueuedAt = DateTime.Now,
+            SentFolder = request.SentFolder,
+            UseImapAppend = true
+        };
+
+        await Publisher.EnqueueAsync(sendingEmailEvent, cancellationToken);
+        return sendingEmailEvent.Id;
+    }
+}
+#endif

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

@@ -0,0 +1,79 @@
+#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 via SMTP using OAuth2 authentication (queued via RabbitMQ).
+/// The account must have <c>UseOAuth2 = true</c> and valid OAuth2 credentials configured.
+/// </summary>
+public record PublishEmailViaOAuth2Command : IRequest<Guid>
+{
+    public required GetEmailAccountQuery Sender { get; init; }
+
+    public required IEnumerable<string> Recipients { get; init; }
+
+    public required string Subject { get; init; }
+
+    public required string Body { get; init; }
+
+    public bool IsHtml { get; init; } = true;
+
+    [JsonIgnore]
+    internal IEnumerable<EmailAttachmentDto> Attachments { get; private init; } = [];
+
+    public PublishEmailViaOAuth2Command WithAttachments(IEnumerable<EmailAttachmentDto> attachments)
+        => this with { Attachments = attachments };
+}
+
+public class PublishEmailViaOAuth2CommandHandler(
+    IRepository<EmailAccount> Repo,
+    ISendingEmailPublisher Publisher,
+    IMapper Mapper,
+    ILogger<PublishEmailViaOAuth2CommandHandler> Logger) : IRequestHandler<PublishEmailViaOAuth2Command, Guid>
+{
+    public async Task<Guid> Handle(PublishEmailViaOAuth2Command 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 ({Criteria}). Using first.",
+                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 (Id: {request.Sender.Id}, Username: {request.Sender.Username}).");
+
+        if (!senderAccount.UseOAuth2)
+            throw new BadRequestException(
+                $"Account '{senderAccount.Username}' (Id: {senderAccount.Id}) is not configured for OAuth2. Set UseOAuth2 = true.");
+
+        if (string.IsNullOrWhiteSpace(senderAccount.OAuth2ClientId) ||
+            string.IsNullOrWhiteSpace(senderAccount.OAuth2ClientSecret))
+            throw new BadRequestException(
+                $"OAuth2 credentials (ClientId, ClientSecret) are not configured for account '{senderAccount.Username}'.");
+
+        var emailContext = Mapper.Map<EmailContext>(request) with { Sender = senderAccount };
+
+        var sendingEmailEvent = new SendingEmailEvent
+        {
+            Id = Guid.NewGuid(),
+            Mail = emailContext,
+            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.Application/OAuth2/Commands/CompleteOAuth2AuthorizationCommand.cs

@@ -0,0 +1,72 @@
+#if NET
+using DigitalData.MessagingService.Application.Common.Interfaces;
+using DigitalData.MessagingService.Application.Common.Interfaces.Repositories;
+using DigitalData.MessagingService.Domain.Entities;
+using DigitalData.MessagingService.Domain.Exceptions;
+using MediatR;
+using Microsoft.Extensions.Logging;
+
+namespace DigitalData.MessagingService.Application.OAuth2.Commands;
+
+/// <summary>
+/// Exchanges a Google OAuth2 authorization code for a refresh token
+/// and persists it on the email account.
+/// Call this from the OAuth2 callback endpoint after the user grants consent.
+/// </summary>
+public record CompleteOAuth2AuthorizationCommand : IRequest<CompleteOAuth2AuthorizationResult>
+{
+    /// <summary>
+    /// ID of the email account being authorized.
+    /// </summary>
+    public required int AccountId { get; init; }
+
+    /// <summary>
+    /// The authorization code received from the OAuth2 provider callback.
+    /// </summary>
+    public required string Code { get; init; }
+
+    /// <summary>
+    /// The redirect URI used in the original authorization request.
+    /// </summary>
+    public required string RedirectUri { get; init; }
+}
+
+public record CompleteOAuth2AuthorizationResult
+{
+    public required string Username { get; init; }
+    public required bool Success { get; init; }
+    public string? ErrorMessage { get; init; }
+}
+
+public class CompleteOAuth2AuthorizationCommandHandler(
+    IRepository<EmailAccount> Repo,
+    IOAuth2AuthorizationService AuthService,
+    ILogger<CompleteOAuth2AuthorizationCommandHandler> Logger) : IRequestHandler<CompleteOAuth2AuthorizationCommand, CompleteOAuth2AuthorizationResult>
+{
+    public async Task<CompleteOAuth2AuthorizationResult> Handle(CompleteOAuth2AuthorizationCommand request, CancellationToken cancellationToken)
+    {
+        var account = await Repo.GetByIdAsync(request.AccountId, cancellationToken)
+            ?? throw new NotFoundException($"No email account found with Id: {request.AccountId}.");
+
+        Logger.LogInformation("Exchanging OAuth2 authorization code for account '{Username}' (Id: {Id}).",
+            account.Username, account.Id);
+
+        var refreshToken = await AuthService.ExchangeCodeForRefreshTokenAsync(
+            account, request.Code, request.RedirectUri, cancellationToken);
+
+        // Set the refresh token directly on the tracked entity — no AutoMapper needed
+        account.OAuth2RefreshToken = refreshToken;
+        await Repo.UpdateSingleAsync(a => a.Id == account.Id, account, cancellationToken);
+
+        Logger.LogInformation("OAuth2 refresh token saved for account '{Username}' (Id: {Id}).",
+            account.Username, account.Id);
+
+        return new CompleteOAuth2AuthorizationResult
+        {
+            Username = account.Username,
+            Success  = true
+        };
+    }
+}
+#endif
+

src/core/DigitalData.MessagingService.Application/OAuth2/Queries/GetOAuth2AuthorizationUrlQuery.cs

@@ -0,0 +1,46 @@
+#if NET
+using DigitalData.MessagingService.Application.Common.Interfaces;
+using DigitalData.MessagingService.Application.Common.Interfaces.Repositories;
+using DigitalData.MessagingService.Domain.Entities;
+using DigitalData.MessagingService.Domain.Enums;
+using DigitalData.MessagingService.Domain.Exceptions;
+using MediatR;
+
+namespace DigitalData.MessagingService.Application.OAuth2.Queries;
+
+/// <summary>
+/// Returns the authorization URL the user must visit to grant OAuth2 access.
+/// Supported for providers that require user-delegated access (e.g. Google).
+/// </summary>
+public record GetOAuth2AuthorizationUrlQuery : IRequest<string>
+{
+    /// <summary>
+    /// ID of the email account to authorize.
+    /// </summary>
+    public required string Username { get; init; }
+
+    /// <summary>
+    /// The redirect URI registered with the OAuth2 provider.
+    /// Must exactly match the URI configured in the provider's developer console.
+    /// </summary>
+    public required string RedirectUri { get; init; }
+}
+
+public class GetOAuth2AuthorizationUrlQueryHandler(
+    IRepository<EmailAccount> Repo,
+    IOAuth2AuthorizationService AuthService) : IRequestHandler<GetOAuth2AuthorizationUrlQuery, string>
+{
+    public async Task<string> Handle(GetOAuth2AuthorizationUrlQuery request, CancellationToken cancellationToken)
+    {
+        var account = await Repo.FindFirstAsync(e => e.Username == request.Username, cancellationToken)
+            ?? throw new NotFoundException($"No email account found with username: {request.Username}.");
+
+        if (account.OAuth2Provider == OAuth2Provider.None)
+            throw new BadRequestException(
+                $"Account '{account.Username}' (Id: {account.Id}) has no OAuth2 provider configured. " +
+                $"Set OAuth2Provider to a supported value (e.g. Google).");
+
+        return AuthService.GetAuthorizationUrl(account, request.RedirectUri);
+    }
+}
+#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>

src/core/DigitalData.MessagingService.Domain/Entities/EmailAccount.cs

@@ -0,0 +1,145 @@
+using System.ComponentModel.DataAnnotations;
+using System.ComponentModel.DataAnnotations.Schema;
+using DigitalData.MessagingService.Domain.Enums;
+
+namespace DigitalData.MessagingService.Domain.Entities;
+
+/// <summary>
+/// DTO for a single email account configuration.
+/// </summary>
+[Table("EMAIL_ACCOUNT")]
+public class EmailAccount
+{
+    /// <summary>
+    /// Logical name to identify this account (e.g. "default", "support").
+    /// </summary>
+    [Key]
+    [DatabaseGenerated(DatabaseGeneratedOption.Identity)]
+    [Column("ID", TypeName = "int")]
+    public int Id { get; set; }
+
+    [Required]
+    [MaxLength(256)]
+    [Column("USERNAME", TypeName = "nvarchar(256)")]
+#if NET
+    public required string Username { get; set; }
+#else
+    public string Username { get; set; } = null!;
+#endif
+
+    [Required]
+    [MaxLength(512)]
+    [Column("PASSWORD", TypeName = "nvarchar(512)")]
+#if NET
+    public required string Password { get; set; }
+#else
+    public string Password { get; set; } = null!;
+#endif
+
+    [Required]
+    [MaxLength(256)]
+    [Column("SMTP_SERVER", TypeName = "nvarchar(256)")]
+#if NET
+    public required string SmtpServer { get; set; }
+#else
+    public string SmtpServer { get; set; } = null!;
+#endif
+
+    [Column("SMTP_PORT", TypeName = "int")]
+    public int SmtpPort { get; set; }
+
+    [Column("SMTP_USE_SSL", TypeName = "bit")]
+    public bool SmtpUseSsl { get; set; }
+
+    [Column("USE_OAUTH2", TypeName = "bit")]
+    public bool UseOAuth2 { get; set; }
+
+    /// <summary>
+    /// IMAP server hostname (e.g. "imap.example.com").
+    /// Leave empty when this account is send-only.
+    /// </summary>
+    [MaxLength(256)]
+    [Column("IMAP_SERVER", TypeName = "nvarchar(256)")]
+    public string? ImapServer { get; set; }
+
+    /// <summary>
+    /// IMAP server port (993 for SSL, 143 for plain/STARTTLS).
+    /// </summary>
+    [Column("IMAP_PORT", TypeName = "int")]
+    public int ImapPort { get; set; } = 993;
+
+    /// <summary>
+    /// Use SSL/TLS when connecting to the IMAP server.
+    /// </summary>
+    [Column("IMAP_USE_SSL", TypeName = "bit")]
+    public bool ImapUseSsl { get; set; } = true;
+
+    /// <summary>
+    /// POP3 server hostname (e.g. "pop.example.com").
+    /// Leave empty when this account does not use POP3.
+    /// </summary>
+    [MaxLength(256)]
+    [Column("POP3_SERVER", TypeName = "nvarchar(256)")]
+    public string? Pop3Server { get; set; }
+
+    /// <summary>
+    /// POP3 server port (995 for SSL, 110 for plain).
+    /// </summary>
+    [Column("POP3_PORT", TypeName = "int")]
+    public int Pop3Port { get; set; } = 995;
+
+    /// <summary>
+    /// Use SSL/TLS when connecting to the POP3 server.
+    /// </summary>
+    [Column("POP3_USE_SSL", TypeName = "bit")]
+    public bool Pop3UseSsl { get; set; } = true;
+
+    /// <summary>
+    /// OAuth2 client ID (required when <see cref="UseOAuth2"/> is true).
+    /// </summary>
+    [MaxLength(512)]
+    [Column("OAUTH2_CLIENT_ID", TypeName = "nvarchar(512)")]
+    public string? OAuth2ClientId { get; set; }
+
+    /// <summary>
+    /// OAuth2 client secret (required when <see cref="UseOAuth2"/> is true).
+    /// For Microsoft: the app registration client secret value from Azure Portal.
+    /// For Google: the client secret from Google Cloud Console credentials JSON.
+    /// </summary>
+    [MaxLength(512)]
+    [Column("OAUTH2_CLIENT_SECRET", TypeName = "nvarchar(512)")]
+    public string? OAuth2ClientSecret { get; set; }
+
+    /// <summary>
+    /// OAuth2 refresh token (Google only).
+    /// Obtained once via the OAuth2 authorization flow (e.g. OAuth Playground).
+    /// Used to exchange for short-lived access tokens without user interaction.
+    /// Leave empty for Microsoft — MSAL handles token refresh internally.
+    /// </summary>
+    [MaxLength(1024)]
+    [Column("OAUTH2_REFRESH_TOKEN", TypeName = "nvarchar(1024)")]
+    public string? OAuth2RefreshToken { get; set; }
+
+    /// <summary>
+    /// OAuth2 tenant ID (e.g. for Microsoft 365: tenant GUID or "common").
+    /// Not required for Google — leave empty.
+    /// </summary>
+    [MaxLength(256)]
+    [Column("OAUTH2_TENANT_ID", TypeName = "nvarchar(256)")]
+    public string? OAuth2TenantId { get; set; }
+
+    /// <summary>
+    /// Identifies which OAuth2 identity provider to use when <see cref="UseOAuth2"/> is true.
+    /// Determines which token acquisition strategy is applied.
+    /// </summary>
+    [Column("OAUTH2_PROVIDER", TypeName = "int")]
+    public OAuth2Provider OAuth2Provider { get; set; } = OAuth2Provider.None;
+
+    /// <summary>
+    /// The protocol used to receive (sync) incoming emails.
+    /// When set to <see cref="IncomingProtocol.None"/>, this account is send-only and will be skipped by the sync worker.
+    /// Takes priority over the presence of <see cref="ImapServer"/> or <see cref="Pop3Server"/>.
+    /// </summary>
+    [Column("INCOMING_PROTOCOL", TypeName = "int")]
+    public IncomingProtocol IncomingProtocol { get; set; } = IncomingProtocol.None;
+}

src/core/DigitalData.MessagingService.Domain/Entities/EmailAttachment.cs

@@ -0,0 +1,83 @@
+using System.ComponentModel.DataAnnotations;
+using System.ComponentModel.DataAnnotations.Schema;
+
+namespace DigitalData.MessagingService.Domain.Entities;
+
+/// <summary>
+/// Represents a single email attachment.
+/// </summary>
+[Table("EMAIL_ATTACHMENT")]
+public sealed class EmailAttachment
+{
+    [Key]
+    [DatabaseGenerated(DatabaseGeneratedOption.Identity)]
+    [Column("ID", TypeName = "bigint")]
+#if NET
+    public long Id { get; init; }
+#else
+    public long Id { get; set; }
+#endif
+
+    /// <summary>
+    /// Display name of the attachment (e.g. "invoice.pdf").
+    /// </summary>
+    [Required]
+    [MaxLength(260)]
+    [Column("FILE_NAME", TypeName = "nvarchar(260)")]
+#if NETFRAMEWORK
+    public string FileName { get; set; } = null!;
+#else
+    public required string FileName { get; init; }
+#endif
+
+    /// <summary>
+    /// Raw content of the attachment.
+    /// </summary>
+    [Required]
+    [Column("CONTENT", TypeName = "varbinary(max)")]
+#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>
+    [Required]
+    [MaxLength(256)]
+    [Column("CONTENT_TYPE", TypeName = "nvarchar(256)")]
+    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>
+    [Column("IS_INLINE", TypeName = "bit")]
+    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>
+    [MaxLength(512)]
+    [Column("CONTENT_ID", TypeName = "nvarchar(512)")]
+    public string? ContentId { get; set; }
+
+    [ForeignKey(nameof(Email))]
+    [Column("EMAIL_ID", TypeName = "bigint")]
+#if NET
+    public long EmailId { get; init; }
+#else
+    public long EmailId { get; set; }
+#endif
+
+#if NET
+    public ReceivedEmail? Email { get; init; }
+#else
+    public ReceivedEmail? Email { get; set; }
+#endif
+}

src/core/DigitalData.MessagingService.Domain/Entities/ReceivedEmail.cs

@@ -0,0 +1,142 @@
+using System.ComponentModel.DataAnnotations;
+using System.ComponentModel.DataAnnotations.Schema;
+
+namespace DigitalData.MessagingService.Domain.Entities;
+
+/// <summary>
+/// Represents an email message received via IMAP.
+/// </summary>
+[Table("RECEIVED_EMAIL")]
+public sealed record ReceivedEmail
+{
+    [Key]
+    [DatabaseGenerated(DatabaseGeneratedOption.Identity)]
+    [Column("ID", TypeName = "bigint")]
+#if NET
+    public long Id { get; init; }
+#else
+    public long Id { get; set; }
+#endif
+
+    /// <summary>
+    /// Unique identifier of the message on the IMAP server (UID).
+    /// </summary>
+    [Column("UID", TypeName = "bigint")]
+#if NET
+    public long Uid { get; init; }
+#else
+    public long Uid { get; set; }
+#endif
+
+    /// <summary>
+    /// Sender address (From header).
+    /// </summary>
+    [Required]
+    [MaxLength(512)]
+    [Column("FROM", TypeName = "nvarchar(512)")]
+#if NET
+    public string From { get; init; } = string.Empty;
+#else
+    public string From { get; set; } = string.Empty;
+#endif
+
+    /// <summary>
+    /// Recipient addresses (To header).
+    /// </summary>
+    [Column("TO", TypeName = "nvarchar(max)")]
+#if NET
+    public List<string> To { get; init; } = [];
+#else
+    public List<string> To { get; set; } = [];
+#endif
+
+    /// <summary>
+    /// CC addresses.
+    /// </summary>
+    [Column("CC", TypeName = "nvarchar(max)")]
+#if NET
+    public List<string> Cc { get; init; } = [];
+#else
+    public List<string> Cc { get; set; } = [];
+#endif
+
+    /// <summary>
+    /// Email subject.
+    /// </summary>
+    [MaxLength(998)]
+    [Column("SUBJECT", TypeName = "nvarchar(998)")]
+#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>
+    [Column("TEXT_BODY", TypeName = "nvarchar(max)")]
+#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>
+    [Column("HTML_BODY", TypeName = "nvarchar(max)")]
+#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>
+    [Column("DATE", TypeName = "datetime2")]
+#if NET
+    public DateTime Date { get; init; }
+#else
+    public DateTime Date { get; set; }
+#endif
+
+    /// <summary>
+    /// Whether the message has been marked as seen/read on the server.
+    /// </summary>
+    [Column("IS_SEEN", TypeName = "bit")]
+#if NET
+    public bool IsSeen { get; init; }
+#else
+    public bool IsSeen { get; set; }
+#endif
+
+    [ForeignKey(nameof(Account))]
+    [Column("ACCOUNT_ID", TypeName = "int")]
+#if NET
+    public int AccountId { get; init; }
+#else
+    public int AccountId { get; set; }
+#endif
+
+    /// <summary>
+    /// Attachments included with this message.
+    /// </summary>
+#if NET
+    public IEnumerable<EmailAttachment>? Attachments { get; init; }
+#else
+    public IEnumerable<EmailAttachment>? Attachments { get; set; }
+#endif
+
+#if NET
+    public EmailAccount? Account { get; init; }
+#else
+    public EmailAccount? Account { get; set; }
+#endif
+
+#if NET
+    public required string Folder { get; init; }
+#else
+    public string Folder { get; set; } = null!;
+#endif
+}

src/core/DigitalData.MessagingService.Domain/Enums/IncomingProtocol.cs

@@ -0,0 +1,34 @@
+namespace DigitalData.MessagingService.Domain.Enums;
+
+/// <summary>
+/// Specifies the protocol used to receive (sync) incoming emails for an account.
+/// </summary>
+public enum IncomingProtocol
+{
+    /// <summary>
+    /// No incoming protocol configured — account is send-only.
+    /// </summary>
+    None = 0,
+
+    /// <summary>
+    /// Sync emails via IMAP using username/password authentication.
+    /// </summary>
+    Imap = 1,
+
+    /// <summary>
+    /// Sync emails via POP3 using username/password authentication.
+    /// </summary>
+    Pop3 = 2,
+
+    /// <summary>
+    /// Sync emails via IMAP using OAuth2 (XOAUTH2) authentication.
+    /// Requires <c>UseOAuth2 = true</c> and valid OAuth2 credentials.
+    /// </summary>
+    ImapOAuth2 = 3,
+
+    /// <summary>
+    /// Sync emails via POP3 using OAuth2 (XOAUTH2) authentication.
+    /// Requires <c>UseOAuth2 = true</c> and valid OAuth2 credentials.
+    /// </summary>
+    Pop3OAuth2 = 4,
+}

src/core/DigitalData.MessagingService.Domain/Enums/OAuth2Provider.cs

@@ -0,0 +1,29 @@
+namespace DigitalData.MessagingService.Domain.Enums;
+
+/// <summary>
+/// Identifies the OAuth2 identity provider used to acquire access tokens.
+/// Only relevant when <c>UseOAuth2 = true</c>.
+/// </summary>
+public enum OAuth2Provider
+{
+    /// <summary>
+    /// No OAuth2 provider — account uses plain username/password authentication.
+    /// </summary>
+    None = 0,
+
+    /// <summary>
+    /// Microsoft identity platform (Azure AD / Microsoft 365 / Exchange Online).
+    /// Uses MSAL with the client credentials flow against
+    /// <c>https://login.microsoftonline.com/{tenant}</c>.
+    /// Requires <c>OAuth2ClientId</c>, <c>OAuth2ClientSecret</c> and <c>OAuth2TenantId</c>.
+    /// </summary>
+    Microsoft = 1,
+
+    /// <summary>
+    /// Google identity platform (Gmail / Google Workspace).
+    /// Uses the service-account or OAuth2 client credentials flow against
+    /// <c>https://oauth2.googleapis.com/token</c>.
+    /// Requires <c>OAuth2ClientId</c> and <c>OAuth2ClientSecret</c>.
+    /// </summary>
+    Google = 2,
+}

src/core/DigitalData.MessagingService.Domain/Exceptions/AuthenticationFailedException.cs

@@ -0,0 +1,16 @@
+namespace DigitalData.MessagingService.Domain.Exceptions
+{
+    /// <summary>
+    /// Exception thrown when OAuth2 authentication fails.
+    /// </summary>
+    public class AuthenticationFailedException : Exception
+    {
+        public AuthenticationFailedException(string message) : base(message)
+        {
+        }
+
+        public AuthenticationFailedException(string message, Exception innerException) : base(message, innerException)
+        {
+        }
+    }
+}

src/core/DigitalData.MessagingService.Domain/Exceptions/BadRequestException.cs

@@ -0,0 +1,21 @@
+namespace DigitalData.MessagingService.Domain.Exceptions
+{
+    /// <summary>
+    /// Exception thrown when a requested entity is not found.
+    /// </summary>
+    public class BadRequestException : Exception
+    {
+        public BadRequestException(string entityName, object key) : base($"{entityName} with key '{key}' was not found.")
+        {
+        }
+
+        public BadRequestException(string message) : base(message)
+        {
+        }
+
+        public BadRequestException(string message, Exception innerException)
+            : base(message, innerException)
+        {
+        }
+    }
+}

src/core/DigitalData.MessagingService.Domain/Exceptions/NotFoundException.cs

@@ -0,0 +1,21 @@
+namespace DigitalData.MessagingService.Domain.Exceptions
+{
+    /// <summary>
+    /// Exception thrown when a requested entity is not found.
+    /// </summary>
+    public class NotFoundException : Exception
+    {
+        public NotFoundException(string entityName, object key) : base($"{entityName} with key '{key}' was not found.")
+        {
+        }
+
+        public NotFoundException(string message) : base(message)
+        {
+        }
+
+        public NotFoundException(string message, Exception innerException)
+            : base(message, innerException)
+        {
+        }
+    }
+}

src/infrastructure/DigitalData.MessagingService.Infrastructure/DependencyInjection.cs

@@ -0,0 +1,98 @@
+using AutoMapper;
+using DigitalData.MessagingService.Application.Common.Interfaces;
+using DigitalData.MessagingService.Application.Common.Interfaces.Repositories;
+using DigitalData.MessagingService.Infrastructure.Mappings;
+using DigitalData.MessagingService.Infrastructure.Persistence;
+using DigitalData.MessagingService.Infrastructure.Queue;
+using DigitalData.MessagingService.Infrastructure.Repositories;
+using DigitalData.MessagingService.Infrastructure.Services;
+using DigitalData.MessagingService.Infrastructure.Services.Background;
+using DigitalData.MessagingService.Publisher;
+using DigitalData.MessagingService.RabbitMQ;
+using Microsoft.AspNetCore.DataProtection;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Hosting;
+
+namespace DigitalData.MessagingService.Infrastructure;
+
+/// <summary>
+/// Dependency injection configuration for Infrastructure layer
+/// </summary>
+public static class DependencyInjection
+{
+    /// <summary>
+    /// Adds Infrastructure layer services to the DI container
+    /// </summary>
+    public static IServiceCollection AddInfrastructure(
+        this IServiceCollection services,
+        IConfiguration configuration)
+    {
+        // --- External Services ---
+        // OAuth2 token services — provider-specific implementations registered separately,
+        // dispatcher is the single IOAuth2TokenService consumed by all other services.
+        services.AddSingleton<MicrosoftOAuth2TokenService>();
+        services.AddSingleton<GoogleOAuth2TokenService>();
+        services.AddSingleton<IOAuth2TokenService, OAuth2TokenServiceDispatcher>();
+
+        services.AddHttpClient(nameof(GoogleOAuth2TokenService));
+        services.AddHttpClient(nameof(GoogleOAuth2AuthorizationService));
+        services.AddSingleton<IOAuth2AuthorizationService, GoogleOAuth2AuthorizationService>();
+
+        // Email Service - SMTP outbound (Limilabs Mail.dll) - OAuth2 aware
+        services.AddSingleton<LimilabsEmailService>();
+        services.AddSingleton<IEmailService>(sp => sp.GetRequiredService<LimilabsEmailService>());
+
+        // Email Service - IMAP inbound (Limilabs Mail.dll)
+        services.AddScoped<IImapEmailService, LimilabsImapEmailService>();
+
+        // Email Service - POP3 inbound (Limilabs Mail.dll)
+        services.AddScoped<IPop3EmailService, LimilabsPop3EmailService>();
+
+        // PDF Processing Service (using DevExpress.Pdf)
+        services.AddScoped<IPdfProcessingService, DevExpressPdfProcessingService>();
+        
+        // Encryption Service (using Data Protection API - Singleton, thread-safe)
+        services.AddSingleton<IEncryptionService, DataProtectionEncryptionService>();
+
+        // --- Email Queue (RabbitMQ) ---
+        services.AddSingleton<SendingEmailConsumerPool>();
+        services.AddMessagingServicePublisher();
+
+        // --- RabbitMQ Configuration ---
+        services.AddRabbitMqConnectionFactory(configuration);
+
+        // --- Data Protection (for encryption) ---
+        services.AddDataProtection()
+            .PersistKeysToFileSystem(new DirectoryInfo(@"C:\ProgramData\EmailService\Keys"))
+            .SetApplicationName("MessagingService");
+
+        // Register Background Workers
+        services.AddHostedService<AsyncInitWorker>();
+        services.AddHostedService<EmailSyncWorker>();
+
+        services.AddSingleton<IEmailSyncService>(p =>
+        {
+            var hostedServices = p.GetRequiredService<IEnumerable<IHostedService>>();
+            var emailSyncWorkers = hostedServices.OfType<EmailSyncWorker>();
+            return emailSyncWorkers.FirstOrDefault() ?? throw new InvalidOperationException("EmailSyncWorker is not registered.");
+        });
+
+        services.AddMemoryCache();
+
+        // --- Database (InMemory) ---
+        services.AddDbContext<MessagingServiceDbContext>(options =>
+            options.UseInMemoryDatabase("MessagingServiceDb"));
+
+        services.AddScoped(typeof(IRepository<>), typeof(Repository<>));
+
+        services.AddScoped<IReceivedEmailRepository, ReceivedEmailRepository>();
+
+        // AutoMapper - Register entity self-mappings (T -> T) for generic repository
+        services.AddAutoMapper(config => config.AddMaps(typeof(EntitySelfMappingProfile).Assembly));
+
+        return services;
+    }
+}
+