Merge pull request #187 from AntonioFalcao/feature/code-smell

AntonioFalcaoJr · web-flow · commit 698006922ab2 · 2021-04-10T10:41:17.000-03:00
Evolving DbContext dependency injection, adding sql serve execution s…
diff --git a/src/Dotnet6.GraphQL4.Repositories.Abstractions/DependencyInjection/Extensions/ServiceCollectionExtensions.cs b/src/Dotnet6.GraphQL4.Repositories.Abstractions/DependencyInjection/Extensions/ServiceCollectionExtensions.cs
@@ -1,5 +1,6 @@
 ﻿using System.Transactions;
 using Dotnet6.GraphQL4.CrossCutting;
+using Dotnet6.GraphQL4.Repositories.Abstractions.DependencyInjection.Options;
 using Dotnet6.GraphQL4.Repositories.Abstractions.UnitsOfWork;
 using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.DependencyInjection;
diff --git a/src/Dotnet6.GraphQL4.Repositories.Abstractions/DependencyInjection/Options/ApplicationTransactionOptions.cs b/src/Dotnet6.GraphQL4.Repositories.Abstractions/DependencyInjection/Options/ApplicationTransactionOptions.cs
@@ -1,6 +1,6 @@
 ﻿using System.Transactions;
 
-namespace Dotnet6.GraphQL4.Repositories.Abstractions.DependencyInjection
+namespace Dotnet6.GraphQL4.Repositories.Abstractions.DependencyInjection.Options
 {
     public class ApplicationTransactionOptions
     {
diff --git a/src/Dotnet6.GraphQL4.Repositories.Abstractions/Transactions/Extensions/TransactionScopeExecuterExtensions.cs b/src/Dotnet6.GraphQL4.Repositories.Abstractions/Transactions/Extensions/TransactionScopeExecuterExtensions.cs
diff --git a/src/Dotnet6.GraphQL4.Repositories.Abstractions/Transactions/Extensions/TransactionScopeExecutorExtensions.cs b/src/Dotnet6.GraphQL4.Repositories.Abstractions/Transactions/Extensions/TransactionScopeExecutorExtensions.cs
@@ -0,0 +1,15 @@
+﻿using System;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace Dotnet6.GraphQL4.Repositories.Abstractions.Transactions.Extensions
+{
+    public static class TransactionScopeExecutorExtensions
+    {
+        public static TransactionScopeExecutor<T> BeginTransactionScope<T>(this Func<T> operation)
+            => new(operation);
+
+        public static TransactionScopeExecutor<T> BeginTransactionScope<T>(this Func<CancellationToken, Task<T>> operationAsync)
+            => new(operationAsync);
+    }
+}
diff --git a/src/Dotnet6.GraphQL4.Repositories.Abstractions/UnitsOfWork/UnitOfWork.cs b/src/Dotnet6.GraphQL4.Repositories.Abstractions/UnitsOfWork/UnitOfWork.cs
@@ -3,7 +3,7 @@
 using System.Threading.Tasks;
 using System.Transactions;
 using Dotnet6.GraphQL4.CrossCutting.Notifications;
-using Dotnet6.GraphQL4.Repositories.Abstractions.DependencyInjection;
+using Dotnet6.GraphQL4.Repositories.Abstractions.DependencyInjection.Options;
 using Dotnet6.GraphQL4.Repositories.Abstractions.Transactions.Extensions;
 using Microsoft.EntityFrameworkCore;
 using Microsoft.EntityFrameworkCore.Infrastructure;
@@ -16,13 +16,16 @@ public class UnitOfWork : IUnitOfWork
     {
         private readonly DatabaseFacade _database;
         private readonly DbContext _dbContext;
-        private readonly IOptionsMonitor<ApplicationTransactionOptions> _options;
+        private readonly ApplicationTransactionOptions _options;
         private readonly INotificationContext _notificationContext;
 
-        public UnitOfWork(DbContext dbContext, IOptionsMonitor<ApplicationTransactionOptions> options, INotificationContext notificationContext)
+        public UnitOfWork(
+            DbContext dbContext, 
+            IOptionsMonitor<ApplicationTransactionOptions> optionsMonitor, 
+            INotificationContext notificationContext)
         {
             _dbContext = dbContext;
-            _options = options;
+            _options = optionsMonitor.CurrentValue;
             _database = _dbContext.Database;
             _notificationContext = notificationContext;
         }
@@ -35,18 +38,18 @@ public Task<TResult> ExecuteInTransactionAsync<TResult>(Func<CancellationToken,
 
         private Task<TResult> ExecuteWithScopeAsync<TResult>(Func<CancellationToken, Task<TResult>> operationAsync, Func<CancellationToken, Task<bool>> condition, CancellationToken cancellationToken)
             => operationAsync
-                .TransactionAsync()
+                .BeginTransactionScope()
                 .WithScopeOption(TransactionScopeOption.Required)
-                .WithOptions(options => options.IsolationLevel = _options.CurrentValue.IsolationLevel)
+                .WithOptions(options => options.IsolationLevel = _options.IsolationLevel)
                 .WithScopeAsyncFlowOption(TransactionScopeAsyncFlowOption.Enabled)
                 .WithConditionAsync(condition ?? (_ => _notificationContext.AllValidAsync))
                 .ExecuteAsync(cancellationToken);
 
         private TResult ExecuteWithScope<TResult>(Func<TResult> operation, Func<bool> condition)
             => operation
-                .Transaction()
+                .BeginTransactionScope()
                 .WithScopeOption(TransactionScopeOption.Required)
-                .WithOptions(options => options.IsolationLevel = _options.CurrentValue.IsolationLevel)
+                .WithOptions(options => options.IsolationLevel = _options.IsolationLevel)
                 .WithScopeAsyncFlowOption(TransactionScopeAsyncFlowOption.Enabled)
                 .WithCondition(condition ?? (() => _notificationContext.AllValid))
                 .Execute();
@@ -55,9 +58,9 @@ private IExecutionStrategy CreateExecutionStrategy()
             => _database.CreateExecutionStrategy();
 
         public bool SaveChanges()
-            => _dbContext.SaveChanges(true) > default(int);
+            => _dbContext.SaveChanges(false) > default(int);
 
         public async Task<bool> SaveChangesAsync(CancellationToken cancellationToken)
-            => await _dbContext.SaveChangesAsync(true, cancellationToken) > default(int);
+            => await _dbContext.SaveChangesAsync(false, cancellationToken) > default(int);
     }
 }
diff --git a/src/Dotnet6.GraphQL4.Store.Repositories/Contexts/StoreDbContext.cs b/src/Dotnet6.GraphQL4.Store.Repositories/Contexts/StoreDbContext.cs
@@ -1,16 +1,33 @@
 using Dotnet6.GraphQL4.Store.Domain.Entities.Products;
 using Dotnet6.GraphQL4.Store.Domain.Entities.Reviews;
 using Dotnet6.GraphQL4.Store.Domain.ValueObjects.ProductTypes;
+using Dotnet6.GraphQL4.Store.Repositories.DependencyInjection.Options;
 using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.Logging;
+using Microsoft.Extensions.Options;
 
 namespace Dotnet6.GraphQL4.Store.Repositories.Contexts
 {
     public class StoreDbContext : DbContext
     {
         private const string SqlLatin1GeneralCp1CsAs = "SQL_Latin1_General_CP1_CS_AS";
+        private readonly IConfiguration _configuration;
+        private readonly ILoggerFactory _loggerFactory;
+        private readonly SqlServerRetryingOptions _options;
 
-        public StoreDbContext(DbContextOptions options)
-            : base(options) { }
+        public StoreDbContext(
+            DbContextOptions options, 
+            ILoggerFactory loggerFactory, 
+            IConfiguration configuration,
+            IOptionsMonitor<SqlServerRetryingOptions> optionsMonitor)
+            : base(options)
+        {
+            _loggerFactory = loggerFactory;
+            _configuration = configuration;
+            _options = optionsMonitor.CurrentValue;
+        }
 
         public DbSet<Product> Products { get; set; }
         public DbSet<ProductType> ProductTypes { get; set; }
@@ -23,5 +40,27 @@ protected override void OnModelCreating(ModelBuilder modelBuilder)
             modelBuilder.Seed();
             base.OnModelCreating(modelBuilder);
         }
+
+        protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
+        {
+            if (optionsBuilder.IsConfigured) return;
+
+            optionsBuilder.EnableDetailedErrors()
+                .EnableSensitiveDataLogging()
+                .UseSqlServer(
+                    connectionString:_configuration.GetConnectionString("DefaultConnection"), 
+                    sqlServerOptionsAction: SqlServerOptionsAction)
+                .UseLoggerFactory(_loggerFactory);
+        }
+
+        private void SqlServerOptionsAction(SqlServerDbContextOptionsBuilder optionsBuilder)
+            => optionsBuilder
+                .ExecutionStrategy(
+                    dependencies => new SqlServerRetryingExecutionStrategy(
+                        dependencies: dependencies,
+                        maxRetryCount: _options.MaxRetryCount,
+                        maxRetryDelay: _options.MaxRetryDelay,
+                        errorNumbersToAdd: _options.ErrorNumbersToAdd))
+                .MigrationsAssembly(assemblyName: typeof(StoreDbContext).Assembly.GetName().Name);
     }
 }
diff --git a/src/Dotnet6.GraphQL4.Store.Repositories/DependencyInjection/Extensions/ServiceCollectionExtensions.cs b/src/Dotnet6.GraphQL4.Store.Repositories/DependencyInjection/Extensions/ServiceCollectionExtensions.cs
@@ -0,0 +1,25 @@
+using Dotnet6.GraphQL4.Store.Repositories.Contexts;
+using Dotnet6.GraphQL4.Store.Repositories.DependencyInjection.Options;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Options;
+
+namespace Dotnet6.GraphQL4.Store.Repositories.DependencyInjection.Extensions
+{
+    public static class ServiceCollectionExtensions
+    {
+        public static IServiceCollection AddApplicationDbContext(this IServiceCollection services)
+            => services
+                .AddScoped<DbContext, StoreDbContext>()
+                .AddDbContext<StoreDbContext>();
+
+        public static OptionsBuilder<SqlServerRetryingOptions> ConfigureSqlServerRetryingOptions(this IServiceCollection services, IConfigurationSection section)
+            => services
+                .AddOptions<SqlServerRetryingOptions>()
+                .Bind(section)
+                .Validate(
+                    validation: options => options.MaxRetryCount <= 10 || options.MaxSecondsRetryDelay <= 10, 
+                    failureMessage: "Max value for Retry or Delay must be 10.");
+    }
+}
diff --git a/src/Dotnet6.GraphQL4.Store.Repositories/DependencyInjection/Options/SqlServerRetryingOptions.cs b/src/Dotnet6.GraphQL4.Store.Repositories/DependencyInjection/Options/SqlServerRetryingOptions.cs
@@ -0,0 +1,30 @@
+﻿using System;
+
+namespace Dotnet6.GraphQL4.Store.Repositories.DependencyInjection.Options
+{
+    public class SqlServerRetryingOptions
+    {
+        private const int DefaultRetryCount = 5;
+        private const int DefaultRetryDelay = 5;
+
+        private int _maxRetryCount;
+        private int _maxSecondsRetryDelay;
+
+        public int MaxRetryCount
+        {
+            get => _maxRetryCount <= 0 ? DefaultRetryCount : _maxRetryCount;
+            set => _maxRetryCount = value;
+        }
+
+        public int MaxSecondsRetryDelay
+        {
+            get => _maxSecondsRetryDelay <= 0 ? DefaultRetryDelay : _maxSecondsRetryDelay;
+            set => _maxSecondsRetryDelay = value;
+        }
+
+        public int[] ErrorNumbersToAdd { get; set; }
+        
+        internal TimeSpan MaxRetryDelay 
+            => TimeSpan.FromSeconds(MaxSecondsRetryDelay);
+    }
+}
diff --git a/src/Dotnet6.GraphQL4.Store.Repositories/Dotnet6.GraphQL4.Store.Repositories.csproj b/src/Dotnet6.GraphQL4.Store.Repositories/Dotnet6.GraphQL4.Store.Repositories.csproj
@@ -2,6 +2,7 @@
     
     <ItemGroup>
         <PackageReference Include="Bogus" Version="33.0.2" />
+        <PackageReference Include="EntityFramework" Version="$(Microsoft_EntityFrameworkCore_Version)" />
         <PackageReference Include="Microsoft.EntityFrameworkCore.Relational" Version="$(Microsoft_EntityFrameworkCore_Version)" />
         <PackageReference Include="Microsoft.EntityFrameworkCore.Design" Version="$(Microsoft_EntityFrameworkCore_Version)" />
         <PackageReference Include="Microsoft.EntityFrameworkCore.SqlServer" Version="$(Microsoft_EntityFrameworkCore_Version)" />
diff --git a/src/Dotnet6.GraphQL4.Store.Repositories/Extensions/DependencyInjection/ServiceCollectionExtensions.cs b/src/Dotnet6.GraphQL4.Store.Repositories/Extensions/DependencyInjection/ServiceCollectionExtensions.cs
diff --git a/src/Dotnet6.GraphQL4.Store.WebAPI/Program.cs b/src/Dotnet6.GraphQL4.Store.WebAPI/Program.cs
@@ -45,6 +45,8 @@ public static async Task Main(string[] args)
             
             Log.Logger = new LoggerConfiguration()
                 .ReadFrom.Configuration(configuration)
+                .Enrich.FromLogContext()
+                .WriteTo.Console()
                 .CreateLogger();
 
             try
diff --git a/src/Dotnet6.GraphQL4.Store.WebAPI/Startup.cs b/src/Dotnet6.GraphQL4.Store.WebAPI/Startup.cs
@@ -1,12 +1,12 @@
 using System.Linq;
 using Dotnet6.GraphQL4.Store.Repositories.Contexts;
-using Dotnet6.GraphQL4.Store.Repositories.Extensions.DependencyInjection;
 using Dotnet6.GraphQL4.Store.WebAPI.Extensions.EndpointRouteBuilders;
 using Dotnet6.GraphQL4.Store.WebAPI.Graphs.Extensions.DependencyInjection;
 using Dotnet6.GraphQL4.CrossCutting.Extensions.DependencyInjection;
 using Dotnet6.GraphQL4.Domain.Abstractions.Extensions.DependencyInjection;
 using Dotnet6.GraphQL4.Repositories.Abstractions.DependencyInjection.Extensions;
 using Dotnet6.GraphQL4.Services.Abstractions.Extensions.DependencyInjection;
+using Dotnet6.GraphQL4.Store.Repositories.DependencyInjection.Extensions;
 using Dotnet6.GraphQL4.Store.WebAPI.Graphs;
 using HealthChecks.UI.Client;
 using Microsoft.AspNetCore.Builder;
@@ -17,6 +17,7 @@
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Diagnostics.HealthChecks;
 using Microsoft.Extensions.Hosting;
+using Microsoft.Extensions.Logging;
 using Serilog;
 
 namespace Dotnet6.GraphQL4.Store.WebAPI
@@ -34,10 +35,12 @@ public Startup(IConfiguration configuration, IWebHostEnvironment env)
             _configuration = configuration;
         }
 
