feat(EnvelopeReceiverReadOnly): Modelldaten und Dokument im Endpunkt sind so eingestellt, dass sie als Bytes geladen werden.

- erstellt dekodierende Erweiterungen.
 - Kodierungserweiterungen erstellt.
 - XSS-Erweiterungen in das Extensions-Paket verschoben.
 - EncodeTypes vom Paket Common in das Paket Constants verschoben.

EnvelopeGenerator.Common/Constants.vb

@@ -99,6 +99,12 @@
         DocumentShared
     End Enum
 
+    Public Enum EncodeType
+        EnvelopeReceiver
+        EnvelopeReceiverReadOnly
+        Undefined
+    End Enum
+
 #End Region
 
 #Region "Constants"

EnvelopeGenerator.Extensions/DecodingExtensions.cs

@@ -0,0 +1,152 @@
+using System.Text;
+using static EnvelopeGenerator.Common.Constants;
+
+namespace EnvelopeGenerator.Extensions
+{
+    public static class DecodingExtensions
+    {
+        /// <summary>
+        /// Validates whether a given string is a correctly formatted Base-64 encoded string.
+        /// </summary>
+        /// <remarks>
+        /// This method checks the string for proper Base-64 formatting, which includes validating
+        /// the length of the string (must be divisible by 4). It also checks each character to ensure
+        /// it belongs to the Base-64 character set (A-Z, a-z, 0-9, '+', '/', and '=' for padding).
+        /// The method ensures that padding characters ('=') only appear at the end of the string and
+        /// are in a valid configuration (either one '=' at the end if the string's length % 4 is 3,
+        /// or two '==' if the length % 4 is 2).
+        /// </remarks>
+        /// <param name="input">The Base-64 encoded string to validate.</param>
+        /// <returns>
+        /// <c>true</c> if the string is a valid Base-64 encoded string; otherwise, <c>false</c>.
+        /// </returns>
+        /// <example>
+        /// <code>
+        /// string testString = "TWFuIGlzIGRpc3Rpbmd1aXNoZWQsIG5vdCBvbmx5IGJ5IGhpcyByZWFzb24sIGJ1dCBieSB0aGlzIHNpbmd1bGFyIHBhc3Npb24gZnJvbSBvdGhlciBhbmltYWxzLCB3aGljaCBpcyBhIGx1c3Qgb2YgdGhlIG1pbmQsIHRoYXQgYnk=";
+        /// bool isValid = IsValidBase64String(testString);
+        /// Console.WriteLine(isValid); // Output: true
+        /// </code>
+        /// </example>
+        public static bool IsBase64String(this string input)
+        {
+            // Check if the string is null or empty
+            if (string.IsNullOrEmpty(input))
+            {
+                return false;
+            }
+
+            // Replace valid base-64 padding
+            input = input.Trim();
+            int mod4 = input.Length % 4;
+            if (mod4 > 0)
+            {
+                // Base-64 string lengths should be divisible by 4
+                return false;
+            }
+
+            // Check each character to ensure it is valid base-64
+            foreach (char c in input)
+            {
+                if (!char.IsLetterOrDigit(c) && c != '+' && c != '/' && c != '=')
+                {
+                    // Invalid character detected
+                    return false;
+                }
+            }
+
+            // Ensure no invalid padding scenarios exist
+            if (input.EndsWith("==") && (input.Length % 4 == 0) ||
+                input.EndsWith("=") && (input.Length % 4 == 3))
+            {
+                return true;
+            }
+
+            return input.IndexOf('=') == -1; // No padding allowed except at the end
+        }
+
+        public static bool TryDecode(this string encodedKey, out string[] decodedKeys)
+        {
+            try
+            {
+                byte[] bytes = Convert.FromBase64String(encodedKey);
+                string decodedString = Encoding.UTF8.GetString(bytes);
+                decodedKeys = decodedString.Split(new string[] { "::" }, StringSplitOptions.None);
+                return true;
+            }
+            catch(ArgumentNullException) { }
+            catch (FormatException) { }
+            catch(ArgumentException) { }
+
+            decodedKeys = Array.Empty<string>();
+            return false;
+        }
+
+        public static EncodeType GetEncodeType(this string[] decodedKeys) => decodedKeys.Length switch
+        {
+            2 => EncodeType.EnvelopeReceiver,
+            3 => long.TryParse(decodedKeys[1], out var _) ? EncodeType.EnvelopeReceiverReadOnly : EncodeType.Undefined,
+            _ => EncodeType.Undefined,
+        };
+
+        public static (string? EnvelopeUuid, string? ReceiverSignature) ParseEnvelopeReceiverId(this string[] decodedKeys)
+            => decodedKeys.GetEncodeType() == EncodeType.EnvelopeReceiver
+            ? (EnvelopeUuid: decodedKeys[0], ReceiverSignature: decodedKeys[1])
+            : throw new InvalidOperationException("Attempted to convert a decoded other than type EnvelopeReceiver to EnvelopeReceiver.");
+
+        public static long ParseReadOnlyId(this string[] decodedKeys)
+            => decodedKeys.GetEncodeType() == EncodeType.EnvelopeReceiverReadOnly
+            ? long.Parse(decodedKeys[1])
+            : throw new InvalidOperationException("Attempted to convert a decoded other than type EnvelopeReceiver to EnvelopeReceiver. ");
+
+        /// <summary>
+        /// Decodes the envelope receiver ID and extracts the envelope UUID and receiver signature.
+        /// </summary>
+        /// <param name="envelopeReceiverId">The base64 encoded string containing the envelope UUID and receiver signature.</param>
+        /// <returns>A tuple containing the envelope UUID and receiver signature.</returns>
+        public static (string? EnvelopeUuid, string? ReceiverSignature) DecodeEnvelopeReceiverId(this string envelopeReceiverId)
+        {
+            if (!envelopeReceiverId.IsBase64String())
+            {
+                return (null, null);
+            }
+            byte[] bytes = Convert.FromBase64String(envelopeReceiverId);
+            string decodedString = Encoding.UTF8.GetString(bytes);
+            string[] parts = decodedString.Split(new string[] { "::" }, StringSplitOptions.None);
+
+            if (parts.Length > 1)
+                return (EnvelopeUuid: parts[0], ReceiverSignature: parts[1]);
+            else
+                return (string.Empty, string.Empty);
+        }
+
+        public static long? DecodeEnvelopeReceiverReadOnlyId(this string envelopeReceiverReadOnlyId)
+        {
+            if (!envelopeReceiverReadOnlyId.IsBase64String())
+            {
+                return null;
+            }
+            byte[] bytes = Convert.FromBase64String(envelopeReceiverReadOnlyId);
+            string decodedString = System.Text.Encoding.UTF8.GetString(bytes);
+            string[] parts = decodedString.Split(new string[] { "::" }, StringSplitOptions.None);
+
+            if (parts.Length > 2)
+                return long.TryParse(parts[1], out long readOnlyId) ? readOnlyId : null;
+            else
+                return null;
+        }
+
+        /// <summary>
+        /// Gets the envelope UUID from the decoded envelope receiver ID.
+        /// </summary>
+        /// <param name="envelopeReceiverId">The base64 encoded string to decode.</param>
+        /// <returns>The envelope UUID.</returns>
+        public static string? GetEnvelopeUuid(this string envelopeReceiverId) => envelopeReceiverId.DecodeEnvelopeReceiverId().EnvelopeUuid;
+
+        /// <summary>
+        /// Gets the receiver signature from the decoded envelope receiver ID.
+        /// </summary>
+        /// <param name="envelopeReceiverId">The base64 encoded string to decode.</param>
+        /// <returns>The receiver signature.</returns>
+        public static string? GetReceiverSignature(this string envelopeReceiverId) => envelopeReceiverId.DecodeEnvelopeReceiverId().ReceiverSignature;
+    }
+}

