Refactor test namespaces to EnvelopeGenerator.Tests.Application

All test files and utilities now use the EnvelopeGenerator.Tests.Application namespace for improved organization and clarity. No functional changes were made; updates are limited to namespaces and using directives. This makes it explicit that these are application-level tests and related helpers.

EnvelopeGenerator.Tests/Application/DocSignedNotificationTests.cs

@@ -0,0 +1,63 @@
+using AutoMapper;
+using DigitalData.Core.Abstraction.Application.Repository;
+using DigitalData.Core.Infrastructure;
+using DigitalData.EmailProfilerDispatcher.Abstraction.Entities;
+using EnvelopeGenerator.Application.Common.Dto.EnvelopeReceiver;
+using EnvelopeGenerator.Application.Common.Notifications.DocSigned;
+using EnvelopeGenerator.Application.Common.Notifications.DocSigned.Handlers;
+using EnvelopeGenerator.Domain.Entities;
+using Microsoft.Extensions.DependencyInjection;
+
+namespace EnvelopeGenerator.Tests.Application;
+
+public class DocSignedNotificationTests : TestBase
+{
+    protected IMapper _mapper;
+
+    protected override void ConfigureServices(IServiceCollection services)
+    {
+        services.AddTransient<SendSignedMailHandler>();
+
+        // overwrite EmailOutRepository
+        services.AddDbRepository(opt => opt.RegisterEntity<Fake.EGDbContext2Prod, EmailOut>(ctx => ctx.EMailOuts));
+    }
+
+    public override async Task Setup()
+    {
+        await base.Setup();
+        _mapper = Host.Services.GetRequiredService<IMapper>();
+    }
+
+    [TestCase("h.tek@digitaldata.works", TestName = "SendSignedMailHandler_ShouldNotThrow_WithValidEmail")]
+    public async Task SendSignedMailHandler_ShouldNotThrow(string emailAddress)
+    {
+        /// Assert
+        CancellationToken cancel = new();
+        var mediator = Mediator;
+
+        // Create envelope
+        var envCmd = this.CreateEnvelopeCommand(User.Id);
+        var env = await mediator.Send(envCmd, cancel);
+
+        // Create receiver
+        var rcvCmd = this.CreateReceiverCommand(emailAddress);
+        (var rcv, _) = await mediator.Send(rcvCmd, cancel);
+
+        // Create envelope receiver
+        var envRcv = this.CreateEnvelopeReceiver(env!.Id, rcv.Id);
+
+        var repo = GetRepository<EnvelopeReceiver>();
+
+        envRcv = await repo.CreateAsync(envRcv, cancel);
+        var envRcvDto = _mapper.Map<EnvelopeReceiverDto>(envRcv);
+
+        var annots = Services.GetRequiredService<PsPdfKitAnnotation>();
+
+        var docSignedNtf = envRcvDto.ToDocSignedNotification(annots);
+
+        var sendSignedMailHandler = Host.Services.GetRequiredService<SendSignedMailHandler>();
+
+        // Act + Assert
+        Assert.DoesNotThrowAsync(async () => await sendSignedMailHandler.Handle(docSignedNtf, cancel));
+    }
+}

EnvelopeGenerator.Tests/Application/Fake.cs

