diff --git a/EnvelopeGenerator.Web/Controllers/EnvelopeController.cs b/EnvelopeGenerator.Web/Controllers/EnvelopeController.cs
index 16a37dc2..3d2870c6 100644
--- a/EnvelopeGenerator.Web/Controllers/EnvelopeController.cs
+++ b/EnvelopeGenerator.Web/Controllers/EnvelopeController.cs
@@ -1,153 +1,161 @@
-using DigitalData.Core.DTO;
-using EnvelopeGenerator.CommonServices;
+using EnvelopeGenerator.CommonServices;
 using EnvelopeGenerator.Web.Services;
 using Microsoft.AspNetCore.Authorization;
 using Microsoft.AspNetCore.Mvc;
 using System.Text.Encodings.Web;
-using static EnvelopeGenerator.CommonServices.Constants;
 using EnvelopeGenerator.Extensions;
 using EnvelopeGenerator.Application.Contracts.Services;
+using static EnvelopeGenerator.Domain.Constants;
+using EnvelopeGenerator.Domain.Entities;
+using EnvelopeGenerator.Domain;
+using DigitalData.Core.Abstraction.Application.DTO;
 
-namespace EnvelopeGenerator.Web.Controllers
+namespace EnvelopeGenerator.Web.Controllers;
+
+[Authorize(Roles = ReceiverRole.FullyAuth)]
+[ApiController]
+[Route("api/[controller]")]
+public class EnvelopeController : BaseController
 {
-    [Authorize(Roles = ReceiverRole.FullyAuth)]
-    [ApiController]
-    [Route("api/[controller]")]
-    public class EnvelopeController : BaseController
+    private readonly EnvelopeOldService envelopeService;
+    private readonly ActionService? actionService;
+    private readonly UrlEncoder _urlEncoder;
+    [Obsolete("Use MediatR")]
+    private readonly IEnvelopeHistoryService _histService;
+    [Obsolete("Use MediatR")]
+    private readonly IReceiverService _receiverService;
+    [Obsolete("Use MediatR")]
+    private readonly IEnvelopeReceiverService _envRcvService;
+
+    [Obsolete("Use MediatR")]
+    public EnvelopeController(DatabaseService database,
+        EnvelopeOldService envelope,
+        ILogger<EnvelopeController> logger, UrlEncoder urlEncoder,
+        IEnvelopeHistoryService envelopeHistoryService,
+        IReceiverService receiverService,
+        IEnvelopeReceiverService envelopeReceiverService) : base(database, logger)
     {
-        private readonly EnvelopeOldService envelopeService;
-        private readonly ActionService? actionService;
-        private readonly UrlEncoder _urlEncoder;
-        private readonly IEnvelopeHistoryService _histService;
-        private readonly IReceiverService _receiverService;
-        private readonly IEnvelopeReceiverService _envRcvService;
+        envelopeService = envelope;
+        actionService = database?.Services?.actionService;
+        _urlEncoder = urlEncoder;
+        _histService = envelopeHistoryService;
+        _receiverService = receiverService;
+        _envRcvService = envelopeReceiverService;
+    }
 
-        public EnvelopeController(DatabaseService database,
-            EnvelopeOldService envelope,
-            ILogger<EnvelopeController> logger, UrlEncoder urlEncoder,
-            IEnvelopeHistoryService envelopeHistoryService,
-            IReceiverService receiverService,
-            IEnvelopeReceiverService envelopeReceiverService) : base(database, logger)
+    [NonAction]
+    [Obsolete("Use MediatR")]
+    public async Task<IActionResult> Get([FromRoute] string envelopeKey)
+    {
+        try
         {
-            envelopeService = envelope;
-            actionService = database?.Services?.actionService;
-            _urlEncoder = urlEncoder;
-            _histService = envelopeHistoryService;
-            _receiverService = receiverService;
-            _envRcvService = envelopeReceiverService;
+            envelopeKey = _urlEncoder.Encode(envelopeKey);
+
+            // Validate Envelope Key and load envelope
+            envelopeService.EnsureValidEnvelopeKey(envelopeKey);
+        
+            EnvelopeReceiver response = await envelopeService.LoadEnvelope(envelopeKey);
+
+            if (envelopeService.ReceiverAlreadySigned(response.Envelope, response.Receiver.Id) == true)
+            {
+                return Problem(statusCode: 403);
+            }          
+
+            _logger.LogInformation("Loaded envelope [{0}] for receiver [{1}]", response.Envelope.Id, response.Envelope.Id);
+            return Json(response);
         }
-
-        [NonAction]
-        public async Task<IActionResult> Get([FromRoute] string envelopeKey)
+        catch (Exception e)
         {
-            try
-            {
-                envelopeKey = _urlEncoder.Encode(envelopeKey);
-
-                // Validate Envelope Key and load envelope
-                envelopeService.EnsureValidEnvelopeKey(envelopeKey);
-            
-                EnvelopeReceiver response = await envelopeService.LoadEnvelope(envelopeKey);
-
-                if (envelopeService.ReceiverAlreadySigned(response.Envelope, response.Receiver.Id) == true)
-                {
-                    return Problem(statusCode: 403);
-                }          
-
-                _logger.LogInformation("Loaded envelope [{0}] for receiver [{1}]", response.Envelope.Id, response.Envelope.Id);
-                return Json(response);
-            }
-            catch (Exception e)
-            {
-                _logger.LogError(e, "{Message}", e.Message);
-                return StatusCode(StatusCodes.Status500InternalServerError);
-            }
+            _logger.LogError(e, "{Message}", e.Message);
+            return StatusCode(StatusCodes.Status500InternalServerError);
         }
+    }
 
-        [Authorize(Roles = ReceiverRole.FullyAuth)]
-        [HttpPost("{envelopeKey}")]
-        public async Task<IActionResult> Update(string envelopeKey, int index)
+    [Authorize(Roles = ReceiverRole.FullyAuth)]
+    [HttpPost("{envelopeKey}")]
+    [Obsolete("Use MediatR")]
+    public async Task<IActionResult> Update(string envelopeKey, int index)
+    {
+        try
         {
-            try
+            envelopeKey = _urlEncoder.Encode(envelopeKey);
+
+            var authSignature = this.GetAuthReceiverSignature();
+
+            if (authSignature != envelopeKey.GetReceiverSignature())
+                return Unauthorized();
+
+            // Validate Envelope Key and load envelope
+            envelopeService.EnsureValidEnvelopeKey(envelopeKey);
+            EnvelopeReceiver response = await envelopeService.LoadEnvelope(envelopeKey);
+
+            // Again check if receiver has already signed
+            if (envelopeService.ReceiverAlreadySigned(response.Envelope, response.Receiver.Id) == true)
             {
-                envelopeKey = _urlEncoder.Encode(envelopeKey);
+                return Problem(statusCode: 403);
+            }
 
-                var authSignature = this.GetAuthReceiverSignature();
+            var document = envelopeService.GetDocument(index, envelopeKey);
 
-                if (authSignature != envelopeKey.GetReceiverSignature())
-                    return Unauthorized();
+            string? annotationData = await envelopeService.EnsureValidAnnotationData(Request);
 
-                // Validate Envelope Key and load envelope
-                envelopeService.EnsureValidEnvelopeKey(envelopeKey);
-                EnvelopeReceiver response = await envelopeService.LoadEnvelope(envelopeKey);
+            envelopeService.InsertDocumentStatus(new Domain.Entities.DocumentStatus()
+            {
+                EnvelopeId = response.Envelope.Id,
+                ReceiverId = response.Receiver.Id,
+                Value = annotationData,
+                Status = Constants.DocumentStatus.Signed
+            });
 
-                // Again check if receiver has already signed
-                if (envelopeService.ReceiverAlreadySigned(response.Envelope, response.Receiver.Id) == true)
+            var signResult = actionService?.SignEnvelope(response.Envelope, response.Receiver);
+
+            return Ok(new object());
+        }
+        catch (Exception e)
+        {
+            _logger.LogError(e, "{Message}", e.Message);
+            return StatusCode(StatusCodes.Status500InternalServerError);
+        }
+    }
+
+    [Authorize(Roles = ReceiverRole.FullyAuth)]
+    [HttpPost("reject")]
+    [Obsolete("Use DigitalData.Core.Exceptions and .Middleware")]
+    public async Task<IActionResult> Reject([FromBody] string? reason = null)
+    {
+        try
+        {
+            var signature = this.GetAuthReceiverSignature();
+            var uuid = this.GetAuthEnvelopeUuid();
+            var mail = this.GetAuthReceiverMail();
+            if(uuid is null || signature is null || mail is null)
+            {
+                _logger.LogEnvelopeError(uuid: uuid, signature: signature,
+                    message: @$"Unauthorized POST request in api\envelope\reject. One of claims, Envelope, signature or mail ({mail}) is null.");
+                return Unauthorized();
+            }
+
+            var envRcvRes = await _envRcvService.ReadByUuidSignatureAsync(uuid: uuid, signature: signature);
+
+            if (envRcvRes.IsFailed)
+            {
+                _logger.LogNotice(envRcvRes.Notices);
+                return Unauthorized("you are not authirized");
+            }
+
+            return await _histService.RecordAsync(envRcvRes.Data.EnvelopeId, userReference: mail, EnvelopeStatus.DocumentRejected, comment: reason).ThenAsync(
+                Success: id => NoContent(),
+                Fail: IActionResult (mssg, ntc) =>
                 {
-                    return Problem(statusCode: 403);
-                }
-
-                var document = envelopeService.GetDocument(index, envelopeKey);
-
-                string? annotationData = await envelopeService.EnsureValidAnnotationData(Request);
-
-                envelopeService.InsertDocumentStatus(new Common.DocumentStatus()
-                {
-                    EnvelopeId = response.Envelope.Id,
-                    ReceiverId = response.Receiver.Id,
-                    Value = annotationData,
-                    Status = Common.Constants.DocumentStatus.Signed
+                    _logger.LogEnvelopeError(uuid: uuid, signature: signature, message: "Unexpected error happend in api/envelope/reject");
+                    _logger.LogNotice(ntc);
+                    return this.ViewInnerServiceError();
                 });
-
-                var signResult = actionService?.SignEnvelope(response.Envelope, response.Receiver);
-
-                return Ok(new object());
-            }
-            catch (Exception e)
-            {
-                _logger.LogError(e, "{Message}", e.Message);
-                return StatusCode(StatusCodes.Status500InternalServerError);
-            }
         }
-
-        [Authorize(Roles = ReceiverRole.FullyAuth)]
-        [HttpPost("reject")]
-        public async Task<IActionResult> Reject([FromBody] string? reason = null)
+        catch (Exception e)
         {
-            try
-            {
-                var signature = this.GetAuthReceiverSignature();
-                var uuid = this.GetAuthEnvelopeUuid();
-                var mail = this.GetAuthReceiverMail();
-                if(uuid is null || signature is null || mail is null)
-                {
-                    _logger.LogEnvelopeError(uuid: uuid, signature: signature,
-                        message: @$"Unauthorized POST request in api\envelope\reject. One of claims, Envelope, signature or mail ({mail}) is null.");
-                    return Unauthorized();
-                }
-
-                var envRcvRes = await _envRcvService.ReadByUuidSignatureAsync(uuid: uuid, signature: signature);
-
-                if (envRcvRes.IsFailed)
-                {
-                    _logger.LogNotice(envRcvRes.Notices);
-                    return Unauthorized("you are not authirized");
-                }
-
-                return await _histService.RecordAsync(envRcvRes.Data.EnvelopeId, userReference: mail, EnvelopeStatus.DocumentRejected, comment: reason).ThenAsync(
-                    Success: id => NoContent(),
-                    Fail: IActionResult (mssg, ntc) =>
-                    {
-                        _logger.LogEnvelopeError(uuid: uuid, signature: signature, message: "Unexpected error happend in api/envelope/reject");
-                        _logger.LogNotice(ntc);
-                        return this.ViewInnerServiceError();
-                    });
-            }
-            catch (Exception e)
-            {
-                _logger.LogError(e, "{Message}", e.Message);
-                return StatusCode(StatusCodes.Status500InternalServerError);
-            }
+            _logger.LogError(e, "{Message}", e.Message);
+            return StatusCode(StatusCodes.Status500InternalServerError);
         }
     }
 }