EnvelopeGenerator.Extensions/EncodeType.cs

@@ -1,9 +0,0 @@
-namespace EnvelopeGenerator.Extensions
-{
-    public enum EncodeType
-    {
-        EnvelopeReceiver,
-        ReadOnly,
-        Undefined
-    }
-}

EnvelopeGenerator.Extensions/EncodingExtensions.cs

@@ -8,157 +8,9 @@ namespace EnvelopeGenerator.Extensions
     /// </summary>
     public static class EncodingExtensions
     {
-        /// <summary>
-        /// Validates whether a given string is a correctly formatted Base-64 encoded string.
-        /// </summary>
-        /// <remarks>
-        /// This method checks the string for proper Base-64 formatting, which includes validating
-        /// the length of the string (must be divisible by 4). It also checks each character to ensure
-        /// it belongs to the Base-64 character set (A-Z, a-z, 0-9, '+', '/', and '=' for padding).
-        /// The method ensures that padding characters ('=') only appear at the end of the string and
-        /// are in a valid configuration (either one '=' at the end if the string's length % 4 is 3,
-        /// or two '==' if the length % 4 is 2).
-        /// </remarks>
-        /// <param name="input">The Base-64 encoded string to validate.</param>
-        /// <returns>
-        /// <c>true</c> if the string is a valid Base-64 encoded string; otherwise, <c>false</c>.
-        /// </returns>
-        /// <example>
-        /// <code>
-        /// string testString = "TWFuIGlzIGRpc3Rpbmd1aXNoZWQsIG5vdCBvbmx5IGJ5IGhpcyByZWFzb24sIGJ1dCBieSB0aGlzIHNpbmd1bGFyIHBhc3Npb24gZnJvbSBvdGhlciBhbmltYWxzLCB3aGljaCBpcyBhIGx1c3Qgb2YgdGhlIG1pbmQsIHRoYXQgYnk=";
-        /// bool isValid = IsValidBase64String(testString);
-        /// Console.WriteLine(isValid); // Output: true
-        /// </code>
-        /// </example>
-        public static bool IsBase64String(this string input)
-        {
-            // Check if the string is null or empty
-            if (string.IsNullOrEmpty(input))
-            {
-                return false;
-            }
-
-            // Replace valid base-64 padding
-            input = input.Trim();
-            int mod4 = input.Length % 4;
-            if (mod4 > 0)
-            {
-                // Base-64 string lengths should be divisible by 4
-                return false;
-            }
-
-            // Check each character to ensure it is valid base-64
-            foreach (char c in input)
-            {
-                if (!char.IsLetterOrDigit(c) && c != '+' && c != '/' && c != '=')
-                {
-                    // Invalid character detected
-                    return false;
-                }
-            }
-
-            // Ensure no invalid padding scenarios exist
-            if (input.EndsWith("==") && (input.Length % 4 == 0) ||
-                input.EndsWith("=") && (input.Length % 4 == 3))
-            {
-                return true;
-            }
-
-            return input.IndexOf('=') == -1; // No padding allowed except at the end
-        }
-
-        public static bool TryDecode(this string encoded, out string[] decoded)
-        {
-            if (!encoded.IsBase64String())
-            {
-                decoded = Array.Empty<string>();
-                return false;
-            }
-            byte[] bytes = Convert.FromBase64String(encoded);
-            string decodedString = Encoding.UTF8.GetString(bytes);
-            decoded = decodedString.Split(new string[] { "::" }, StringSplitOptions.None);
-            return true;
-        }
-
-        public static EncodeType GetEncodeType(this string[] decoded) => decoded.Length switch
-        {
-            2 => EncodeType.EnvelopeReceiver,
-            3 => long.TryParse(decoded[1], out var _) ? EncodeType.ReadOnly : EncodeType.Undefined,
-            _ => EncodeType.Undefined,
-        };
-
-        public static (string? EnvelopeUuid, string? ReceiverSignature) ToEnvelopeReceiverId(this string[] decoded) 
-            => decoded.GetEncodeType() == EncodeType.EnvelopeReceiver
-            ? (EnvelopeUuid: decoded[0], ReceiverSignature: decoded[1])
-            : throw new InvalidOperationException("Attempted to convert a decoded other than type EnvelopeReceiver to EnvelopeReceiver. ");
-
-        public static long ToReadOnlyId(this string[] decoded)
-            => decoded.GetEncodeType() == EncodeType.ReadOnly
-            ? long.Parse(decoded[1])
-            : throw new InvalidOperationException("Attempted to convert a decoded other than type EnvelopeReceiver to EnvelopeReceiver. ");
-
-        /// <summary>
-        /// Decodes the envelope receiver ID and extracts the envelope UUID and receiver signature.
-        /// </summary>
-        /// <param name="envelopeReceiverId">The base64 encoded string containing the envelope UUID and receiver signature.</param>
-        /// <returns>A tuple containing the envelope UUID and receiver signature.</returns>
-        public static (string? EnvelopeUuid, string? ReceiverSignature) DecodeEnvelopeReceiverId(this string envelopeReceiverId)
-        {
-            if (!envelopeReceiverId.IsBase64String())
-            {
-                return (null, null);
-            }
-            byte[] bytes = Convert.FromBase64String(envelopeReceiverId);
-            string decodedString = Encoding.UTF8.GetString(bytes);
-            string[] parts = decodedString.Split(new string[] { "::" }, StringSplitOptions.None);
-
-            if (parts.Length > 1)
-                return (EnvelopeUuid: parts[0], ReceiverSignature: parts[1]);
-            else
-                return (string.Empty, string.Empty);
-        }
-
-        public static long? DecodeEnvelopeReceiverReadOnlyId(this string envelopeReceiverReadOnlyId)
-        {
-            if (!envelopeReceiverReadOnlyId.IsBase64String())
-            {
-                return null;
-            }
-            byte[] bytes = Convert.FromBase64String(envelopeReceiverReadOnlyId);
-            string decodedString = System.Text.Encoding.UTF8.GetString(bytes);
-            string[] parts = decodedString.Split(new string[] { "::" }, StringSplitOptions.None);
-
-            if (parts.Length > 2)
-                return long.TryParse(parts[1], out long readOnlyId) ? readOnlyId : null;
-            else
-                return null;
-        }
-
-        /// <summary>
-        /// Gets the envelope UUID from the decoded envelope receiver ID.
-        /// </summary>
-        /// <param name="envelopeReceiverId">The base64 encoded string to decode.</param>
-        /// <returns>The envelope UUID.</returns>
-        public static string? GetEnvelopeUuid(this string envelopeReceiverId) => envelopeReceiverId.DecodeEnvelopeReceiverId().EnvelopeUuid;
-
-        /// <summary>
-        /// Gets the receiver signature from the decoded envelope receiver ID.
-        /// </summary>
-        /// <param name="envelopeReceiverId">The base64 encoded string to decode.</param>
-        /// <returns>The receiver signature.</returns>
-        public static string? GetReceiverSignature(this string envelopeReceiverId) => envelopeReceiverId.DecodeEnvelopeReceiverId().ReceiverSignature;
-
-		public static string EncodeEnvelopeReceiverId(this (string envelopeUuid, string receiverSignature) input)
-		{
-			string combinedString = $"{input.envelopeUuid}::{input.receiverSignature}";
-			byte[] bytes = Encoding.UTF8.GetBytes(combinedString);
-			string base64String = Convert.ToBase64String(bytes);
-
-			return base64String;
-		}
-
         public static string EncodeEnvelopeReceiverId(this long readOnlyId)
         {
+            //The random number is used as a salt to increase security but it is not saved in the database.
             string combinedString = $"{Random.Shared.Next()}::{readOnlyId}::{Random.Shared.Next()}";
             byte[] bytes = Encoding.UTF8.GetBytes(combinedString);
             string base64String = Convert.ToBase64String(bytes);
@@ -166,38 +18,13 @@ namespace EnvelopeGenerator.Extensions
             return base64String;
         }
 
-        public static void LogEnvelopeError(this ILogger logger, string envelopeReceiverId, Exception? exception = null, string? message = null, params object?[] args)
+        public static string EncodeEnvelopeReceiverId(this (string envelopeUuid, string receiverSignature) input)
         {
-            var sb = new StringBuilder().AppendLine(envelopeReceiverId.DecodeEnvelopeReceiverId().ToTitle());
+            string combinedString = $"{input.envelopeUuid}::{input.receiverSignature}";
+            byte[] bytes = Encoding.UTF8.GetBytes(combinedString);
+            string base64String = Convert.ToBase64String(bytes);
 
-            if (message is not null)
-                sb.AppendLine(message);
-
-            if(exception is null)
-                logger.Log(LogLevel.Error, sb.ToString(), args);
-            else
-                logger.Log(LogLevel.Error, exception, sb.AppendLine(exception.Message).ToString(), args);
-        }
-
-        public static void LogEnvelopeError(this ILogger logger, string? uuid, string? signature = null, Exception? exception = null, string? message = null, params object?[] args)
-        {
-            var sb = new StringBuilder($"Envelope Uuid: {uuid}");
-
-            if(signature is not null)
-                sb.AppendLine().Append($"Receiver Signature: {signature}");
-
-            if (message is not null)
-                sb.AppendLine().Append(message);
-
-            if (exception is null)
-                logger.Log(LogLevel.Error, sb.ToString(), args);
-            else
-                logger.Log(LogLevel.Error, exception, sb.ToString(), args);
-        }
-
-        public static string ToTitle(this (string? UUID, string? Signature) envelopeReceiverTuple)
-        {
-            return $"UUID is {envelopeReceiverTuple.UUID} and signature is {envelopeReceiverTuple.Signature}";
+            return base64String;
         }
     }
 }

