WIP

Core/Sql/ConnectionFactory/IDbConnectionFactory.cs

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

Core/Sql/ConnectionFactory/PostgresConnectionFactory.cs

@@ -0,0 +1,65 @@
+using Npgsql;
+using System.Data;
+namespace PlanTempus.Core.Sql.ConnectionFactory
+{
+
+
+	public class PostgresConnectionFactory : IDbConnectionFactory, IAsyncDisposable
+	{
+		private readonly NpgsqlDataSource _baseDataSource;
+		private readonly Action<NpgsqlDataSourceBuilder> _configureDataSource;
+		private readonly Microsoft.Extensions.Logging.ILoggerFactory _loggerFactory; //this is not tested nor implemented, I just created it as an idea
+
+		public PostgresConnectionFactory(
+			string connectionString,
+			Microsoft.Extensions.Logging.ILoggerFactory loggerFactory = null,
+			Action<NpgsqlDataSourceBuilder> configureDataSource = null)
+		{
+			_loggerFactory = loggerFactory;
+			_configureDataSource = configureDataSource ?? (builder => { });
+
+			// Opret base data source med konfiguration
+			var dataSourceBuilder = new NpgsqlDataSourceBuilder(connectionString);
+			ConfigureDataSourceBuilder(dataSourceBuilder);
+			_baseDataSource = dataSourceBuilder.Build();
+		}
+
+		public IDbConnection Create()
+		{
+			return _baseDataSource.CreateConnection();
+		}
+
+		public IDbConnection Create(ConnectionStringParameters param)
+		{
+			var connectionStringBuilder = new NpgsqlConnectionStringBuilder(
+				_baseDataSource.ConnectionString)
+			{
+				Username = param.user,
+				Password = param.pwd
+			};
+
+			var tempDataSourceBuilder = new NpgsqlDataSourceBuilder(
+				connectionStringBuilder.ToString());
+
+			ConfigureDataSourceBuilder(tempDataSourceBuilder);
+
+			var tempDataSource = tempDataSourceBuilder.Build();
+			return tempDataSource.CreateConnection();
+		}
+
+		private void ConfigureDataSourceBuilder(NpgsqlDataSourceBuilder builder)
+		{
+			if (_loggerFactory != null)
+			{
+				builder.UseLoggerFactory(_loggerFactory);
+			}
+
+			_configureDataSource?.Invoke(builder);
+		}
+
+		public async ValueTask DisposeAsync()
+		{
+			await _baseDataSource.DisposeAsync();
+		}
+	}
+}

Core/Sql/SqlOperations.cs

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