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

clean up server

Browse Source
This commit is contained in:
Jonathan Jenne 2023-11-06 10:46:02 +01:00
parent 0b6eecc534
commit bbfbe3a7b4
10 changed files with 317 additions and 330 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

30
EnvelopeGenerator.Web/Controllers/BaseController.cs Normal file
View File

@ -0,0 +1,30 @@
using DigitalData.Modules.Logging;
using EnvelopeGenerator.Web.Services;
using Microsoft.AspNetCore.Mvc;
using static EnvelopeGenerator.Web.Constants;
namespace EnvelopeGenerator.Web.Controllers
{
public class BaseController : Controller
{
internal DatabaseService database;
internal LogConfig logConfig;
internal Logger logger;
public BaseController(DatabaseService database, LoggingService logging)
{
this.database = database;
this.logConfig = logging.LogConfig;
this.logger = logging.LogConfig.GetLoggerFor(GetType().Name);
}
internal ObjectResult ErrorResponse(Exception e)
{
logger.Error(e);
return Problem(
statusCode: 500,
detail: e.Message,
type: ErrorType.ServerError.ToString());
}
}
}

87
EnvelopeGenerator.Web/Controllers/DocumentController.cs
View File

@ -1,25 +1,16 @@
using Microsoft.AspNetCore.Mvc;
using DigitalData.Modules.Logging;
using EnvelopeGenerator.Common;
using EnvelopeGenerator.Web.Services;
using static EnvelopeGenerator.Common.Constants;
using static EnvelopeGenerator.Web.Constants;
namespace EnvelopeGenerator.Web.Controllers
{
public class DocumentController : Controller
public class DocumentController : BaseController
{
private readonly DatabaseService database;
private readonly LoggingService logging;
private readonly Logger logger;
private readonly ApiService api;
private readonly EnvelopeService envelopeService;
public DocumentController(DatabaseService database, LoggingService logging, ApiService api)
public DocumentController(DatabaseService database, LoggingService logging, EnvelopeService envelope) : base(database, logging)
{
this.database = database;
this.logging = logging;
this.logger = logging.LogConfig.GetLoggerFor(GetType().Name);
this.api = api;
envelopeService = envelope;
}
[HttpGet]
@ -28,40 +19,25 @@ namespace EnvelopeGenerator.Web.Controllers
{
try
{
logger.Info("Handling file download.");
logger.Info("DocumentController/Get");
// Validate Envelope Key
EnvelopeResponse r = api.EnsureValidEnvelopeKey(envelopeKey);
// Validate Envelope Key and load envelope
envelopeService.EnsureValidEnvelopeKey(envelopeKey);
EnvelopeResponse response = envelopeService.LoadEnvelope(envelopeKey);
// Load document info
var Request = ControllerContext.HttpContext.Request;
var document = api.GetDocument(Request, envelopeKey);
var document = envelopeService.GetDocument(Request, envelopeKey);
// Load the document from disk
var bytes = await System.IO.File.ReadAllBytesAsync(document.Filepath);
logger.Info("Serving file, size: [{0}]", bytes.Length);
var bytes = await envelopeService.GetDocumentContents(document);
// Return the document as bytes
return File(bytes, "application/octet-stream");
}
catch (IOException e)
{
logger.Error(e);
return Problem(
statusCode: 500,
detail: e.Message,
type: ErrorType.ServerError.ToString());
}
catch (Exception e)
{
// Better error handling & reporting
logger.Error(e);
return Problem(
statusCode: 500,
detail: e.Message,
type: ErrorType.ServerError.ToString());
return ErrorResponse(e);
}
}
@ -71,50 +47,27 @@ namespace EnvelopeGenerator.Web.Controllers
{
try
{
logger.Info("Handling file update.");
logger.Info("DocumentController/Update");
// Validate Envelope Key
EnvelopeResponse r = api.EnsureValidEnvelopeKey(envelopeKey);
// Validate Envelope Key and load envelope
envelopeService.EnsureValidEnvelopeKey(envelopeKey);
EnvelopeResponse response = envelopeService.LoadEnvelope(envelopeKey);
// Load Document info
var Request = ControllerContext.HttpContext.Request;
var document = api.GetDocument(Request, envelopeKey);
var document = envelopeService.GetDocument(Request, envelopeKey);
// Try to update the document with new data
if (!await api.UpdateDocument(Request.Body, document.Filepath))
{
throw new IOException("Document could not be saved to disk!");
}
// Update the document with new data
await envelopeService.UpdateDocument(Request.Body, document.Filepath);
// Add history entry
database.InsertHistoryEntry(new EnvelopeHistoryEntry()
{
ActionDescription = "Dokument wurde signiert",
ActionDate = DateTime.Now,
ActionType = EnvelopeHistoryActionType.Signed,
EnvelopeId = r.Envelope.Id,
UserReference = r.Receiver.Email
});
envelopeService.InsertHistoryEntrySigned(response);
return Ok();
}
catch (IOException e)
{
logger.Error(e);
return Problem(
statusCode: 500,
detail: e.Message,
type: ErrorType.ServerError.ToString());
}
catch (Exception e)
{
// Better error handling & reporting
logger.Error(e);
return Problem(
statusCode: 500,
detail: e.Message,
type: ErrorType.ServerError.ToString());
return ErrorResponse(e);
}
}
}

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

@ -2,24 +2,17 @@
using EnvelopeGenerator.Common;
using EnvelopeGenerator.Web.Services;
using Microsoft.AspNetCore.Mvc;
using NLog;
using static EnvelopeGenerator.Web.Constants;
namespace EnvelopeGenerator.Web.Controllers
{
public class EnvelopeController : Controller
public class EnvelopeController : BaseController
{
private readonly DatabaseService database;
private readonly LoggingService logging;
private readonly Logger logger;
private readonly ApiService api;
private readonly EnvelopeService envelopeService;
public EnvelopeController(DatabaseService database, LoggingService logging, ApiService api)
public EnvelopeController(DatabaseService database, LoggingService logging, EnvelopeService envelope) : base(database, logging)
{
this.database = database;
this.logging = logging;
this.logger = logging.LogConfig.GetLoggerFor(GetType().Name);
this.api = api;
envelopeService = envelope;
}
[HttpGet]
@ -28,23 +21,17 @@ namespace EnvelopeGenerator.Web.Controllers
{
try
{
logger.Info("Handling envelope loading.");
logger.Info("EnvelopeController/Get");
EnvelopeResponse r = api.EnsureValidEnvelopeKey(envelopeKey);
// Return the envelope and additional data as json
return Json(r);
// Validate Envelope Key and load envelope
envelopeService.EnsureValidEnvelopeKey(envelopeKey);
EnvelopeResponse response = envelopeService.LoadEnvelope(envelopeKey);
return Json(response);
}
catch (Exception e)
{
// Better error handling & reporting
logger.Error(e);
return Problem(
statusCode: 500,
detail: e.Message,
type: ErrorType.ServerError.ToString());
return ErrorResponse(e);
}
}
@ -54,24 +41,21 @@ namespace EnvelopeGenerator.Web.Controllers
{
try
{
logger.Info("Handling envelope saving.");
logger.Info("EnvelopeController/Update");
EnvelopeResponse r = api.EnsureValidEnvelopeKey(envelopeKey);
// Validate Envelope Key and load envelope
envelopeService.EnsureValidEnvelopeKey(envelopeKey);
EnvelopeResponse response = envelopeService.LoadEnvelope(envelopeKey);
var Request = ControllerContext.HttpContext.Request;
var document = api.GetDocument(Request, envelopeKey);
var document = envelopeService.GetDocument(Request, envelopeKey);
string? annotationData = await api.EnsureValidAnnotationData(Request);
string annotationData = await envelopeService.EnsureValidAnnotationData(Request);
if (annotationData == null)
envelopeService.InsertDocumentStatus(new DocumentStatus()
{
throw new ArgumentNullException("AnnotationData");
}
database.InsertDocumentStatus(new DocumentStatus()
{
EnvelopeId = r.Envelope.Id,
ReceiverId = r.Receiver.Id,
EnvelopeId = response.Envelope.Id,
ReceiverId = response.Receiver.Id,
Value = annotationData,
Status = Common.Constants.DocumentStatus.Signed
});
@ -80,12 +64,7 @@ namespace EnvelopeGenerator.Web.Controllers
}
catch (Exception e)
{
// Better error handling & reporting
logger.Error(e);
return Problem(
statusCode: 500,
detail: e.Message,
type: ErrorType.ServerError.ToString());
return ErrorResponse(e);
}
}
}

1
EnvelopeGenerator.Web/EnvelopeGenerator.Web.csproj
View File

@ -41,7 +41,6 @@
</ItemGroup>
<ItemGroup>
<Folder Include="Data\" />
<Folder Include="wwwroot\lib\NewFolder\" />
</ItemGroup>

4
EnvelopeGenerator.Web/Pages/Index.razor
View File

@ -1,7 +1,7 @@
@page "/"
@using EnvelopeGenerator.Common;
@using EnvelopeGenerator.Web.Services;
@inject DatabaseService Database;
@inject EnvelopeService Envelope;
<PageTitle>Index</PageTitle>
@ -32,7 +32,7 @@
protected override void OnInitialized()
{
// Test
envelopes = Database.LoadEnvelopes(receiverId);
envelopes = Envelope.LoadEnvelopes(receiverId);
}

6
EnvelopeGenerator.Web/Program.cs
View File

@ -6,11 +6,13 @@ var builder = WebApplication.CreateBuilder(args);
builder.Services.AddRazorPages();
builder.Services.AddServerSideBlazor();
// Add custom services
// Add base services
builder.Services.AddSingleton<LoggingService>();
builder.Services.AddSingleton<ApiService>();
builder.Services.AddTransient<DatabaseService>();
// Add higher order services
builder.Services.AddSingleton<EnvelopeService>();
builder.Services.AddControllers();
builder.Services.AddLocalization();

131
EnvelopeGenerator.Web/Services/ApiService.cs
View File

@ -1,131 +0,0 @@
using DigitalData.Modules.Database;
using DigitalData.Modules.Logging;
using EnvelopeGenerator.Common;
using Microsoft.Extensions.Primitives;
using System.Reflection;
using System.Reflection.Metadata;
using System.Text;
namespace EnvelopeGenerator.Web.Services
{
public class ApiService
{
private readonly DatabaseService database;
private readonly LogConfig logConfig;
private readonly Logger logger;
public ApiService(LoggingService Logging, DatabaseService database, IConfiguration Config)
{
this.database = database;
this.logConfig = Logging.LogConfig;
this.logger = Logging.LogConfig.GetLogger();
logger.Debug("Initializing ApiService");
}
public EnvelopeResponse EnsureValidEnvelopeKey(string envelopeKey)
{
logger.Debug("Parsing EnvelopeKey..");
if (string.IsNullOrEmpty(envelopeKey))
throw new ArgumentNullException("EnvelopeKey");
Tuple<string, string> result = Helpers.DecodeEnvelopeReceiverId(envelopeKey);
logger.Debug("EnvelopeUUID: [{0}]", result.Item1);
logger.Debug("ReceiverSignature: [{0}]", result.Item2);
if (string.IsNullOrEmpty(result.Item1))
throw new ArgumentNullException("EnvelopeUUID");
if (string.IsNullOrEmpty(result.Item2))
throw new ArgumentNullException("ReceiverSignature");
EnvelopeResponse response = database.LoadEnvelope(envelopeKey);
return response;
}
public async Task<string?> EnsureValidAnnotationData(HttpRequest request)
{
logger.Debug("Parsing AnnotationData..");
try
{
using MemoryStream ms = new();
await request.BodyReader.CopyToAsync(ms);
var bytes = ms.ToArray();
return Encoding.UTF8.GetString(bytes);
}
catch (Exception e)
{
logger.Error(e);
return null;
}
}
public int EnsureValidDocumentIndex(HttpRequest request)
{
if (request.Query.TryGetValue("index", out StringValues documentIndexString))
{
try
{
return int.Parse(documentIndexString.First());
}
catch (Exception e)
{
throw new ArgumentNullException("DocumentIndex", e);
}
}
else
{
throw new ArgumentNullException("DocumentIndex");
}
}
public EnvelopeDocument GetDocument(HttpRequest request, string envelopeKey)
{
EnvelopeResponse r = database.LoadEnvelope(envelopeKey);
int documentId = EnsureValidDocumentIndex(request);
var document = r.Envelope.Documents.
Where(d => d.Id == documentId).
FirstOrDefault();
if (document == null)
throw new ArgumentException("DocumentId");
return document;
}
public async Task<bool> UpdateDocument(Stream fileStream, string filePath)
{
try
{
using FileStream fs = new(filePath, FileMode.Open);
await fileStream.CopyToAsync(fs);
fs.Flush();
return true;
}
catch (Exception ex)
{
logger.Error(ex);
return false;
}
}
public State GetState(LogConfig LogConfig, MSSQLServer Database)
{
return new State
{
LogConfig = LogConfig,
Database = Database,
};
}
}
}

18
EnvelopeGenerator.Web/Services/BaseService.cs Normal file
View File

@ -0,0 +1,18 @@
using DigitalData.Modules.Logging;
namespace EnvelopeGenerator.Web.Services
{
public class BaseService
{
internal readonly LogConfig logConfig;
internal readonly IConfiguration config;
internal Logger logger;
public BaseService(IConfiguration Config, LoggingService Logging)
{
logConfig = Logging.LogConfig;
logger = Logging.LogConfig.GetLogger();
config = Config;
}
}
}

117
EnvelopeGenerator.Web/Services/DatabaseService.cs
View File

@ -1,116 +1,61 @@
using DigitalData.Modules.Database;
using DigitalData.Modules.Logging;
using EnvelopeGenerator.Common;
namespace EnvelopeGenerator.Web.Services
{
public class DatabaseService
public class DatabaseService: BaseService
{
public MSSQLServer MSSQL { get; set; }
private EnvelopeModel envelopeModel;
private DocumentModel documentModel;
private ReceiverModel receiverModel;
private ElementModel elementModel;
private HistoryModel historyModel;
private DocumentStatusModel documentStatusModel;
private readonly LogConfig _logConfig;
private readonly Logger _logger;
public DatabaseService(LoggingService Logging, IConfiguration Config)
public class ModelContainer
{
_logConfig = Logging.LogConfig;
_logger = Logging.LogConfig.GetLogger();
public EnvelopeModel envelopeModel;
public DocumentModel documentModel;
public ReceiverModel receiverModel;
public ElementModel elementModel;
public HistoryModel historyModel;
public DocumentStatusModel documentStatusModel;
_logger.Debug("Establishing MSSQL Database connection..");
MSSQL = new MSSQLServer(_logConfig, Config["Config:ConnectionString"]);
public ModelContainer(State state)
{
envelopeModel = new(state);
documentModel = new(state);
receiverModel = new(state);
elementModel = new(state);
historyModel = new(state);
documentStatusModel = new(state);
}
}
public readonly ModelContainer? Models;
public DatabaseService(IConfiguration Config, LoggingService Logging, DatabaseService database) : base(Config, Logging)
{
logger = Logging.LogConfig.GetLogger();
logger.Debug("Establishing MSSQL Database connection..");
MSSQL = new MSSQLServer(logConfig, Config["Config:ConnectionString"]);
if (MSSQL.DBInitialized == true)
{
_logger.Debug("MSSQL Connection: [{0}]", MSSQL.CurrentConnectionString);
logger.Debug("MSSQL Connection: [{0}]", MSSQL.CurrentConnectionString);
var state = GetState();
InitializeModels(state);
Models = new(state);
}
else
{
_logger.Warn("Connection could not be established!");
logger.Error("Connection could not be established!");
}
}
public State GetState()
private State GetState()
{
return new State
{
Database = MSSQL,
LogConfig = _logConfig,
LogConfig = logConfig,
UserId = 2 // TODO
};
}
public void InitializeModels(State state)
{
envelopeModel = new(state);
documentModel = new(state);
receiverModel = new(state);
elementModel = new(state);
historyModel = new(state);
documentStatusModel = new(state);
}
public EnvelopeResponse LoadEnvelope(string pEnvelopeKey)
{
Tuple<string, string> result = Helpers.DecodeEnvelopeReceiverId(pEnvelopeKey);
var envelopeUuid = result.Item1;
var receiverSignature = result.Item2;
var receiverId = receiverModel.GetReceiverIdBySignature(receiverSignature);
Envelope? envelope = envelopeModel.GetByUuid(envelopeUuid);
if (envelope == null)
{
throw new NullReferenceException("Envelope not found");
}
if (envelope.Receivers == null)
{
throw new NullReferenceException("Receivers for envelope not loaded");
}
EnvelopeReceiver? receiver = envelope.Receivers.Where(r => r.Id == receiverId).SingleOrDefault();
if (receiver == null)
{
throw new NullReferenceException("Receiver not found");
}
return new()
{
Receiver = receiver,
Envelope = envelope
};
}
public List<Envelope> LoadEnvelopes(int pReceiverId)
{
return (List<Envelope>)envelopeModel.List(pReceiverId);
}
public EnvelopeDocument LoadDocument(int pDocumentId)
{
return documentModel.GetById(pDocumentId);
}
public bool InsertHistoryEntry(EnvelopeHistoryEntry historyEntry)
{
return historyModel.Insert(historyEntry);
}
public bool InsertDocumentStatus(DocumentStatus documentStatus)
{
return documentStatusModel.InsertOrUpdate(documentStatus);
}
}
}

192
EnvelopeGenerator.Web/Services/EnvelopeService.cs Normal file
View File

@ -0,0 +1,192 @@
using EnvelopeGenerator.Common;
using Microsoft.Extensions.Primitives;
using System.Reflection.Metadata;
using System.Text;
using static EnvelopeGenerator.Common.Constants;
namespace EnvelopeGenerator.Web.Services
{
public class EnvelopeService : BaseService
{
private ReceiverModel receiverModel;
private EnvelopeModel envelopeModel;
private HistoryModel historyModel;
private DocumentModel documentModel;
private DocumentStatusModel documentStatusModel;
public EnvelopeService(IConfiguration Config, LoggingService Logging, DatabaseService database) : base(Config, Logging)
{
logger = Logging.LogConfig.GetLogger();
if (database.Models == null)
{
throw new ArgumentNullException("Models not loaded.");
}
receiverModel = database.Models.receiverModel;
envelopeModel = database.Models.envelopeModel;
historyModel = database.Models.historyModel;
documentModel = database.Models.documentModel;
documentStatusModel = database.Models.documentStatusModel;
}
public void EnsureValidEnvelopeKey(string envelopeKey)
{
logger.Debug("Parsing EnvelopeKey..");
if (string.IsNullOrEmpty(envelopeKey))
throw new ArgumentNullException("EnvelopeKey");
Tuple<string, string> result = Helpers.DecodeEnvelopeReceiverId(envelopeKey);
logger.Debug("EnvelopeUUID: [{0}]", result.Item1);
logger.Debug("ReceiverSignature: [{0}]", result.Item2);
if (string.IsNullOrEmpty(result.Item1))
throw new ArgumentNullException("EnvelopeUUID");
if (string.IsNullOrEmpty(result.Item2))
throw new ArgumentNullException("ReceiverSignature");
}
public EnvelopeResponse LoadEnvelope(string pEnvelopeKey)
{
Tuple<string, string> result = Helpers.DecodeEnvelopeReceiverId(pEnvelopeKey);
var envelopeUuid = result.Item1;
var receiverSignature = result.Item2;
var receiverId = receiverModel.GetReceiverIdBySignature(receiverSignature);
Envelope? envelope = envelopeModel.GetByUuid(envelopeUuid);
if (envelope == null)
{
throw new NullReferenceException("Envelope not found");
}
if (envelope.Receivers == null)
{
throw new NullReferenceException("Receivers for envelope not loaded");
}
EnvelopeReceiver? receiver = envelope.Receivers.Where(r => r.Id == receiverId).SingleOrDefault();
if (receiver == null)
{
throw new NullReferenceException("Receiver not found");
}
return new()
{
Receiver = receiver,
Envelope = envelope
};
}
public List<Envelope> LoadEnvelopes(int pReceiverId)
{
return (List<Envelope>)envelopeModel.List(pReceiverId);
}
public bool InsertHistoryEntry(EnvelopeHistoryEntry historyEntry)
{
return historyModel.Insert(historyEntry);
}
public bool InsertHistoryEntrySigned(EnvelopeResponse response)
{
return historyModel.Insert(new EnvelopeHistoryEntry()
{
ActionDescription = "Dokument wurde signiert",
ActionDate = DateTime.Now,
ActionType = EnvelopeHistoryActionType.Signed,
EnvelopeId = response.Envelope.Id,
UserReference = response.Receiver.Email
});
}
public bool InsertDocumentStatus(Common.DocumentStatus documentStatus)
{
return documentStatusModel.InsertOrUpdate(documentStatus);
}
public async Task<string?> EnsureValidAnnotationData(HttpRequest request)
{
try
{
logger.Debug("Parsing annotation data from request..");
using MemoryStream ms = new();
await request.BodyReader.CopyToAsync(ms);
var bytes = ms.ToArray();
return Encoding.UTF8.GetString(bytes);
}
catch (Exception e)
{
logger.Error(e);
throw new ArgumentNullException("AnnotationData");
}
}
public int EnsureValidDocumentIndex(HttpRequest request)
{
if (!request.Query.TryGetValue("index", out StringValues documentIndexStringList))
{
logger.Warn("There is no query parameter called index");
throw new ArgumentNullException("DocumentIndex");
}
if (documentIndexStringList.FirstOrDefault() == null)
{
logger.Warn("There is no query parameter called index");
throw new ArgumentNullException("DocumentIndex");
}
if (!int.TryParse(documentIndexStringList.First(), out int documentIndex))
{
logger.Warn("Invalid document index [{0}]", documentIndexStringList.First());
throw new ArgumentNullException("DocumentIndex");
}
return documentIndex;
}
public EnvelopeDocument GetDocument(HttpRequest request, string envelopeKey)
{
EnvelopeResponse response = LoadEnvelope(envelopeKey);
int documentId = EnsureValidDocumentIndex(request);
logger.Debug("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.Debug("Document [{0}] loaded!", documentId);
return document;
}
public async Task UpdateDocument(Stream fileStream, string filePath)
{
logger.Debug("Writing document to path [{0}]..", filePath);
using FileStream fs = new(filePath, FileMode.Open);
await fileStream.CopyToAsync(fs);
logger.Debug("Document written!");
}
public async Task<byte[]> GetDocumentContents(EnvelopeDocument document)
{
logger.Debug("Loading file [{0}]", document.Filepath);
var bytes = await File.ReadAllBytesAsync(document.Filepath);
logger.Info("File loaded, size: [{0}]", bytes.Length);
return bytes;
}
}
}