Pass db connection to the command builder

Author: mgrosperrin

samples/SimpleApp/SimpleApp.csproj

@@ -3,7 +3,7 @@
     <PropertyGroup>
         <TargetFramework />
         <OutputType>Exe</OutputType>
-        <TargetFrameworks>netcoreapp2.0;net471</TargetFrameworks>
+        <TargetFrameworks>netcoreapp3.1;net471</TargetFrameworks>
         <LangVersion>latest</LangVersion>
         <GeneratePackageOnBuild>false</GeneratePackageOnBuild>
         <DocumentationFile />

src/MGR.CommandLineParser.Command.OracleProcedure/CommandObjectBuilder.cs

@@ -1,20 +1,42 @@
 using System;
 using System.Collections.Generic;
-using System.Text;
+using System.Data.Common;
 using MGR.CommandLineParser.Extensibility.Command;
 
 namespace MGR.CommandLineParser.Command.OracleProcedure
 {
-    class CommandObjectBuilder : ICommandObjectBuilder
+    internal class CommandObjectBuilder : ICommandObjectBuilder
     {
-        public CommandObjectBuilder(IEnumerable<CommandOption> options, )
-        {
+        private IEnumerable<ICommandOptionMetadata> _options;
+        private IEnumerable<Parameter> _outParameters;
+        private DbConnection _dbConnection;
 
+        public CommandObjectBuilder(IEnumerable<ICommandOptionMetadata> options, IEnumerable<Parameter> outParameters, DbConnection dbConnection)
+        {
+            _options = options;
+            _outParameters = outParameters;
+            _dbConnection = dbConnection;
         }
+
         public void AddArguments(string argument) => throw new NotImplementedException("Oracle procedures does not define unamed arguments");
-        public ICommandOption FindOption(string optionName) => throw new NotImplementedException();
-        public ICommandOption FindOptionByShortName(string optionShortName) => throw new NotImplementedException("Oracle procedures does not define 'short name' for the parameters");
-        public ICommandObject GenerateCommandObject() => throw new NotImplementedException();
-        public CommandValidationResult Validate(IServiceProvider serviceProvider) => throw new NotImplementedException();
+        public ICommandOption FindOption(string optionName)
+        {
+            throw new NotImplementedException();
+        }
+
+        public ICommandOption FindOptionByShortName(string optionShortName)
+        {
+            throw new NotImplementedException($"Oracle procedures does not define 'short name' for the parameters ('{ optionShortName }')");
+        }
+
+        public ICommandObject GenerateCommandObject()
+        {
+            throw new NotImplementedException();
+        }
+
+        public CommandValidationResult Validate(IServiceProvider serviceProvider)
+        {
+            throw new NotImplementedException();
+        }
     }
 }

src/MGR.CommandLineParser.Command.OracleProcedure/CommandType.cs

@@ -1,23 +1,29 @@
 using System;
 using System.Collections.Generic;
+using System.Data.Common;
 using MGR.CommandLineParser.Extensibility.Command;
 
 namespace MGR.CommandLineParser.Command.OracleProcedure
 {
     internal class CommandType : ICommandType
     {
         private readonly IEnumerable<Parameter> _outParameters;
+        private readonly DbConnection _dbConnection;
 
-        public CommandType(CommandMetadata commandMetadata, IEnumerable<CommandOptionMetadata> options, IEnumerable<Parameter> outParameters)
+        public CommandType(CommandMetadata commandMetadata, IEnumerable<CommandOptionMetadata> options, IEnumerable<Parameter> outParameters, DbConnection dbConnection)
         {
             Metadata = commandMetadata;
             Options = options;
             _outParameters = outParameters;
+            _dbConnection = dbConnection;
         }
         public ICommandMetadata Metadata { get; }
 
         public IEnumerable<ICommandOptionMetadata> Options { get; }
 
-        public ICommandObjectBuilder CreateCommandObjectBuilder(IServiceProvider serviceProvider) => throw new NotImplementedException();
+        public ICommandObjectBuilder CreateCommandObjectBuilder(IServiceProvider serviceProvider)
+        {
+            return new CommandObjectBuilder(Options, _outParameters, _dbConnection);
+        }
     }
 }

src/MGR.CommandLineParser.Command.OracleProcedure/CommandTypeProvider.cs

@@ -1,4 +1,5 @@
 using System.Collections.Generic;
+using System.Data.Common;
 using System.Linq;
 using System.Threading.Tasks;
 using MGR.CommandLineParser.Extensibility.Command;
@@ -16,24 +17,35 @@ public CommandTypeProvider(OracleSystemContext dbContext)
         }
         public async Task<IEnumerable<ICommandType>> GetAllCommandTypes()
         {
-            var procedures = _dbContext.Procedures.Include(procedure => procedure.Parameters).ToListAsync();
-            return procedures.Select(MapProcedureToCommandType);
+            var procedures = await _dbContext.Procedures.Include(procedure => procedure.Parameters).ToListAsync();
+            return procedures.Select(procedure => MapProcedureToCommandType(procedure, _dbContext.Database.GetDbConnection()));
         }
-        public ICommandType GetCommandType(string commandName)
+        public async Task<ICommandType> GetCommandType(string commandName)
         {
-            var procedure = _dbContext.Procedures.Include(procedure => procedure.Parameters).Where(procedure => procedure.Name == commandName).SingleOrDefault();
+            var procedure = await _dbContext.Procedures.Include(procedure => procedure.Parameters).Where(procedure => procedure.Name == commandName).SingleOrDefaultAsync();
             if (procedure != null)
             {
-                return MapProcedureToCommandType(procedure);
+                return MapProcedureToCommandType(procedure, _dbContext.Database.GetDbConnection());
             }
             return null;
         }
 
-        private static CommandType MapProcedureToCommandType(Procedure procedure) => new CommandType(new CommandMetadata(procedure.Name),
-                procedure.Parameters.Where(parameter => parameter.Direction.HasFlag(Direction.In)).Select(parameter => new CommandOptionMetadata(
-                    new OptionDisplayInfo(parameter.Name),
-                    !parameter.HasDefaultValue,
-                    parameter.DefaultValue)),
-                procedure.Parameters.Where(parameter => parameter.Direction.HasFlag(Direction.Out));
+        private static CommandType MapProcedureToCommandType(Procedure procedure, DbConnection dbConnection)
+        {
+            return new CommandType(
+                new CommandMetadata(procedure.Name),
+                procedure.Parameters
+                    .Where(parameter => parameter.Direction.HasFlag(Direction.In))
+                    .Select(parameter => new CommandOptionMetadata(
+                                new OptionDisplayInfo(parameter.Name),
+                                !parameter.HasDefaultValue,
+                                parameter.DefaultValue
+                                )
+                    ),
+                procedure.Parameters
+                    .Where(parameter => parameter.Direction.HasFlag(Direction.Out)),
+                dbConnection
+                );
+        }
     }
 }

src/MGR.CommandLineParser.Command.OracleProcedure/OracleSystemContext.cs

@@ -7,9 +7,14 @@ internal sealed class OracleSystemContext : DbContext
     {
         public DbSet<Procedure> Procedures { get; set; }
 
+        public OracleSystemContext(DbContextOptions<OracleSystemContext> options)
+            : base(options)
+        { }
+
         protected override void OnModelCreating(ModelBuilder modelBuilder)
         {
-            modelBuilder.ApplyConfiguration(new ProcedureMap())
+            modelBuilder
+                .ApplyConfiguration(new ProcedureMap())
                 .ApplyConfiguration(new ParameterMap());
             base.OnModelCreating(modelBuilder);
         }