Janus007/PlanTempusApp
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Cleaning up with Rider

Browse source
This commit is contained in:
Janus C. H. Knudsen 2025-03-04 23:54:55 +01:00
parent 69758735de
commit 91da89a4e8
22 changed files with 574 additions and 386 deletions
Download patch file Download diff file Expand all files Collapse all files

137
Application/Components/ApiViewComponentBase.cs Normal file
View file

@ -0,0 +1,137 @@
using Microsoft.ApplicationInsights;
using Microsoft.AspNetCore.Mvc;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
namespace PlanTempus.Application.Components
{
public abstract class ApiViewComponentBase : ViewComponent
{
private readonly HttpClient _httpClient;
private readonly TelemetryClient _telemetry;
protected ApiViewComponentBase(IHttpClientFactory httpClientFactory, TelemetryClient telemetry)
{
_httpClient = httpClientFactory.CreateClient("ApiClient");
_telemetry = telemetry;
}
/// <summary>
/// Fetches data from API as JObject
/// </summary>
/// <param name="apiEndpoint">API endpoint path (e.g. "/api/product/get/1")</param>
/// <returns>JObject with API result</returns>
protected async Task<JObject> GetJObjectFromApiAsync(string apiEndpoint)
{
try
{
_telemetry.TrackEvent("ApiCall", new Dictionary<string, string>
{
["Endpoint"] = apiEndpoint,
["Source"] = "GetJObjectFromApiAsync"
});
// Use HttpClient to get JSON string
var response = await _httpClient.GetAsync(apiEndpoint);
response.EnsureSuccessStatusCode();
var jsonString = await response.Content.ReadAsStringAsync();
return JObject.Parse(jsonString);
}
catch (Exception ex)
{
_telemetry.TrackException(ex, new Dictionary<string, string>
{
["Endpoint"] = apiEndpoint,
["Method"] = "GetJObjectFromApiAsync"
});
return null;
}
}
/// <summary>
/// Fetches data from API as JArray
/// </summary>
/// <param name="apiEndpoint">API endpoint path</param>
/// <returns>JArray with API result</returns>
protected async Task<JArray> GetJArrayFromApiAsync(string apiEndpoint)
{
try
{
_telemetry.TrackEvent("ApiCall", new Dictionary<string, string>
{
["Endpoint"] = apiEndpoint,
["Source"] = "GetJArrayFromApiAsync"
});
// Use HttpClient to get JSON string
var response = await _httpClient.GetAsync(apiEndpoint);
response.EnsureSuccessStatusCode();
var jsonString = await response.Content.ReadAsStringAsync();
return JArray.Parse(jsonString);
}
catch (Exception ex)
{
_telemetry.TrackException(ex, new Dictionary<string, string>
{
["Endpoint"] = apiEndpoint,
["Method"] = "GetJArrayFromApiAsync"
});
return null;
}
}
/// <summary>
/// Sends POST request to API and receives JObject response
/// </summary>
/// <param name="apiEndpoint">API endpoint path</param>
/// <param name="data">Data to be sent (can be JObject or other type)</param>
/// <returns>JObject with response data</returns>
protected async Task<JObject> PostToApiAsync(string apiEndpoint, object data)
{
try
{
_telemetry.TrackEvent("ApiPost", new Dictionary<string, string>
{
["Endpoint"] = apiEndpoint
});
// Convert data to JSON string
var content = new StringContent(
JsonConvert.SerializeObject(data),
System.Text.Encoding.UTF8,
"application/json");
var response = await _httpClient.PostAsync(apiEndpoint, content);
response.EnsureSuccessStatusCode();
var jsonString = await response.Content.ReadAsStringAsync();
return JObject.Parse(jsonString);
}
catch (Exception ex)
{
_telemetry.TrackException(ex, new Dictionary<string, string>
{
["Endpoint"] = apiEndpoint,
["Method"] = "PostToApiAsync"
});
return null;
}
}
/// <summary>
/// Handles errors in a consistent way
/// </summary>
protected IViewComponentResult HandleError(string message = "An error occurred.")
{
_telemetry.TrackEvent("ComponentError", new Dictionary<string, string>
{
["Message"] = message,
["Component"] = this.GetType().Name
});
return Content(message);
}
}
}

43
Application/Components/OrganizationViewComponent.cs Normal file
View file

@ -0,0 +1,43 @@
using Microsoft.AspNetCore.Mvc;
using Microsoft.ApplicationInsights;
namespace PlanTempus.Application.Components
{
public class OrganizationViewComponent : ApiViewComponentBase
{
private readonly TelemetryClient _telemetry;
public OrganizationViewComponent(
IHttpClientFactory httpClientFactory,
TelemetryClient telemetry)
: base(httpClientFactory, telemetry)
{
_telemetry = telemetry;
}
public async Task<IViewComponentResult> InvokeAsync(int organizationId, bool showDetailedView = true)
{
_telemetry.TrackEvent($"{GetType().Name}Invoked", new Dictionary<string, string>
{
["OrganizationId"] = organizationId.ToString(),
["ShowDetailedView"] = showDetailedView.ToString()
});
var organization = await GetJObjectFromApiAsync($"/api/organization/get/{organizationId}");
if (organization == null)
return HandleError("Organization not found");
ViewBag.ShowDetailedView = showDetailedView;
_telemetry.TrackEvent("Viewed", new Dictionary<string, string>
{
["OrganizationId"] = organizationId.ToString(),
["Name"] = organization["name"]?.ToString()
});
return View(organization);
}
}
}

