AppStd/EnvelopeGenerator
8
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Refactor EnvelopeController and EnvelopeOldService

Browse Source 
Significantly refactored `EnvelopeController.cs` to improve structure, add logging, and enhance error handling in methods. Introduced new private fields and updated constructor parameters, with some marked as obsolete.

Updated `EnvelopeOldService.cs` to add private fields, improve logging, and enhance error handling in key methods. Introduced `ReceiverAlreadySigned` method and marked `GetDocument` as obsolete. Improved overall functionality and maintainability.
This commit is contained in:
tekh 2025-06-27 10:59:52 +02:00
parent 08601adc49
commit dedfb924d8
2 changed files with 296 additions and 284 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

258
EnvelopeGenerator.Web/Controllers/EnvelopeController.cs
View File

@ -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);
[NonAction]
public async Task<IActionResult> Get([FromRoute] string envelopeKey)
{
try
// Validate Envelope Key and load envelope
envelopeService.EnsureValidEnvelopeKey(envelopeKey);
EnvelopeReceiver response = await envelopeService.LoadEnvelope(envelopeKey);
if (envelopeService.ReceiverAlreadySigned(response.Envelope, response.Receiver.Id) == true)
{
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);
return Problem(statusCode: 403);
}
_logger.LogInformation("Loaded envelope [{0}] for receiver [{1}]", response.Envelope.Id, response.Envelope.Id);
return Json(response);
}
[Authorize(Roles = ReceiverRole.FullyAuth)]
[HttpPost("{envelopeKey}")]
public async Task<IActionResult> Update(string envelopeKey, int index)
catch (Exception e)
{
try
_logger.LogError(e, "{Message}", e.Message);
return StatusCode(StatusCodes.Status500InternalServerError);
}
}
[Authorize(Roles = ReceiverRole.FullyAuth)]
[HttpPost("{envelopeKey}")]
[Obsolete("Use MediatR")]
public async Task<IActionResult> Update(string envelopeKey, int index)
{
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);
}
}
}

320
EnvelopeGenerator.Web/Services/EnvelopeOldService.cs
View File

@ -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;
_logger = logger;
private readonly DocumentStatusModel documentStatusModel;
if (database.Models is null)
throw new ArgumentNullException("Models not loaded.");
private readonly IConfigService _configService;
private readonly ILogger<EnvelopeOldService> _logger;
receiverModel = database.Models.receiverModel;
envelopeModel = database.Models.envelopeModel;
historyModel = database.Models.historyModel;
documentStatusModel = database.Models.documentStatusModel;
public EnvelopeOldService(DatabaseService database, IConfigService configService, ILogger<EnvelopeOldService> logger)
_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;
}
}