@@ -0,0 +1,312 @@
+using Bogus;
+using CommandDotNet;
+using DigitalData.Core.Abstraction.Application.Repository;
+using DigitalData.UserManager.Domain.Entities;
+using EnvelopeGenerator.Application;
+using EnvelopeGenerator.Application.Common.Configurations;
+using EnvelopeGenerator.Application.Common.Extensions;
+using EnvelopeGenerator.Application.EnvelopeReceivers.Commands;
+using EnvelopeGenerator.Application.Envelopes.Commands;
+using EnvelopeGenerator.Application.Histories.Commands;
+using EnvelopeGenerator.Application.Receivers.Commands;
+using EnvelopeGenerator.Application.Users.Commands;
+using EnvelopeGenerator.Domain.Constants;
+using EnvelopeGenerator.Domain.Entities;
+using EnvelopeGenerator.Infrastructure;
+using EnvelopeGenerator.Tests.Application;
+using MediatR;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Hosting;
+using Microsoft.Extensions.Logging;
+using Microsoft.Extensions.Options;
+using QuestPDF.Fluent;
+using QuestPDF.Infrastructure;
+
+namespace EnvelopeGenerator.Tests.Application;
+
+public class Fake
+{
+    public static readonly Faker Provider = new("de");
+
+    public static Host CreateHost(Action<IServiceCollection>? configureServices = null) => Microsoft.Extensions.Hosting.Host.CreateDefaultBuilder()
+        .ConfigureAppConfiguration((context, config) =>
+        {
+            // add appsettings.json
+            config.SetBasePath(Directory.GetCurrentDirectory());
+            config.AddJsonFile("appsettings.json", optional: false, reloadOnChange: true);
+        })
+        .ConfigureServices((context, services) =>
+        {
+            IConfiguration configuration = context.Configuration;
+
+            // add Application and Infrastructure services
+#pragma warning disable CS0618
+            services.AddEnvelopeGeneratorServices(configuration);
+
+            var cnnStrName = "Default";
+
+            var connStr = context.Configuration.GetConnectionString(cnnStrName)
+                ?? throw new InvalidOperationException($"Connection string '{cnnStrName}' is missing in the application configuration.");
+
+            services.AddEnvelopeGeneratorInfrastructureServices(opt =>
+            {
+                opt.AddDbContext(dbCtxOpt => dbCtxOpt.UseInMemoryDatabase("EnvelopeGeneratorTestDb"));
+
+                opt.AddDbTriggerParams(context.Configuration);
+
+                opt.AddDbContext((provider, options) =>
+                {
+                    var logger = provider.GetRequiredService<ILogger<EGDbContext>>();
+                    options.UseSqlServer(connStr)
+                            .LogTo(log => logger.LogInformation("{log}", log), LogLevel.Trace)
+                            .EnableSensitiveDataLogging()
+                            .EnableDetailedErrors();
+                });
+                opt.AddSQLExecutor(executor => executor.ConnectionString = connStr);
+
+            });
+
+            var prodCnnStr = context.Configuration.GetConnectionString("Default");
+            services.AddDbContext<EGDbContext2Prod>(opt => opt.UseSqlServer(prodCnnStr));
+
+            // add custom services
+            configureServices?.Invoke(services);
+#pragma warning restore CS0618
+        })
+        .Build()
+        .ToFake();
+
+    public class Host : IHost
+    {
+        #region Root
+        private readonly IHost _root;
+
+        public Host(IHost root)
+        {
+            _root = root;
+        }
+
+        public IServiceProvider Services => _root.Services;
+
+        public void Dispose()
+        {
+            _root.Dispose();
+        }
+
+        public Task StartAsync(CancellationToken cancel = default)
+        {
+            return _root.StartAsync(cancel);
+        }
+
+        public Task StopAsync(CancellationToken cancel = default)
+        {
+            return _root.StopAsync(cancel);
+        }
+        #endregion
+
+        #region Shortcuts
+        public IMediator Mediator => Services.GetRequiredService<IMediator>();
+
+        public IRepository<TEntity> GetRepository<TEntity>() => Services.GetRequiredService<IRepository<TEntity>>();
+
+        public async Task<Host> AddSamples()
+        {
+            await AddSampleReceivers();
+            await AddSampleUser();
+            return this;
+        }
+        #endregion
+
+        #region Sample Receivers
+        public List<(int Id, string EmailAddress)> _sampleReceivers = new();
+
+        public IEnumerable<(int Id, string EmailAddress)> SampleReceivers
+            => _sampleReceivers.Any()
+                ? _sampleReceivers
+                : throw new InvalidOperationException(
+                    "No sample receivers have been initialized. Call AddSampleReceivers() before accessing this property."
+                );
+
+        public async Task<Host> AddSampleReceivers()
+        {
+            var mediator = Mediator;
+            foreach (var cmd in Provider.CreateReceiverCommands())
+            {
+                var (receiver, _) = await mediator.Send(cmd);
+                _sampleReceivers.Add((receiver.Id, cmd.EmailAddress));
+            }
+            return this;
+        }
+        #endregion
+
+        #region Sample User
+        private User? _user;
+
+        public User User => _user ?? throw new InvalidOperationException(
+            "The 'User' instance has not been initialized. Call AddSampleUser() before accessing this property.");
+
+        public async Task<Host> AddSampleUser()
+        {
+            var repo = GetRepository<User>();
+            var cmd = Provider.CreateUserCommand();
+            _user = await repo.CreateAsync(cmd);
+            return this;
+        }
+        #endregion
+    }
+
+    /// <summary>
+    /// Represents a mock database context that inherits from <see cref="EGDbContext"/>.
+    /// This context is intended for testing purposes while connecting to the production database.
+    /// </summary>
+    public class EGDbContext2Prod : EGDbContextBase
+    {
+        public EGDbContext2Prod(DbContextOptions<EGDbContext2Prod> options, IOptions<DbTriggerParams> triggerParamOptions, ILogger<EGDbContext>? logger = null) : base(options, triggerParamOptions, logger)
+        {
+        }
+    }
+}
+
+public static class Extensions
+{
+    public static Fake.Host ToFake(this IHost host) => new(host);
+
+    public static T PickEnum<T>(this Faker faker) where T : struct, Enum
+    {
+        var values = Enum.GetValues(typeof(T));
+        var index = faker.Random.Int(0, values.Length - 1);
+        return (T)values.GetValue(index)!;
+    }
+
+    #region Receiver Command
+    public static CreateReceiverCommand CreateReceiverCommand(this Faker fake, string? emailAddress = null) => new()
+    {
+        EmailAddress = emailAddress ?? fake.Internet.Email(),
+    };
+
+    public static List<CreateReceiverCommand> CreateReceiverCommands(this Faker fake, int minCount = 10, int maxCount = 20)
+        => Enumerable.Range(0, fake.Random.Number(minCount, maxCount))
+            .Select(_ => fake.CreateReceiverCommand())
+            .ToList();
+    #endregion
+
+    #region Envelope
+    public static CreateEnvelopeCommand CreateEnvelopeCommand(this Faker fake, int userId) => new()
+    {
+        Message = fake.Lorem.Paragraph(fake.Random.Number(2, 5)),
+        Title = fake.Lorem.Words(fake.Random.Number(3, 4)).Join(" "),
+        UserId = userId,
+        UseSQLExecutor = false
+    };
+
+    public static List<CreateEnvelopeCommand> CreateEnvelopeCommands(this Faker fake, params int[] userIDs)
+        => Enumerable.Range(0, userIDs.Length)
+            .Select(fake.CreateEnvelopeCommand)
+            .ToList();
+
+    public static Envelope CreateEnvelope(this Faker faker, int userId, bool tfaEnabled = false) => new()
+    {
+        Id = faker.Random.Number(1, 1000),
+        UserId = userId,
+        Status = EnvelopeStatus.EnvelopeCreated,
+        Uuid = Guid.NewGuid().ToString(),
+        Title = faker.Lorem.Paragraph(faker.Random.Number(1, 2)),
+        Message = faker.Lorem.Paragraph(faker.Random.Number(2, 5)),
+        TfaEnabled = tfaEnabled,
+        AddedWhen = DateTime.UtcNow,
+        CertificationType = (int)CertificationType.AdvancedElectronicSignature,
+        UseAccessCode = false,
+        ContractType = (int)ContractType.Contract,
+        Language = "de",
+        SendReminderEmails = false,
+        Comment = faker.Lorem.Sentence(10),
+        DocResult = faker.CreatePdfAsByte()
+    };
+    #endregion
+
+    #region Document
+    public static byte[] CreatePdfAsByte(this Faker faker)
+    {
+        string name = faker.Name.FullName();
+        string address = faker.Address.FullAddress();
+        string lorem = faker.Lorem.Paragraphs(2);
+
+        QuestPDF.Settings.License = LicenseType.Community;
+        var document = QuestPDF.Fluent.Document.Create(container =>
+        {
+            container.Page(page =>
+            {
+                page.Margin(50);
+                page.Header().Text("Random PDF").FontSize(20).Bold();
+                page.Content().Column(col =>
+                {
+                    col.Item().Text($"Vor- und Nachname: {name}");
+                    col.Item().Text($"Adresse: {address}");
+                    col.Item().Text(lorem);
+                });
+            });
+        });
+
+        using var ms = new MemoryStream();
+        document.GeneratePdf(ms);
+        return ms.ToArray();
+    }
+
+    public static string CreatePdfAsBase64(this Faker faker) => Convert.ToBase64String(faker.CreatePdfAsByte());
+
+    public static DocumentCreateCommand CreateDocumentCommand(this Faker faker) => new()
+    {
+        DataAsBase64 = faker.CreatePdfAsBase64()
+    };
+
+    public static List<DocumentCreateCommand> CreateDocumentCommands(this Faker fake, int minCount = 10, int maxCount = 20)
+    => Enumerable.Range(0, fake.Random.Number(minCount, maxCount))
+        .Select(_ => fake.CreateDocumentCommand())
+        .ToList();
+    #endregion
+
+    #region Envelope Receiver
+    public static EnvelopeReceiver CreateEnvelopeReceiver(this Faker faker, int envelopeId, int receiverId) => new()
+    {
+        EnvelopeId = envelopeId,
+        ReceiverId = receiverId,
+        Status = ReceiverStatus.Unsigned,
+        AddedWhen = DateTime.UtcNow,
+        AccessCode = faker.Random.Number(1000, 9999).ToString(),
+        ChangedWhen = DateTime.UtcNow,
+        CompanyName = faker.Company.CompanyName(),
+        JobTitle = faker.Name.JobTitle(),
+        Name = faker.Name.FullName(),
+    };
+    #endregion
+
+    #region History
+    public static CreateHistoryCommand CreateHistoryCommand(this Faker fake, string key, EnvelopeStatus? status = null)
+    {
+        return new()
+        {
+            Status = status ?? fake.PickEnum<EnvelopeStatus>(),
+            Comment = fake.Lorem.Sentence(),
+            Key = key,
+        };
+    }
+    #endregion
+
+    #region User Command
+    public static CreateUserCommand CreateUserCommand(this Faker fake) => new()
+    {
+        Prename = fake.Name.FirstName(),
+        Name = fake.Name.LastName(),
+        Username = fake.Internet.UserName(),
+        Shortname = fake.Random.String2(3, 8),
+        Email = fake.Internet.Email()
+    };
+
+    public static List<CreateUserCommand> CreateUserCommands(this Faker fake, int minCount = 10, int maxCount = 20)
+        => Enumerable.Range(0, fake.Random.Number(minCount, maxCount))
+            .Select(_ => fake.CreateUserCommand())
+            .ToList();
+    #endregion
+}