406
Core/Logging/SeqLogger.cs
View file

@ -3,238 +3,250 @@ using System.Text;
namespace PlanTempus.Core.Logging
{
public class SeqLogger<T>
{
private readonly SeqHttpClient _httpClient;
private readonly string _environmentName;
private readonly string _machineName;
private readonly SeqConfiguration _configuration;
public class SeqLogger<T>
{
private readonly SeqHttpClient _httpClient;
private readonly string _environmentName;
private readonly string _machineName;
private readonly SeqConfiguration _configuration;
public SeqLogger(SeqHttpClient httpClient, SeqConfiguration configuration)
{
_httpClient = httpClient;
_configuration = configuration;
}
public SeqLogger(SeqHttpClient httpClient, SeqConfiguration configuration)
{
_httpClient = httpClient;
_configuration = configuration;
}
public async Task LogAsync(TraceTelemetry trace, CancellationToken cancellationToken = default)
{
var seqEvent = new Dictionary<string, object>
{
{ "@t", trace.Timestamp.UtcDateTime.ToString("o") },
{ "@mt", trace.Message },
{ "@l", MapSeverityToLevel(trace.SeverityLevel) },
{ "Environment", _environmentName },
{ "MachineName", _machineName }
};
public async Task LogAsync(TraceTelemetry trace, CancellationToken cancellationToken = default)
{
var seqEvent = new Dictionary<string, object>
{
{ "@t", trace.Timestamp.UtcDateTime.ToString("o") },
{ "@mt", trace.Message },
{ "@l", MapSeverityToLevel(trace.SeverityLevel) },
{ "Environment", _environmentName },
{ "MachineName", _machineName }
};
foreach (var prop in trace.Properties)
seqEvent.Add($"prop_{prop.Key}", prop.Value);
foreach (var prop in trace.Properties)
seqEvent.Add($"prop_{prop.Key}", prop.Value);
foreach (var prop in trace.Context.GlobalProperties)
seqEvent.Add($"global_{prop.Key}", prop.Value);
foreach (var prop in trace.Context.GlobalProperties)
seqEvent.Add($"global_{prop.Key}", prop.Value);
await SendToSeqAsync(seqEvent, cancellationToken);
}
await SendToSeqAsync(seqEvent, cancellationToken);
}
public async Task LogAsync(EventTelemetry evt, CancellationToken cancellationToken = default)
{
var seqEvent = new Dictionary<string, object>
{
{ "@t", evt.Timestamp.UtcDateTime.ToString("o") },
{ "@mt", evt.Name },
{ "@l", "Information" },
{ "Environment", _environmentName },
{ "MachineName", _machineName }
};
public async Task LogAsync(EventTelemetry evt, CancellationToken cancellationToken = default)
{
var seqEvent = new Dictionary<string, object>
{
{ "@t", evt.Timestamp.UtcDateTime.ToString("o") },
{ "@mt", evt.Name },
{ "@l", "Information" },
{ "Environment", _environmentName },
{ "MachineName", _machineName }
};
foreach (var prop in evt.Properties)
seqEvent.Add($"prop_{prop.Key}", prop.Value);
foreach (var prop in evt.Properties)
seqEvent.Add($"prop_{prop.Key}", prop.Value);
foreach (var prop in evt.Context.GlobalProperties)
seqEvent.Add($"global_{prop.Key}", prop.Value);
foreach (var prop in evt.Context.GlobalProperties)
seqEvent.Add($"global_{prop.Key}", prop.Value);
foreach (var metric in evt.Metrics)
seqEvent.Add($"metric_{metric.Key}", metric.Value);
foreach (var metric in evt.Metrics)
seqEvent.Add($"metric_{metric.Key}", metric.Value);
await SendToSeqAsync(seqEvent, cancellationToken);
}
await SendToSeqAsync(seqEvent, cancellationToken);
}
public async Task LogAsync(ExceptionTelemetry ex, CancellationToken cancellationToken = default)
{
var seqEvent = new Dictionary<string, object>
{
{ "@t", ex.Timestamp.UtcDateTime.ToString("o") },
{ "@mt", ex.Exception.Message },
{ "@l", "Error" },
{ "@x", FormatExceptionForSeq(ex.Exception) },
{ "Environment", _environmentName },
{ "MachineName", _machineName },
{ "ExceptionType", ex.Exception.GetType().Name },
};
public async Task LogAsync(ExceptionTelemetry ex, CancellationToken cancellationToken = default)
{
var seqEvent = new Dictionary<string, object>
{
{ "@t", ex.Timestamp.UtcDateTime.ToString("o") },
{ "@mt", ex.Exception.Message },
{ "@l", "Error" },
{ "@x", FormatExceptionForSeq(ex.Exception) },
{ "Environment", _environmentName },
{ "MachineName", _machineName },
{ "ExceptionType", ex.Exception.GetType().Name },
};
foreach (var prop in ex.Properties)
seqEvent.Add($"prop_{prop.Key}", prop.Value);
foreach (var prop in ex.Properties)
seqEvent.Add($"prop_{prop.Key}", prop.Value);
foreach (var prop in ex.Context.GlobalProperties)
seqEvent.Add($"global_{prop.Key}", prop.Value);
foreach (var prop in ex.Context.GlobalProperties)
seqEvent.Add($"global_{prop.Key}", prop.Value);
await SendToSeqAsync(seqEvent, cancellationToken);
}
await SendToSeqAsync(seqEvent, cancellationToken);
}
public async Task LogAsync(DependencyTelemetry dep, CancellationToken cancellationToken = default)
{
var seqEvent = new Dictionary<string, object>
{
{ "@t", dep.Timestamp.UtcDateTime.ToString("o") },
{ "@mt", $"Dependency: {dep.Name}" },
{ "@l", dep.Success??true ? "Information" : "Error" },
{ "Environment", _environmentName },
{ "MachineName", _machineName },
{ "DependencyType", dep.Type },
{ "Target", dep.Target },
{ "Duration", dep.Duration.TotalMilliseconds }
};
public async Task LogAsync(DependencyTelemetry dep, CancellationToken cancellationToken = default)
{
var seqEvent = new Dictionary<string, object>
{
{ "@t", dep.Timestamp.UtcDateTime.ToString("o") },
{ "@mt", $"Dependency: {dep.Name}" },
{ "@l", dep.Success ?? true ? "Information" : "Error" },
{ "Environment", _environmentName },
{ "MachineName", _machineName },
{ "DependencyType", dep.Type },
{ "Target", dep.Target },
{ "Duration", dep.Duration.TotalMilliseconds }
};
foreach (var prop in dep.Properties)
seqEvent.Add($"prop_{prop.Key}", prop.Value);
foreach (var prop in dep.Properties)
seqEvent.Add($"prop_{prop.Key}", prop.Value);
foreach (var prop in dep.Context.GlobalProperties)
seqEvent.Add($"global_{prop.Key}", prop.Value);
foreach (var prop in dep.Context.GlobalProperties)
seqEvent.Add($"global_{prop.Key}", prop.Value);
await SendToSeqAsync(seqEvent, cancellationToken);
}
await SendToSeqAsync(seqEvent, cancellationToken);
}
public async Task LogAsync(RequestTelemetry req, CancellationToken cancellationToken = default)
{
throw new NotImplementedException();
}
public async Task LogAsync(Microsoft.ApplicationInsights.Extensibility.IOperationHolder<RequestTelemetry> operationHolder, CancellationToken cancellationToken = default)
{
var req = operationHolder.Telemetry;
public async Task LogAsync(RequestTelemetry req, CancellationToken cancellationToken = default)
{
await Task.CompletedTask;
throw new NotImplementedException();
}
//https://docs.datalust.co/v2025.1/docs/posting-raw-events
var seqEvent = new Dictionary<string, object>
{
public async Task LogAsync(
Microsoft.ApplicationInsights.Extensibility.IOperationHolder<RequestTelemetry> operationHolder,
CancellationToken cancellationToken = default)
{
var req = operationHolder.Telemetry;
{ "@t", req.Timestamp.UtcDateTime.ToString("o") },
{ "@mt",req.Name },
{ "@l", req.Success??true ? "Information" : "Error" },
{ "@sp", req.Id }, //Span id Unique identifier of a span Yes, if the event is a span
{ "@tr", req.Context.Operation.Id}, //Trace id An identifier that groups all spans and logs that are in the same trace Yes, if the event is a span
{ "@sk","Server" }, //Span kind Describes the relationship of the span to others in the trace: Client, Server, Internal, Producer, or Consumer
{ "@st", req.Timestamp.UtcDateTime.Subtract(req.Duration).ToString("o") }, //Start The start ISO 8601 timestamp of this span Yes, if the event is a span
//https://docs.datalust.co/v2025.1/docs/posting-raw-events
var seqEvent = new Dictionary<string, object>
{
{ "@t", req.Timestamp.UtcDateTime.ToString("o") },
{ "@mt", req.Name },
{ "@l", req.Success ?? true ? "Information" : "Error" },
{ "@sp", req.Id }, //Span id Unique identifier of a span Yes, if the event is a span
{
"@tr", req.Context.Operation.Id
}, //Trace id An identifier that groups all spans and logs that are in the same trace Yes, if the event is a span
{
"@sk", "Server"
}, //Span kind Describes the relationship of the span to others in the trace: Client, Server, Internal, Producer, or Consumer
{
"@st", req.Timestamp.UtcDateTime.Subtract(req.Duration).ToString("o")
}, //Start The start ISO 8601 timestamp of this span Yes, if the event is a span
{ "SourceContext", typeof(T).FullName },
{ "Url", req.Url },
{ "RequestId", req.Id },
{ "ItemTypeFlag", req.ItemTypeFlag.ToString() }
};
{ "Url", req.Url },
{ "RequestId", req.Id },
{ "ItemTypeFlag", req.ItemTypeFlag.ToString() }
};
if (!string.IsNullOrEmpty(req.ResponseCode))
{
if (int.TryParse(req.ResponseCode, out int statusCode))
{
if (Enum.IsDefined(typeof(System.Net.HttpStatusCode), statusCode))
seqEvent["StatusCode"] = $"{statusCode} {(System.Net.HttpStatusCode)statusCode}";
else
seqEvent["StatusCode"] = $"{statusCode} Unknown";
}
}
if (!string.IsNullOrEmpty(req.Context.Operation.ParentId))
seqEvent["@ps"] = req.Context.Operation.ParentId;
if (!string.IsNullOrEmpty(req.ResponseCode))
{
if (int.TryParse(req.ResponseCode, out int statusCode))
{
if (Enum.IsDefined(typeof(System.Net.HttpStatusCode), statusCode))
seqEvent["StatusCode"] = $"{statusCode} {(System.Net.HttpStatusCode)statusCode}";
else
seqEvent["StatusCode"] = $"{statusCode} Unknown";
}
}
if (req.Properties.TryGetValue("httpMethod", out string method))
{
seqEvent["RequestMethod"] = method;
seqEvent["@mt"] = $"{req.Properties["httpMethod"]} {req.Name}";
req.Properties.Remove("httpMethod");
}
if (!string.IsNullOrEmpty(req.Context.Operation.ParentId))
seqEvent["@ps"] = req.Context.Operation.ParentId;
foreach (var prop in req.Properties)
seqEvent.Add($"prop_{prop.Key}", prop.Value);
if (req.Properties.TryGetValue("httpMethod", out string method))
{
seqEvent["RequestMethod"] = method;
seqEvent["@mt"] = $"{req.Properties["httpMethod"]} {req.Name}";
req.Properties.Remove("httpMethod");
}
foreach (var prop in req.Context.GlobalProperties)
seqEvent.Add($"{prop.Key}", prop.Value);
foreach (var prop in req.Properties)
seqEvent.Add($"prop_{prop.Key}", prop.Value);
await SendToSeqAsync(seqEvent, cancellationToken);
}
private async Task SendToSeqAsync(Dictionary<string, object> seqEvent, CancellationToken cancellationToken)
{
var content = new StringContent(
Newtonsoft.Json.JsonConvert.SerializeObject(seqEvent),
Encoding.UTF8,
"application/vnd.serilog.clef");
foreach (var prop in req.Context.GlobalProperties)
seqEvent.Add($"{prop.Key}", prop.Value);
var requestMessage = new HttpRequestMessage(HttpMethod.Post, "/ingest/clef")
{
Content = content
};
await SendToSeqAsync(seqEvent, cancellationToken);
}
var result = await _httpClient.SendAsync(requestMessage, cancellationToken);
private async Task SendToSeqAsync(Dictionary<string, object> seqEvent, CancellationToken cancellationToken)
{
var content = new StringContent(
Newtonsoft.Json.JsonConvert.SerializeObject(seqEvent),
Encoding.UTF8,
"application/vnd.serilog.clef");
result.EnsureSuccessStatusCode();
}
var requestMessage = new HttpRequestMessage(HttpMethod.Post, "/ingest/clef")
{
Content = content
};
private static string MapSeverityToLevel(SeverityLevel? severity)
{
return severity switch
{
SeverityLevel.Verbose => "Verbose",
SeverityLevel.Information => "Information",
SeverityLevel.Warning => "Warning",
SeverityLevel.Error => "Error",
SeverityLevel.Critical => "Fatal",
_ => "Information"
};
}
private static string FormatExceptionForSeq(Exception ex)
{
var sb = new StringBuilder();
var exceptionCount = 0;
var result = await _httpClient.SendAsync(requestMessage, cancellationToken);
void FormatSingleException(Exception currentEx, int depth)
{
if (depth > 0) sb.AppendLine("\n--- Inner Exception ---");
result.EnsureSuccessStatusCode();
}
sb.AppendLine($"Exception Type: {currentEx.GetType().FullName}");
sb.AppendLine($"Message: {currentEx.Message}");
sb.AppendLine($"Source: {currentEx.Source}");
sb.AppendLine($"HResult: 0x{currentEx.HResult:X8}");
sb.AppendLine("Stack Trace:");
sb.AppendLine(currentEx.StackTrace?.Trim());
private static string MapSeverityToLevel(SeverityLevel? severity)
{
return severity switch
{
SeverityLevel.Verbose => "Verbose",
SeverityLevel.Information => "Information",
SeverityLevel.Warning => "Warning",
SeverityLevel.Error => "Error",
SeverityLevel.Critical => "Fatal",
_ => "Information"
};
}
if (currentEx.Data.Count > 0)
{
sb.AppendLine("Additional Data:");
foreach (var key in currentEx.Data.Keys)
{
sb.AppendLine($" {key}: {currentEx.Data[key]}");
}
}
}
private static string FormatExceptionForSeq(Exception ex)
{
var sb = new StringBuilder();
var exceptionCount = 0;
void RecurseExceptions(Exception currentEx, int depth = 0)
{
if (currentEx is AggregateException aggEx)
{
foreach (var inner in aggEx.InnerExceptions)
{
RecurseExceptions(inner, depth);
depth++;
}
}
else if (currentEx.InnerException != null)
{
RecurseExceptions(currentEx.InnerException, depth + 1);
}
void FormatSingleException(Exception currentEx, int depth)
{
if (depth > 0) sb.AppendLine("\n--- Inner Exception ---");
FormatSingleException(currentEx, depth);
exceptionCount++;
}
sb.AppendLine($"Exception Type: {currentEx.GetType().FullName}");
sb.AppendLine($"Message: {currentEx.Message}");
sb.AppendLine($"Source: {currentEx.Source}");
sb.AppendLine($"HResult: 0x{currentEx.HResult:X8}");
sb.AppendLine("Stack Trace:");
sb.AppendLine(currentEx.StackTrace?.Trim());
RecurseExceptions(ex);
sb.Insert(0, $"EXCEPTION CHAIN ({exceptionCount} exceptions):\n");
return sb.ToString();
}
}
}
if (currentEx.Data.Count > 0)
{
sb.AppendLine("Additional Data:");
foreach (var key in currentEx.Data.Keys)
{
sb.AppendLine($" {key}: {currentEx.Data[key]}");
}
}
}
void RecurseExceptions(Exception currentEx, int depth = 0)
{
if (currentEx is AggregateException aggEx)
{
foreach (var inner in aggEx.InnerExceptions)
{
RecurseExceptions(inner, depth);
depth++;
}
}
else if (currentEx.InnerException != null)
{
RecurseExceptions(currentEx.InnerException, depth + 1);
}
FormatSingleException(currentEx, depth);
exceptionCount++;
}
RecurseExceptions(ex);
sb.Insert(0, $"EXCEPTION CHAIN ({exceptionCount} exceptions):\n");
return sb.ToString();
}
}
}