EnvelopeGenerator.Extensions/EnvelopeGenerator.Extensions.csproj

@@ -7,7 +7,13 @@
   </PropertyGroup>
 
   <ItemGroup>
+    <PackageReference Include="HtmlSanitizer" Version="8.0.865" />
+    <PackageReference Include="Microsoft.Extensions.Localization.Abstractions" Version="7.0.19" />
     <PackageReference Include="Microsoft.Extensions.Logging" Version="8.0.0" />
   </ItemGroup>
 
+  <ItemGroup>
+    <ProjectReference Include="..\EnvelopeGenerator.Common\EnvelopeGenerator.Common.vbproj" />
+  </ItemGroup>
+
 </Project>

EnvelopeGenerator.Extensions/LoggerExtensions.cs

@@ -0,0 +1,42 @@
+using Microsoft.Extensions.Logging;
+using System.Text;
+
+namespace EnvelopeGenerator.Extensions
+{
+    public static class LoggerExtensions
+    {
+        public static void LogEnvelopeError(this ILogger logger, string envelopeReceiverId, Exception? exception = null, string? message = null, params object?[] args)
+        {
+            var sb = new StringBuilder().AppendLine(envelopeReceiverId.DecodeEnvelopeReceiverId().ToTitle());
+
+            if (message is not null)
+                sb.AppendLine(message);
+
+            if (exception is null)
+                logger.Log(LogLevel.Error, sb.ToString(), args);
+            else
+                logger.Log(LogLevel.Error, exception, sb.AppendLine(exception.Message).ToString(), args);
+        }
+
+        public static void LogEnvelopeError(this ILogger logger, string? uuid, string? signature = null, Exception? exception = null, string? message = null, params object?[] args)
+        {
+            var sb = new StringBuilder($"Envelope Uuid: {uuid}");
+
+            if (signature is not null)
+                sb.AppendLine().Append($"Receiver Signature: {signature}");
+
+            if (message is not null)
+                sb.AppendLine().Append(message);
+
+            if (exception is null)
+                logger.Log(LogLevel.Error, sb.ToString(), args);
+            else
+                logger.Log(LogLevel.Error, exception, sb.ToString(), args);
+        }
+
+        public static string ToTitle(this (string? UUID, string? Signature) envelopeReceiverTuple)
+        {
+            return $"UUID is {envelopeReceiverTuple.UUID} and signature is {envelopeReceiverTuple.Signature}";
+        }
+    }
+}