EnvelopeGenerator.Tests/Application/HistoryTests.cs

@@ -0,0 +1,119 @@
+using EnvelopeGenerator.Application.Common.Dto.History;
+using EnvelopeGenerator.Application.Common.Extensions;
+using EnvelopeGenerator.Application.Histories.Commands;
+using EnvelopeGenerator.Application.Histories.Queries;
+using EnvelopeGenerator.Domain.Constants;
+using EnvelopeGenerator.Domain.Entities;
+using Microsoft.Extensions.DependencyInjection;
+
+namespace EnvelopeGenerator.Tests.Application;
+
+[TestFixture]
+public class HistoryTests : TestBase
+{
+    protected override void ConfigureServices(IServiceCollection services)
+    {
+    }
+
+    [SetUp]
+    public override Task Setup()
+    {
+        return base.Setup();
+    }
+
+    [TearDown]
+    public override void TearDown()
+    {
+        base.TearDown();
+    }
+
+    [Test]
+    public async Task CreateHistory_And_ReadHistory_Should_Work()
+    {
+        /// Arrange
+        CancellationToken cancel = default;
+
+        // Create envelope
+        var envelope = FakeEnvelope;
+        envelope = await GetRepository<Envelope>().CreateAsync(envelope, cancel);
+
+        // Create receiver
+        var createReceiverCmd = this.CreateReceiverCommand();
+        (var receiver, _) = await Mediator.Send(createReceiverCmd);
+
+        // Create envelope receiver
+        var envRcv = this.CreateEnvelopeReceiver(envelope.Id, receiver.Id);
+        envRcv = await GetRepository<EnvelopeReceiver>().CreateAsync(envRcv, cancel);
+
+        var key = (envelope.Uuid, receiver.Signature).ToEnvelopeKey();
+
+        var createCmd = Fake.Provider.CreateHistoryCommand(key);
+
+        // Act
+        var hist = await Mediator.Send(createCmd);
+
+        // Assert
+        Assert.That(hist, Is.Not.Null);
+    }
+
+    [Test]
+    public async Task ReadHistory_Should_Filter_By_Status()
+    {
+        /// Arrange
+        CancellationToken cancel = default;
+
+        // Create envelope
+        var envelope = FakeEnvelope;
+        envelope = await GetRepository<Envelope>().CreateAsync(envelope, cancel);
+
+        // Create receiver
+        var createReceiverCmd = this.CreateReceiverCommand();
+        (var receiver, _) = await Mediator.Send(createReceiverCmd);
+
+        // Create envelope receiver
+        var envRcv = this.CreateEnvelopeReceiver(envelope.Id, receiver.Id);
+        envRcv = await GetRepository<EnvelopeReceiver>().CreateAsync(envRcv, cancel);
+
+        var createCmd1 = new CreateHistoryCommand
+        {
+            EnvelopeId = envelope.Id,
+            UserReference = receiver.EmailAddress,
+            Status = EnvelopeStatus.AccessCodeRequested
+        };
+
+        var createCmd2 = new CreateHistoryCommand
+        {
+            EnvelopeId = envelope.Id,
+            UserReference = receiver.EmailAddress,
+            Status = EnvelopeStatus.EnvelopeCompletelySigned
+        };
+
+        await Mediator.Send(createCmd1, cancel);
+        await Mediator.Send(createCmd2, cancel);
+
+        // Act
+        var readQuery = new ReadHistoryQuery()
+        {
+            EnvelopeId = envelope.Id,
+            Status = EnvelopeStatus.EnvelopeCompletelySigned
+        };
+        var result = await Mediator.Send(readQuery, cancel);
+        
+        // Assert
+        Assert.That(result, Has.Exactly(1).Items);
+        Assert.That(result, Has.All.Matches<HistoryDto>(r => r.Status == EnvelopeStatus.EnvelopeCompletelySigned));
+    }
+
+    [Test]
+    public async Task ReadHistory_Should_Return_Empty_When_No_Record()
+    {
+        // Act
+        var result = await Mediator.Send(new ReadHistoryQuery()
+        {
+            EnvelopeId = 9999
+        });
+
+        // Assert
+        Assert.That(result, Is.Empty);
+    }
+}