-        public void Configure(IApplicationBuilder app)
+        public void Configure(IApplicationBuilder app , ILoggerFactory loggerFactory)
         {
             if (_env.IsDevelopment())
                 app.UseDeveloperExceptionPage();
+
+            loggerFactory.AddSerilog();
             
             app.UseSerilogRequestLogging()
                 .UseApplicationGraphQL<StoreSchema>()
@@ -78,6 +81,7 @@ public void Configure(IApplicationBuilder app)
         public void ConfigureServices(IServiceCollection services)
         {
             services
+                .AddLogging()
                 .AddBuilders()
                 .AddRepositories()
                 .AddUnitOfWork()
@@ -89,13 +93,10 @@ public void ConfigureServices(IServiceCollection services)
                 .AddControllers();
 
             services.ConfigureTransactionOptions(_configuration.GetSection("Transactions"));
-            
-            services.AddApplicationDbContext(options =>
-                {
-                    options.DefaultConnection = _configuration.GetConnectionString(nameof(options.DefaultConnection));
-                    _configuration.Bind(nameof(options.ConnectionResiliency), options.ConnectionResiliency);
-                });
+            services.ConfigureSqlServerRetryingOptions(_configuration.GetSection("SqlServerRetryingOptions"));
 
+            services.AddApplicationDbContext();
+            
             services.AddApplicationGraphQL(options
                 => options.IsDevelopment = _env.IsDevelopment());
 
@@ -111,8 +112,8 @@ public void ConfigureServices(IServiceCollection services)
                     name: "Sql Server (Ready)",
                     failureStatus: HealthStatus.Unhealthy,
                     tags: _readinessTags,
-                    customTestQuery: async (dbContext, cancellationToken) 
-                        => await dbContext.Products.AnyAsync(cancellationToken));
+                    customTestQuery: (dbContext, cancellationToken) 
+                        => dbContext.Products.AnyAsync(cancellationToken));
         }
     }
 }
diff --git a/src/Dotnet6.GraphQL4.Store.WebAPI/appsettings.Development.json b/src/Dotnet6.GraphQL4.Store.WebAPI/appsettings.Development.json
diff --git a/src/Dotnet6.GraphQL4.Store.WebAPI/appsettings.json b/src/Dotnet6.GraphQL4.Store.WebAPI/appsettings.json

Original file line number	Diff line number	Diff line change
`@@ -1,6 +1,6 @@`
`1`	`1`	`using System.Transactions;`
`2`	`2`
`3`		`-namespace Dotnet6.GraphQL4.Repositories.Abstractions.DependencyInjection`
	`3`	`+namespace Dotnet6.GraphQL4.Repositories.Abstractions.DependencyInjection.Options`
`4`	`4`	`{`
`5`	`5`	`public class ApplicationTransactionOptions`
`6`	`6`	`{`