1
Core/MultiKeyEncryption/MasterKey.cs
View file

@ -4,6 +4,7 @@
{
public async Task RotateMasterKey(int tenantId, string oldMasterKey, string newMasterKey)
{
await Task.CompletedTask;
// Hent alle bruger-keys for tenant
//var users = await GetTenantUsers(tenantId);

1
Core/SecureTokenizer.cs
View file

@ -1,6 +1,5 @@
namespace PlanTempus.Core
{
public class SecureTokenizer : ISecureTokenizer
{
private const int _saltSize = 16; // 128 bit

2
Core/Sql/ConnectionFactory/IDbConnectionFactory.cs
View file

@ -1,7 +1,5 @@
namespace PlanTempus.Core.Sql.ConnectionFactory
{
public record ConnectionStringParameters(string user, string pwd);
public interface IDbConnectionFactory
{
System.Data.IDbConnection Create();

5
Core/Sql/ConnectionFactory/PostgresConnectionFactory.cs
View file

@ -3,6 +3,7 @@ using System.Data;
namespace PlanTempus.Core.Sql.ConnectionFactory
{
public record ConnectionStringParameters(string User, string Pwd);
public class PostgresConnectionFactory : IDbConnectionFactory, IAsyncDisposable
{
@ -34,8 +35,8 @@ namespace PlanTempus.Core.Sql.ConnectionFactory
var connectionStringBuilder = new NpgsqlConnectionStringBuilder(
_baseDataSource.ConnectionString)
{
Username = param.user,
Password = param.pwd
Username = param.User,
Password = param.Pwd
};
var tempDataSourceBuilder = new NpgsqlDataSourceBuilder(

35
Core/Sql/DatabaseScope.cs Normal file
View file

@ -0,0 +1,35 @@
using System.Data;
using Microsoft.ApplicationInsights.DataContracts;
using Microsoft.ApplicationInsights.Extensibility;
namespace PlanTempus.Core.Sql;
public class DatabaseScope : IDisposable
{
private readonly IOperationHolder<DependencyTelemetry> _operation;
public DatabaseScope(IDbConnection connection, IOperationHolder<DependencyTelemetry> operation)
{
Connection = connection;
_operation = operation;
}
public IDbConnection Connection { get; }
public void Dispose()
{
_operation.Dispose();
Connection.Dispose();
}
public void Success()
{
_operation.Telemetry.Success = true;
}
public void Error(Exception ex)
{
_operation.Telemetry.Success = false;
_operation.Telemetry.Properties["Error"] = ex.Message;
}
}

10
Core/Sql/IDatabaseOperations.cs Normal file
View file

@ -0,0 +1,10 @@
using System.Data;
namespace PlanTempus.Core.Sql;
public interface IDatabaseOperations
{
DatabaseScope CreateScope(string operationName);
Task<T> ExecuteAsync<T>(Func<IDbConnection, Task<T>> operation, string operationName);
Task ExecuteAsync(Func<IDbConnection, Task> operation, string operationName);
}

141
Core/Sql/SqlOperations.cs
View file

@ -1,100 +1,59 @@
using Microsoft.ApplicationInsights;
using System.Data;
using Microsoft.ApplicationInsights;
using Microsoft.ApplicationInsights.DataContracts;
using Microsoft.ApplicationInsights.Extensibility;
using PlanTempus.Core.Sql.ConnectionFactory;
using System.Data;
namespace PlanTempus.Core.Sql
namespace PlanTempus.Core.Sql;
public class SqlOperations : IDatabaseOperations
{
public class DatabaseScope : IDisposable
{
private readonly IDbConnection _connection;
private readonly IOperationHolder<DependencyTelemetry> _operation;
private readonly IDbConnectionFactory _connectionFactory;
private readonly TelemetryClient _telemetryClient;
public DatabaseScope(IDbConnection connection, IOperationHolder<DependencyTelemetry> operation)
{
_connection = connection;
_operation = operation;
}
public SqlOperations(IDbConnectionFactory connectionFactory, TelemetryClient telemetryClient)
{
_connectionFactory = connectionFactory;
_telemetryClient = telemetryClient;
}
public IDbConnection Connection => _connection;
public DatabaseScope CreateScope(string operationName)
{
var connection = _connectionFactory.Create();
var operation = _telemetryClient.StartOperation<DependencyTelemetry>(operationName);
operation.Telemetry.Type = "SQL";
operation.Telemetry.Target = "PostgreSQL";
public void Success()
{
_operation.Telemetry.Success = true;
}
return new DatabaseScope(connection, operation);
}
public void Error(Exception ex)
{
_operation.Telemetry.Success = false;
_operation.Telemetry.Properties["Error"] = ex.Message;
}
public async Task<T> ExecuteAsync<T>(Func<IDbConnection, Task<T>> operation, string operationName)
{
using var scope = CreateScope(operationName);
try
{
var result = await operation(scope.Connection);
scope.Success();
return result;
}
catch (Exception ex)
{
scope.Error(ex);
throw;
}
}
public void Dispose()
{
_operation.Dispose();
_connection.Dispose();
}
}
public interface IDatabaseOperations
{
DatabaseScope CreateScope(string operationName);
Task<T> ExecuteAsync<T>(Func<IDbConnection, Task<T>> operation, string operationName);
Task ExecuteAsync(Func<IDbConnection, Task> operation, string operationName);
}
public class SqlOperations : IDatabaseOperations
{
private readonly IDbConnectionFactory _connectionFactory;
private readonly TelemetryClient _telemetryClient;
public SqlOperations(IDbConnectionFactory connectionFactory, TelemetryClient telemetryClient)
{
_connectionFactory = connectionFactory;
_telemetryClient = telemetryClient;
}
public DatabaseScope CreateScope(string operationName)
{
var connection = _connectionFactory.Create();
var operation = _telemetryClient.StartOperation<DependencyTelemetry>(operationName);
operation.Telemetry.Type = "SQL";
operation.Telemetry.Target = "PostgreSQL";
return new DatabaseScope(connection, operation);
}
public async Task<T> ExecuteAsync<T>(Func<IDbConnection, Task<T>> operation, string operationName)
{
using var scope = CreateScope(operationName);
try
{
var result = await operation(scope.Connection);
scope.Success();
return result;
}
catch (Exception ex)
{
scope.Error(ex);
throw;
}
}
public async Task ExecuteAsync(Func<IDbConnection, Task> operation, string operationName)
{
using var scope = CreateScope(operationName);
try
{
await operation(scope.Connection);
scope.Success();
}
catch (Exception ex)
{
scope.Error(ex);
throw;
}
}
}
}
public async Task ExecuteAsync(Func<IDbConnection, Task> operation, string operationName)
{
using var scope = CreateScope(operationName);
try
{
await operation(scope.Connection);
scope.Success();
}
catch (Exception ex)
{
scope.Error(ex);
throw;
}
}
}

1
Database/ConfigurationManagementSystem/SetupConfiguration.cs
View file

@ -19,6 +19,7 @@ public class SetupConfiguration : IDbConfigure<SetupConfiguration.Command>
{
using var conn = parameters is null ? _connectionFactory.Create() : _connectionFactory.Create(parameters);
using var transaction = conn.OpenWithTransaction();
try
{
CreateConfigurationTable(conn);

1
Database/Core/DCL/SetupDbAdmin.cs
View file

@ -2,7 +2,6 @@
using Insight.Database;
using PlanTempus.Core.Sql.ConnectionFactory;
using PlanTempus.Database.Common;
using PlanTempus.Database.Core;
namespace PlanTempus.Database.Core.DCL
{

2
PlanTempus.Components/Organizations/Create/CreateOrganizationCommand.cs
View file

@ -3,7 +3,7 @@
public class CreateOrganizationCommand
{
public string Name { get; set; }
public string Description { get; set; }
public string ConnectionString { get; set; }
public Guid CreatedById { get; set; }
}
}

30
PlanTempus.Components/Organizations/Create/CreateOrganizationHandler.cs
View file

@ -12,37 +12,27 @@ namespace PlanTempus.Components.Organizations.Create
_databaseOperations = databaseOperations;
}
public async Task<CreateOrganizationResponse> Handle(CreateOrganizationCommand command)
public async Task<CreateOrganizationResult> Handle(CreateOrganizationCommand command)
{
using var db = _databaseOperations.CreateScope(nameof(CreateOrganizationHandler));
try
{
var organizationId = Guid.NewGuid();
var now = DateTime.UtcNow;
var sql = @"
INSERT INTO organizations (id, name, description, created_by_id)
VALUES (@Id, @Name, @Description, @CreatedById)";
var sql = @"
INSERT INTO organizations (connection_string, created_by)
VALUES (@ConnectionString, @CreatedBy)
RETURNING id, created_at";
await db.Connection.ExecuteSqlAsync(sql, new
var data = await db.Connection.QuerySqlAsync<CreateOrganizationResult>(sql, new
{
Id = organizationId,
command.Name,
command.Description,
CreatedById = command.CreatedById,
CreatedAt = now,
UpdatedAt = now
ConnectionString = command.ConnectionString,
CreatedBy = command.CreatedById
});
db.Success();
return new CreateOrganizationResponse
{
Id = organizationId,
Name = command.Name,
CreatedAt = now
};
return data.First();
}
catch (Exception ex)
{

15
PlanTempus.Components/Organizations/Create/CreateOrganizationResponse.cs
View file

@ -1,15 +0,0 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace PlanTempus.Components.Organizations.Create
{
public class CreateOrganizationResponse
{
public Guid Id { get; set; }
public string Name { get; set; }
public DateTime CreatedAt { get; set; }
}
}

8
PlanTempus.Components/Organizations/Create/CreateOrganizationResult.cs Normal file
View file

@ -0,0 +1,8 @@
namespace PlanTempus.Components.Organizations.Create
{
public class CreateOrganizationResult
{
public int Id { get; set; }
public DateTime CreatedAt { get; set; }
}
}

2
PlanTempus.Components/Users/Create/CreateUserController.cs
View file

@ -7,7 +7,7 @@ namespace PlanTempus.Components.Users.Create
public class CreateUserController(CreateUserHandler handler, CreateUserValidator validator) : ControllerBase
{
[HttpPost]
public async Task<ActionResult<CreateUserResponse>> Create([FromBody] CreateUserCommand command)
public async Task<ActionResult<CreateUserResult>> Create([FromBody] CreateUserCommand command)
{
try
{

81
PlanTempus.Components/Users/Create/CreateUserHandler.cs
View file

@ -5,60 +5,41 @@ using PlanTempus.Core.Sql;
namespace PlanTempus.Components.Users.Create
{
public class CreateUserHandler(IDatabaseOperations databaseOperations, ISecureTokenizer secureTokenizer)
{
private readonly ISecureTokenizer _secureTokenizer;
public async Task<CreateUserResponse> Handle(CreateUserCommand command)
{
using var db = databaseOperations.CreateScope(nameof(CreateUserHandler));
try
{
var sql = @"
{
public async Task<CreateUserResult> Handle(CreateUserCommand command)
{
using var db = databaseOperations.CreateScope(nameof(CreateUserHandler));
try
{
var sql = @"
INSERT INTO system.users(email, password_hash, security_stamp, email_confirmed,
access_failed_count, lockout_enabled, lockout_end,
is_active, created_at, last_login_at)
access_failed_count, lockout_enabled,
is_active)
VALUES(@Email, @PasswordHash, @SecurityStamp, @EmailConfirmed,
@AccessFailedCount, @LockoutEnabled, @LockoutEnd,
@IsActive, @CreatedAt, @LastLoginAt)
RETURNING id, created_at";
@AccessFailedCount, @LockoutEnabled, @IsActive)
RETURNING id, created_at, email, is_active";
var result = await db.Connection.QuerySqlAsync<UserCreationResult>(sql, new
{
Email = command.Email,
PasswordHash = secureTokenizer.TokenizeText(command.Password),
SecurityStamp = Guid.NewGuid().ToString("N"),
EmailConfirmed = false,
AccessFailedCount = 0,
LockoutEnabled = true,
LockoutEnd = (DateTime?)null,
IsActive = command.IsActive,
CreatedAt = DateTime.UtcNow,
LastLoginAt = (DateTime?)null
});
var data = await db.Connection.QuerySqlAsync<CreateUserResult>(sql, new
{
Email = command.Email,
PasswordHash = secureTokenizer.TokenizeText(command.Password),
SecurityStamp = Guid.NewGuid().ToString("N"),
EmailConfirmed = false,
AccessFailedCount = 0,
LockoutEnabled = false,
IsActive = command.IsActive,
});
var createdUser = result.First();
db.Success();
db.Success();
return new CreateUserResponse
{
Id = createdUser.Id,
Email = command.Email,
IsActive = command.IsActive,
CreatedAt = createdUser.CreatedAt
};
}
catch (Exception ex)
{
db.Error(ex);
throw;
}
}
private class UserCreationResult
{
public long Id { get; set; }
public DateTime CreatedAt { get; set; }
}
}
return data.First();
}
catch (Exception ex)
{
db.Error(ex);
throw;
}
}
}
}

2
PlanTempus.Components/Users/Create/CreateUserResponse.cs → PlanTempus.Components/Users/Create/CreateUserResult.cs
View file

@ -1,7 +1,7 @@
namespace PlanTempus.Components.Users.Create
{
public class CreateUserResponse
public class CreateUserResult
{
public long Id { get; set; }
public string Email { get; set; }

6
SetupInfrastructure/Program.cs
View file

@ -170,8 +170,8 @@ namespace PlanTempus.SetupInfrastructure
string.IsNullOrEmpty(userPass.Split(":")[1]));
var superUser = new ConnectionStringParameters(
user: userPass.Split(":")[0],
pwd: userPass.Split(":")[1]
User: userPass.Split(":")[0],
Pwd: userPass.Split(":")[1]
);
if (IsSuperAdmin(superUser))
@ -191,7 +191,7 @@ namespace PlanTempus.SetupInfrastructure
sw.Restart();
//use application user, we use that role from now.
var connParams = new ConnectionStringParameters(user: "heimdall", pwd: "3911");
var connParams = new ConnectionStringParameters(User: "heimdall", Pwd: "3911");
_setupIdentitySystem.With(new SetupIdentitySystem.Command { Schema = "system" }, connParams);
Console.WriteLine($"DONE, took: {sw.ElapsedMilliseconds} ms");

2
SqlManagement/.dbeaver/.project-metadata.json.bak
View file

@ -1 +1 @@
{"resources":{"Scripts/Script-1.sql":{"default-datasource":"postgres-jdbc-1948450a8b4-5fc9eec404e65c44","default-catalog":"ptmain"},"Scripts/Script.sql":{"default-datasource":"postgres-jdbc-1948450a8b4-5fc9eec404e65c44","default-catalog":"ptmain"},"Scripts/SmartConfigSystem.sql":{"default-datasource":"postgres-jdbc-1948450a8b4-5fc9eec404e65c44","default-catalog":"ptdb01"},"Scripts/grant-privileges.sql":{"default-datasource":"postgres-jdbc-1948450a8b4-5fc9eec404e65c44"}}}
{"resources":{"Scripts/Script-1.sql":{"default-datasource":"postgres-jdbc-1948450a8b4-5fc9eec404e65c44","default-catalog":"ptmain"},"Scripts/Script.sql":{"default-datasource":"postgres-jdbc-1948450a8b4-5fc9eec404e65c44","default-catalog":"ptmain"},"Scripts/SmartConfigSystem.sql":{"default-datasource":"postgres-jdbc-1948450a8b4-5fc9eec404e65c44","default-catalog":"ptdb01"},"Scripts/grant-privileges.sql":{"default-datasource":"postgres-jdbc-1948450a8b4-5fc9eec404e65c44","default-catalog":"ptmain"}}}

29
qodana.yaml Normal file
View file

@ -0,0 +1,29 @@
#-------------------------------------------------------------------------------#
# Qodana analysis is configured by qodana.yaml file #
# https://www.jetbrains.com/help/qodana/qodana-yaml.html #
#-------------------------------------------------------------------------------#
version: "1.0"
#Specify IDE code to run analysis without container (Applied in CI/CD pipeline)
ide: QDNET
#Specify inspection profile for code analysis
profile:
name: qodana.starter
#Enable inspections
#include:
# - name: <SomeEnabledInspectionId>
#Disable inspections
#exclude:
# - name: <SomeDisabledInspectionId>
# paths:
# - <path/where/not/run/inspection>
#Execute shell command before Qodana execution (Applied in CI/CD pipeline)
#bootstrap: sh ./prepare-qodana.sh
#Install IDE plugins before Qodana execution (Applied in CI/CD pipeline)
#plugins:
# - id: <plugin.id> #(plugin id can be found at https://plugins.jetbrains.com)