EnvelopeGenerator.Tests/Application/TestBase.cs

@@ -0,0 +1,143 @@
+using Bogus;
+using DigitalData.Core.Abstraction.Application.Repository;
+using DigitalData.UserManager.Domain.Entities;
+using EnvelopeGenerator.Application.Envelopes.Commands;
+using EnvelopeGenerator.Domain.Entities;
+using MediatR;
+using Microsoft.Extensions.DependencyInjection;
+
+namespace EnvelopeGenerator.Tests.Application;
+
+public abstract class TestBase : Faker
+{
+    protected Fake.Host Host;
+
+    protected User User => Host.User;
+
+    protected IMediator Mediator => Host.Mediator;
+
+    protected CreateEnvelopeCommand FakeCreateEnvelopeCommand => this.CreateEnvelopeCommand(Host.User.Id);
+
+    protected Envelope FakeEnvelope => this.CreateEnvelope(Host.User.Id);
+
+    protected IRepository<T> GetRepository<T>() where T : class => Host.GetRepository<T>();
+
+    protected IRepository Repository => Host.Services.GetRequiredService<IRepository>();
+
+    protected IServiceProvider Services => Host.Services;
+
+    protected abstract void ConfigureServices(IServiceCollection services);
+
+    [SetUp]
+    public virtual async Task Setup()
+    {
+        Host = Fake.CreateHost(ConfigureServices);
+        await Host.AddSamples();
+
+        var repo = GetRepository<EmailTemplate>();
+
+        // Add seed email templates
+        foreach (var temp in SeedEmailTemplates)
+            await repo.CreateAsync(temp);
+    }
+
+    [TearDown]
+    public virtual void TearDown()
+    {
+        Host.Dispose();
+    }
+
+    protected static List<EmailTemplate> SeedEmailTemplates => new()
+    {
+        new EmailTemplate
+        {
+            Id = 1,
+            Name = "DocumentReceived",
+            Body = "Guten Tag [NAME_RECEIVER],<br /> <br /><B><I> [NAME_SENDER]</I></B> hat Ihnen ein Dokument zum [SIGNATURE_TYPE] gesendet.<br /> <br /> Über den folgenden Link können Sie das Dokument einsehen und elektronisch unterschreiben: <a href=\"[LINK_TO_DOCUMENT]\">[LINK_TO_DOCUMENT_TEXT]</a><br /> <br /> [MESSAGE]<br /> <br /> Mit freundlichen Grüßen<br /> <br /> [NAME_PORTAL]",
+            Subject = "Dokument erhalten: '[DOCUMENT_TITLE]'",
+            AddedWhen = DateTime.Parse("2024-05-29 09:33:54.913"),
+            ChangedWhen = DateTime.Parse("2025-05-09 10:25:03.020")
+        },
+        new EmailTemplate
+        {
+            Id = 2,
+            Name = "DocumentDeleted",
+            Body = "Guten Tag [NAME_RECEIVER],<br /> <br /><B><I> [NAME_SENDER]</I></B> hat den Umschlag <B><I>'[DOCUMENT_TITLE]'</I></B> gelöscht/zurückgezogen.<br /><p> Begründung: <br /> <I>[REASON]</I> <p> <br /> Mit freundlichen Grüßen<br /> <br /> [NAME_PORTAL]",
+            Subject = "Umschlag zurückgezogen: '[DOCUMENT_TITLE]'",
+            AddedWhen = DateTime.Parse("2024-05-29 09:33:54.913"),
+            ChangedWhen = DateTime.Parse("2025-05-09 10:25:03.033")
+        },
+        new EmailTemplate
+        {
+            Id = 3,
+            Name = "DocumentSigned",
+            Body = "Guten Tag [NAME_RECEIVER],<br /> <br /> hiermit bestätigen wir Ihnen die erfolgreiche Signatur für den Vorgang <B><I>'[DOCUMENT_TITLE]'</I></B>.<br /> Wenn alle Vertragspartner unterzeichnet haben, erhalten Sie ebenfalls per email ein unterschriebenes Exemplar mit dem Signierungszertifikat! <br /> Mit freundlichen Grüßen<br /> <br /> [NAME_PORTAL]",
+            Subject = "Dokument unterschrieben: '[DOCUMENT_TITLE]'",
+            AddedWhen = DateTime.Parse("2024-05-29 09:33:54.913"),
+            ChangedWhen = DateTime.Parse("2025-05-09 10:25:03.033")
+        },
+        new EmailTemplate
+        {
+            Id = 4,
+            Name = "DocumentCompleted",
+            Body = "Guten Tag [NAME_RECEIVER],<br /> <br /> Der Signaturvorgang <B><I>'[DOCUMENT_TITLE]'</I></B> wurde erfolgreich abgeschlossen.<br /> <br /> Sie erhalten das Dokument mit einem detaillierten Ergebnisbericht als Anhang zu dieser Email.<br /> <br /> Mit freundlichen Grüßen<br /> <br /> [NAME_PORTAL]",
+            Subject = "Umschlag abgeschlossen: '[DOCUMENT_TITLE]'",
+            AddedWhen = DateTime.Parse("2024-05-29 09:33:54.913"),
+            ChangedWhen = DateTime.Parse("2025-05-09 10:25:03.050")
+        },
+        new EmailTemplate
+        {
+            Id = 5,
+            Name = "DocumentAccessCodeReceived",
+            Body = "Guten Tag [NAME_RECEIVER],<br /> <br /><B><I> [NAME_SENDER]</I></B> hat Ihnen ein Dokument zum [SIGNATURE_TYPE] gesendet. <br /> <br /> Verwenden Sie den folgenden Zugriffscode, um das Dokument einzusehen:<br /> <br /> [DOCUMENT_ACCESS_CODE]<br /> <br /> Mit freundlichen Grüßen<br /> <br /> [NAME_PORTAL]",
+            Subject = "Zugriffscode für Dokument erhalten: '[DOCUMENT_TITLE]'",
+            AddedWhen = DateTime.Parse("2024-05-29 09:33:54.913"),
+            ChangedWhen = DateTime.Parse("2025-05-09 10:25:03.050")
+        },
+        new EmailTemplate
+        {
+            Id = 6,
+            Name = "DocumentRejected_ADM",
+            Body = "Guten Tag [NAME_SENDER],<p><B><I>[NAME_RECEIVER]</I></B> hat den Umschlag <B><I>'[DOCUMENT_TITLE]'</I></B> mit folgendem Grund abgelehnt: <p> [REASON]  <p>Der Umschlag wurde auf den Status Rejected gesetzt. <p>  Mit freundlichen Grüßen<br /> <br /> [NAME_PORTAL]",
+            Subject = "'[DOCUMENT_TITLE]' - Unterzeichnungsvorgang zurückgezogen",
+            AddedWhen = DateTime.Parse("2024-06-06 10:25:14.917"),
+            ChangedWhen = DateTime.Parse("2025-05-09 10:25:03.067")
+        },
+        new EmailTemplate
+        {
+            Id = 9,
+            Name = "DocumentRejected_REC",
+            Body = "Guten Tag [NAME_RECEIVER], <p>Hiermit bestätigen wir Ihnen die Ablehnung des Unterzeichnungsvorganges <B><I>'[DOCUMENT_TITLE]'</I></B>!<p>Der Vertragsinhaber <B><I>[NAME_SENDER]</I></B> wurde über die Ablehnung informiert. <p>  Mit freundlichen Grüßen<br /> <br /> [NAME_PORTAL]",
+            Subject = "'[DOCUMENT_TITLE]' - Bestätigung Ablehnung",
+            AddedWhen = DateTime.Parse("2024-06-12 09:24:34.927"),
+            ChangedWhen = DateTime.Parse("2025-05-09 10:25:03.067")
+        },
+        new EmailTemplate
+        {
+            Id = 10,
+            Name = "DocumentRejected_REC_2",
+            Body = "Guten Tag [NAME_RECEIVER], <p>Der Unterzeichnungsvorganges <B><I>'[DOCUMENT_TITLE]'</I></B> wurde durch einen anderen Vertragspartner abgelehnt! Ihre notwendige Unterzeichnung wurde verworfen.<p> Der Vertragsinhaber <B><I>[NAME_SENDER]</I></B> wird sich bei Bedarf mit Ihnen in Verbindung setzen. <p>  Mit freundlichen Grüßen<br /> <br /> [NAME_PORTAL]",
+            Subject = "'[DOCUMENT_TITLE]' - Unterzeichnungsvorgang abgelehnt.",
+            AddedWhen = DateTime.Parse("2024-06-12 09:55:40.613"),
+            ChangedWhen = DateTime.Parse("2025-05-09 10:25:03.080")
+        },
+        new EmailTemplate
+        {
+            Id = 11,
+            Name = "DocumentShared",
+            Body = "Guten Tag,<br />  <br /><B><I>  [NAME_RECEIVER]</I></B> hat Ihnen ein Dokument zum Ansehen gesendet.<br />  <br />  Über den folgenden Link können Sie das Dokument einsehen: <a href=\"[LINK_TO_DOCUMENT]\">[LINK_TO_DOCUMENT_TEXT]</a><br /> <br />  <br />  Mit freundlichen Grüßen<br />  <br />  [NAME_PORTAL]",
+            Subject = "Dokument geteilt: '[DOCUMENT_TITLE]'",
+            AddedWhen = DateTime.Parse("2024-09-27 11:37:47.860"),
+            ChangedWhen = DateTime.Parse("2025-05-09 10:25:03.097")
+        },
+        new EmailTemplate
+        {
+            Id = 12,
+            Name = "TotpSecret",
+            Body = "Guten Tag,<br /> <br />Sie können auf Ihren Zwei-Faktor-Authentifizierungscode zugreifen, indem Sie den unten stehenden QR-Code mit einer beliebigen Authentifizierungs-App auf Ihrem Telefon scannen (Google Authenticator, Microsoft Authenticator usw.). Dieser Code ist bis zum [TFA_EXPIRATION] gültig.<br /> <br /> <img src=\"data:image/png;base64,[TFA_QR_CODE]\" style=\"width: 13rem; height: 13rem;\"><br /> <br /> <br /> Mit freundlichen Grüßen<br /> <br /> [NAME_PORTAL]",
+            Subject = "2-Faktor-Authentifizierung QR-Code",
+            AddedWhen = DateTime.Parse("2024-12-11 10:07:08.400"),
+            ChangedWhen = DateTime.Parse("2025-05-12 10:43:44.290")
+        }
+    };
+}