\ No newline at end of file
diff --git a/EnvelopeGenerator.Web/Services/EnvelopeOldService.cs b/EnvelopeGenerator.Web/Services/EnvelopeOldService.cs
index 8a1cc26d..fbb35de6 100644
--- a/EnvelopeGenerator.Web/Services/EnvelopeOldService.cs
+++ b/EnvelopeGenerator.Web/Services/EnvelopeOldService.cs
@@ -1,186 +1,190 @@
 using EnvelopeGenerator.Application.Contracts.Services;
 using EnvelopeGenerator.CommonServices;
+using EnvelopeGenerator.Domain.Entities;
 using System.Text;
 
-namespace EnvelopeGenerator.Web.Services
+namespace EnvelopeGenerator.Web.Services;
+
+public class EnvelopeOldService
 {
-    public class EnvelopeOldService
+    private readonly ReceiverModel receiverModel;
+    private readonly EnvelopeModel envelopeModel;
+    private readonly HistoryModel historyModel;
+    
+    private readonly DocumentStatusModel documentStatusModel;
+
+    [Obsolete("Use MediatR")]
+    private readonly IConfigService _configService;
+    private readonly ILogger<EnvelopeOldService> _logger;
+
+    [Obsolete("Use MediatR")]
+    public EnvelopeOldService(DatabaseService database, IConfigService configService, ILogger<EnvelopeOldService> logger)
     {
-        private readonly ReceiverModel receiverModel;
-        private readonly EnvelopeModel envelopeModel;
-        private readonly HistoryModel historyModel;
-        
-        private readonly DocumentStatusModel documentStatusModel;
+        _logger = logger;
 
-        private readonly IConfigService _configService;
-        private readonly ILogger<EnvelopeOldService> _logger;
+        if (database.Models is null)
+            throw new ArgumentNullException("Models not loaded.");
 
-        public EnvelopeOldService(DatabaseService database, IConfigService configService, ILogger<EnvelopeOldService> logger)
+        receiverModel = database.Models.receiverModel;
+        envelopeModel = database.Models.envelopeModel;
+        historyModel = database.Models.historyModel;
+        documentStatusModel = database.Models.documentStatusModel;
+
+        _configService = configService;
+    }
+
+    public void EnsureValidEnvelopeKey(string envelopeKey)
+    {
+        _logger.LogInformation("Parsing EnvelopeKey..");
+
+        if (string.IsNullOrEmpty(envelopeKey))
+            throw new ArgumentNullException("EnvelopeKey");
+
+        Tuple<string, string> result = Helpers.DecodeEnvelopeReceiverId(envelopeKey);
+        _logger.LogInformation("EnvelopeUUID: [{0}]", result.Item1);
+        _logger.LogInformation("ReceiverSignature: [{0}]", result.Item2);
+
+        if (string.IsNullOrEmpty(result.Item1))
+            throw new ArgumentNullException("EnvelopeUUID");
+
+        if (string.IsNullOrEmpty(result.Item2))
+            throw new ArgumentNullException("ReceiverSignature");
+    }
+
+    [Obsolete("Use MediatR")]
+    public async Task<EnvelopeReceiver> LoadEnvelope(string pEnvelopeKey)
+    {
+        _logger.LogInformation("Loading Envelope by Key [{0}]", pEnvelopeKey);
+
+        Tuple<string, string> result = Helpers.DecodeEnvelopeReceiverId(pEnvelopeKey);
+        var envelopeUuid = result.Item1;
+        var receiverSignature = result.Item2;
+        var receiverId = receiverModel.GetReceiverIdBySignature(receiverSignature);
+
+        _logger.LogInformation("Resolved receiver signature to receiverId [{0}]", receiverId);
+
+        _logger.LogInformation("Loading envelope..");
+        Envelope? envelope = envelopeModel.GetByUuid(envelopeUuid);
+
+        if (envelope == null)
         {
-            _logger = logger;
-
-            if (database.Models is null)
-                throw new ArgumentNullException("Models not loaded.");
-
-            receiverModel = database.Models.receiverModel;
-            envelopeModel = database.Models.envelopeModel;
-            historyModel = database.Models.historyModel;
-            documentStatusModel = database.Models.documentStatusModel;
-
-            _configService = configService;
+            _logger.LogWarning("Envelope not found");
+            throw new NullReferenceException("Envelope not found");
         }
 
-        public void EnsureValidEnvelopeKey(string envelopeKey)
+        _logger.LogInformation("Envelope loaded");
+
+        if (envelope.Receivers == null)
         {
-            _logger.LogInformation("Parsing EnvelopeKey..");
-
-            if (string.IsNullOrEmpty(envelopeKey))
-                throw new ArgumentNullException("EnvelopeKey");
-
-            Tuple<string, string> result = Helpers.DecodeEnvelopeReceiverId(envelopeKey);
-            _logger.LogInformation("EnvelopeUUID: [{0}]", result.Item1);
-            _logger.LogInformation("ReceiverSignature: [{0}]", result.Item2);
-
-            if (string.IsNullOrEmpty(result.Item1))
-                throw new ArgumentNullException("EnvelopeUUID");
-
-            if (string.IsNullOrEmpty(result.Item2))
-                throw new ArgumentNullException("ReceiverSignature");
+            _logger.LogWarning("Receivers for envelope not loaded");
+            throw new NullReferenceException("Receivers for envelope not loaded");
         }
 
-        public async Task<EnvelopeReceiver> LoadEnvelope(string pEnvelopeKey)
+        _logger.LogInformation("Envelope receivers found: [{0}]", envelope.Receivers.Count);
+
+        Receiver? receiver = envelope.Receivers.Where(r => r.Id == receiverId).SingleOrDefault();
+
+        if (receiver == null)
         {
-            _logger.LogInformation("Loading Envelope by Key [{0}]", pEnvelopeKey);
-
-            Tuple<string, string> result = Helpers.DecodeEnvelopeReceiverId(pEnvelopeKey);
-            var envelopeUuid = result.Item1;
-            var receiverSignature = result.Item2;
-            var receiverId = receiverModel.GetReceiverIdBySignature(receiverSignature);
-
-            _logger.LogInformation("Resolved receiver signature to receiverId [{0}]", receiverId);
-
-            _logger.LogInformation("Loading envelope..");
-            Envelope? envelope = envelopeModel.GetByUuid(envelopeUuid);
-
-            if (envelope == null)
-            {
-                _logger.LogWarning("Envelope not found");
-                throw new NullReferenceException("Envelope not found");
-            }
-
-            _logger.LogInformation("Envelope loaded");
-
-            if (envelope.Receivers == null)
-            {
-                _logger.LogWarning("Receivers for envelope not loaded");
-                throw new NullReferenceException("Receivers for envelope not loaded");
-            }
-
-            _logger.LogInformation("Envelope receivers found: [{0}]", envelope.Receivers.Count);
-
-            Receiver? receiver = envelope.Receivers.Where(r => r.Id == receiverId).SingleOrDefault();
-
-            if (receiver == null)
-            {
-                _logger.LogWarning("Receiver [{0}] not found", receiverId);
-                throw new NullReferenceException("Receiver not found");
-            }
-
-            _logger.LogInformation("Loading documents for receiver [{0}]", receiver.EmailAddress);
-
-            // filter elements by receiver
-            envelope.Documents = envelope.Documents.Select((document) =>
-            {
-                document.Elements = document.Elements.Where((e) => e.ReceiverId == receiverId).ToList();
-                return document;
-            }).ToList();
-
-            //if documenet_path_dmz is existing in config, replace the path with it
-            var config = await _configService.ReadDefaultAsync();
-
-            return new()
-            {
-                Receiver = receiver,
-                Envelope = envelope
-            };
+            _logger.LogWarning("Receiver [{0}] not found", receiverId);
+            throw new NullReferenceException("Receiver not found");
         }
 
-        public List<Envelope> LoadEnvelopes()
+        _logger.LogInformation("Loading documents for receiver [{0}]", receiver.EmailAddress);
+
+        // filter elements by receiver
+        envelope.Documents = envelope.Documents.Select((document) =>
         {
-            var receivers = receiverModel.ListReceivers();
-            List<Envelope> envelopes = new();
-
-            foreach (var receiver in receivers)
-            {
-                var envs = (List<Envelope>)envelopeModel.List(receiver.Id);
-                envelopes.AddRange(envs);
-            }
-
-            return envelopes;
-        }
-
-        public List<Envelope> LoadEnvelopes(int pReceiverId)
-        {
-            return (List<Envelope>)envelopeModel.List(pReceiverId);
-        }
-
-        public bool ReceiverAlreadySigned(Envelope envelope, int receiverId)
-        {
-            return historyModel.HasReceiverSigned(envelope.Id, receiverId);     
-        }
-
-        public async Task<string?> EnsureValidAnnotationData(HttpRequest request)
-        {
-            try
-            {
-                _logger.LogInformation("Parsing annotation data from request..");
-
-                using MemoryStream ms = new();
-                await request.BodyReader.CopyToAsync(ms);
-                var bytes = ms.ToArray();
-
-                _logger.LogInformation("Annotation data parsed, size: [{0}]", bytes.Length);
-
-                return Encoding.UTF8.GetString(bytes);
-            }
-            catch (Exception e)
-            {
-                _logger.LogError(e, "Inner Service Error");
-                throw new ArgumentNullException("AnnotationData");
-            }
-        }
-
-        public async Task<EnvelopeDocument> GetDocument(int documentId, string envelopeKey)
-        {
-            EnvelopeReceiver response = await LoadEnvelope(envelopeKey);
-
-            _logger.LogInformation("Loading document for Id [{0}]", documentId);
-            
-            var document = response.Envelope.Documents.
-                Where(d => d.Id == documentId).
-                FirstOrDefault();
-
-            if (document == null)
-                throw new ArgumentException("DocumentId");
-
-            _logger.LogInformation("Document [{0}] loaded!", documentId);
-
+            document.Elements = document.Elements.Where((e) => e.ReceiverId == receiverId).ToList();
             return document;
+        }).ToList();
+
+        //if documenet_path_dmz is existing in config, replace the path with it
+        var config = await _configService.ReadDefaultAsync();
+
+        return new()
+        {
+            Receiver = receiver,
+            Envelope = envelope
+        };
+    }
+
+    public List<Envelope> LoadEnvelopes()
+    {
+        var receivers = receiverModel.ListReceivers();
+        List<Envelope> envelopes = new();
+
+        foreach (var receiver in receivers)
+        {
+            var envs = (List<Envelope>)envelopeModel.List(receiver.Id);
+            envelopes.AddRange(envs);
         }
 
-        public bool InsertDocumentStatus(Common.DocumentStatus documentStatus)
+        return envelopes;
+    }
+
+    public List<Envelope> LoadEnvelopes(int pReceiverId)
+    {
+        return (List<Envelope>)envelopeModel.List(pReceiverId);
+    }
+
+    public bool ReceiverAlreadySigned(Envelope envelope, int receiverId)
+    {
+        return historyModel.HasReceiverSigned(envelope.Id, receiverId);     
+    }
+
+    public async Task<string?> EnsureValidAnnotationData(HttpRequest request)
+    {
+        try
         {
-            _logger.LogInformation("Saving annotation data..");
-            return documentStatusModel.InsertOrUpdate(documentStatus);
+            _logger.LogInformation("Parsing annotation data from request..");
+
+            using MemoryStream ms = new();
+            await request.BodyReader.CopyToAsync(ms);
+            var bytes = ms.ToArray();
+
+            _logger.LogInformation("Annotation data parsed, size: [{0}]", bytes.Length);
+
+            return Encoding.UTF8.GetString(bytes);
         }
-
-        public async Task<byte[]> GetDocumentContents(EnvelopeDocument document)
+        catch (Exception e)
         {
-            _logger.LogInformation("Loading file [{0}]", document.Filepath);
-            var bytes = await File.ReadAllBytesAsync(document.Filepath);
-            _logger.LogInformation("File loaded, size: [{0}]", bytes.Length);
-
-            return bytes;
+            _logger.LogError(e, "Inner Service Error");
+            throw new ArgumentNullException("AnnotationData");
         }
     }
+
+    [Obsolete("Use MediatR")]
+    public async Task<EnvelopeDocument> GetDocument(int documentId, string envelopeKey)
+    {
+        EnvelopeReceiver response = await LoadEnvelope(envelopeKey);
+
+        _logger.LogInformation("Loading document for Id [{0}]", documentId);
+        
+        var document = response.Envelope.Documents.
+            Where(d => d.Id == documentId).
+            FirstOrDefault();
+
+        if (document == null)
+            throw new ArgumentException("DocumentId");
+
+        _logger.LogInformation("Document [{0}] loaded!", documentId);
+
+        return document;
+    }
+
+    public bool InsertDocumentStatus(DocumentStatus documentStatus)
+    {
+        _logger.LogInformation("Saving annotation data..");
+        return documentStatusModel.InsertOrUpdate(documentStatus);
+    }
+
+    public async Task<byte[]> GetDocumentContents(EnvelopeDocument document)
+    {
+        _logger.LogInformation("Loading file [{0}]", document.Filepath);
+        var bytes = await File.ReadAllBytesAsync(document.Filepath);
+        _logger.LogInformation("File loaded, size: [{0}]", bytes.Length);
+
+        return bytes;
+    }
 }
\ No newline at end of file