EnvelopeGenerator.Extensions/XSSExtensions.cs

@@ -2,7 +2,7 @@
 using Microsoft.Extensions.Localization;
 using System.Text.Encodings.Web;
 
-namespace EnvelopeGenerator.Web
+namespace EnvelopeGenerator.Extensions
 {
     public static class XSSExtensions
     {

EnvelopeGenerator.Infrastructure/Repositories/EnvelopeReceiverReadOnlyRepository.cs

@@ -28,6 +28,24 @@ namespace EnvelopeGenerator.Infrastructure.Repositories
             return await IncludeEnvelope(erros);
         }
 
+        public override async Task<EnvelopeReceiverReadOnly?> ReadByIdAsync(long id)
+        {
+            var erro = await _dbSet.AsNoTracking()
+                .Include(erro => erro.Receiver)
+                .Where(erro => erro.Id == id)
+                .FirstOrDefaultAsync();
+
+            return await IncludeEnvelope(erro);
+        }
+
+        //TODO: Use IQueryable.Include instead of this when ID type is clarified.
+        [Obsolete("Use IQueryable.Include instead of this when ID type is clarified.")]
+        private async Task<EnvelopeReceiverReadOnly> IncludeEnvelope(EnvelopeReceiverReadOnly erro)
+        {
+            erro.Envelope = await _envRepo.ReadByIdAsync((int)erro.EnvelopeId);
+            return erro;
+        }
+
         //TODO: Use IQueryable.Include instead of this when ID type is clarified.
         [Obsolete("Use IQueryable.Include instead of this when ID type is clarified.")]
         private async Task<IEnumerable<EnvelopeReceiverReadOnly>> IncludeEnvelope(params EnvelopeReceiverReadOnly[] erros)

EnvelopeGenerator.Web/Controllers/HomeController.cs

@@ -15,8 +15,8 @@ using System.Text.Encodings.Web;
 using EnvelopeGenerator.Web.Models;
 using EnvelopeGenerator.Application.Resources;
 using EnvelopeGenerator.Application.DTOs.EnvelopeReceiver;
+using static EnvelopeGenerator.Common.Constants;
 using EnvelopeGenerator.Domain.Entities;
-using System.Text.RegularExpressions;
 
 namespace EnvelopeGenerator.Web.Controllers
 {
@@ -52,7 +52,7 @@ namespace EnvelopeGenerator.Web.Controllers
         {
             try
             {
-                envelopeReceiverId = _urlEncoder.Encode(envelopeReceiverId);
+                //envelopeReceiverId = _urlEncoder.Encode(envelopeReceiverId);
 
                 if (!envelopeReceiverId.TryDecode(out var decoded))
                 {
@@ -60,7 +60,7 @@ namespace EnvelopeGenerator.Web.Controllers
                     return this.ViewDocumentNotFound();
                 }
 
-                if(decoded.GetEncodeType() == EncodeType.ReadOnly)
+                if(decoded.GetEncodeType() == EncodeType.EnvelopeReceiverReadOnly)
                     return Redirect($"{envelopeReceiverId}/ReadOnly");
 
                 ViewData["EnvelopeKey"] = envelopeReceiverId;
@@ -199,7 +199,7 @@ namespace EnvelopeGenerator.Web.Controllers
                             {
                                 _logger.LogEnvelopeError(envelopeReceiverId: envelopeReceiverId, message: "No document was found.");
 								return this.ViewDocumentNotFound();
-							}                                
+							}                              
 
                             var claims = new List<Claim> {
                                             new(ClaimTypes.NameIdentifier, uuid),
@@ -305,16 +305,62 @@ namespace EnvelopeGenerator.Web.Controllers
             }
         }
 
-        [Authorize]
-        [HttpGet("EnvelopeKey/{envelopeReceiverId}/ReadOnly")]
-        public async Task<IActionResult> EnvelopeReceiverReadOnly(string readOnlyId)
+        [HttpGet("EnvelopeKey/{readOnlyKey}/ReadOnly")]
+        public async Task<IActionResult> EnvelopeReceiverReadOnly([FromRoute] string readOnlyKey)
         {
             try
             {
-                return Ok();
+                //readOnlyKey = _urlEncoder.Encode(readOnlyKey);
+
+                // check if the readOnlyId is valid
+                if (!readOnlyKey.TryDecode(out var decodedKeys) || decodedKeys.GetEncodeType() != EncodeType.EnvelopeReceiverReadOnly)
+                {
+                    Response.StatusCode = StatusCodes.Status401Unauthorized;
+                    return this.ViewDocumentNotFound();
+                }
+
+                var readOnlyId = decodedKeys.ParseReadOnlyId();
+                var erro_res = await _readOnlyService.ReadByIdAsync(readOnlyId);
+                if (erro_res.IsFailed)
+                {
+                    _logger.LogNotice(erro_res.Notices);
+                    return this.ViewInnerServiceError();
+                }
+
+                var erro = erro_res.Data;
+
+                return await _envRcvService.ReadByUuidSignatureAsync(uuid: erro.Envelope!.Uuid, erro.Receiver!.Signature).ThenAsync(
+                SuccessAsync: async er =>
+                {
+                    var envelopeKey = (er.Envelope!.Uuid, er.Receiver!.Signature).EncodeEnvelopeReceiverId();
+                    
+                    EnvelopeResponse response = await envelopeOldService.LoadEnvelope(envelopeKey);
+
+                    if (response.Envelope.Documents.Count > 0)
+                    {
+                        var document = await envelopeOldService.GetDocument(response.Envelope.Documents[0].Id, envelopeKey);
+                        byte[] bytes = await envelopeOldService.GetDocumentContents(document);
+                        ViewData["EnvelopeKey"] = envelopeKey;
+                        ViewData["DocumentBytes"] = bytes;
+                        ViewData["IsReadOnly"] = true;
+                        ViewData["PSPDFKitLicenseKey"] = _configuration["PSPDFKitLicenseKey"];
+                        return View("ShowEnvelope", er);
+                    }
+                    else
+                    {
+                        _logger.LogEnvelopeError(envelopeReceiverId: envelopeKey, message: "No document was found.");
+                        return this.ViewDocumentNotFound();
+                    }
+                },
+                Fail: (messages, notices) =>
+                {
+                    _logger.LogNotice(notices);
+                    return this.ViewEnvelopeNotFound();
+                });
             }
             catch (Exception ex)
             {
+                _logger.LogError(ex, "An unexpected error occurred while displaying a read-only envelope. Read-only key is {readOnlyKey}. {message}", readOnlyKey, ex.Message);
                 return this.ViewInnerServiceError();
             }
         }

EnvelopeGenerator.Web/Controllers/ReadOnlyController.cs

@@ -1,6 +1,7 @@
 using DigitalData.Core.DTO;
 using EnvelopeGenerator.Application.Contracts;
 using EnvelopeGenerator.Application.DTOs.EnvelopeReceiverReadOnly;
+using EnvelopeGenerator.Extensions;
 using Microsoft.AspNetCore.Authorization;
 using Microsoft.AspNetCore.Mvc;
 using Newtonsoft.Json;
@@ -50,5 +51,10 @@ namespace EnvelopeGenerator.Web.Controllers
                     return StatusCode(StatusCodes.Status500InternalServerError);
                 });
         }
+
+        [HttpGet("key/{readOnlyId}")]
+        public IActionResult CreateLink(long readOnlyId) => Ok(
+            Request.Headers["Origin"].ToString() + "/EnvelopeKey/" + readOnlyId.EncodeEnvelopeReceiverId());
+
     }
 }

EnvelopeGenerator.Web/Views/_ViewImports.cshtml

@@ -1,6 +1,7 @@
 @using EnvelopeGenerator.Web
 @using EnvelopeGenerator.Web.Models
 @using EnvelopeGenerator.Web.Sanitizers
+@using EnvelopeGenerator.Extensions
 @using Microsoft.Extensions.Localization
 @using EnvelopeGenerator.Application.Resources
 @using Microsoft.Extensions.Options