Adds support for Using EntityTypeConfiguration files.

samples/efcpt-config.schema.json

@@ -217,6 +217,11 @@
           "type": "boolean",
           "title": "Customize code using T4 templates"
         },
+        "use-t4-split": {
+          "type": "boolean",
+          "default": false,
+          "title": "Customize code using T4 templates including EntityTypeConfiguration.t4.  This cannot be used in combination with use-t4 or split-dbcontext-preview"
+      },
         "remove-defaultsql-from-bool-properties": {
           "type": "boolean",
           "title": "Remove SQL default from bool columns to avoid them being bool?"

samples/efcpt-schema.json

@@ -377,6 +377,14 @@
                         false
                     ]
                 },
+                "use-t4-split": {
+                    "type": "boolean",
+                    "default": false,
+                    "title": "Customize code using T4 templates including EntityTypeConfiguration.t4.  This cannot be used in combination with use-t4 or split-dbcontext-preview",
+                    "examples": [
+                        false
+                    ]
+                },
                 "t4-template-path": {
                     "type": [ "string", "null" ] ,
                     "default": null,

src/Core/RevEng.Core.60/IReverseEngineerScaffolder.cs

@@ -6,7 +6,7 @@ namespace RevEng.Core
 {
     public interface IReverseEngineerScaffolder
     {
-        SavedModelFiles GenerateDbContext(ReverseEngineerCommandOptions options, List<string> schemas, string outputContextDir, string modelNamespace, string contextNamespace, string projectPath, string outputPath);
+        SavedModelFiles GenerateDbContext(ReverseEngineerCommandOptions options, List<string> schemas, string outputContextDir, string modelNamespace, string contextNamespace, string projectPath, string outputPath, string rootNameSpace);
         SavedModelFiles GenerateFunctions(ReverseEngineerCommandOptions options, List<string> schemas, ref List<string> errors, string outputContextDir, string modelNamespace, string contextNamespace, bool supportsFunctions);
         SavedModelFiles GenerateStoredProcedures(ReverseEngineerCommandOptions options, List<string> schemas, ref List<string> errors, string outputContextDir, string modelNamespace, string contextNamespace, bool supportsProcedures);
     }

src/Core/RevEng.Core.60/ReverseEngineerRunner.cs

@@ -83,14 +83,14 @@ public static ReverseEngineerResult GenerateFiles(ReverseEngineerCommandOptions
 
             try
             {
-                SavedModelFiles filePaths = scaffolder!.GenerateDbContext(options, schemas, outputContextDir, modelNamespace, contextNamespace, options.ProjectPath, options.OutputPath);
+                SavedModelFiles filePaths = scaffolder!.GenerateDbContext(options, schemas, outputContextDir, modelNamespace, contextNamespace, options.ProjectPath, options.OutputPath, options.ProjectRootNamespace);
 
 #if CORE70 || CORE80
-                if (options.UseT4)
+                if (options.UseT4 || options.UseT4Split)
                 {
                     foreach (var paths in GetAlternateCodeTemplatePaths(options.ProjectPath))
                     {
-                        scaffolder!.GenerateDbContext(options, schemas, paths.Path, modelNamespace, contextNamespace, paths.Path, paths.OutputPath);
+                        scaffolder!.GenerateDbContext(options, schemas, paths.Path, modelNamespace, contextNamespace, paths.Path, paths.OutputPath, options.ProjectRootNamespace);
                     }
                 }
 #endif
@@ -139,20 +139,25 @@ public static ReverseEngineerResult GenerateFiles(ReverseEngineerCommandOptions
                     }
 
                     RemoveFragments(filePaths.ContextFile, options.ContextClassName, options.IncludeConnectionString, options.UseNoDefaultConstructor);
-                    if (!options.UseHandleBars && !options.UseT4)
+                    if (!options.UseHandleBars && !options.UseT4 && !options.UseT4Split)
                     {
                         PostProcess(filePaths.ContextFile, options.UseNullableReferences);
                     }
 
                     entityTypeConfigurationPaths = SplitDbContext(filePaths.ContextFile, options.UseDbContextSplitting, contextNamespace, options.UseNullableReferences, options.ContextClassName);
+
+                    if (options.UseT4Split)
+                    {
+                        entityTypeConfigurationPaths.AddRange(MoveConfigurationFiles(filePaths.AdditionalFiles));
+                    }
                 }
                 else if (options.Tables.Exists(t => t.ObjectType == ObjectType.Procedure)
                     || options.Tables.Exists(t => t.ObjectType == ObjectType.ScalarFunction))
                 {
                     warnings.Add("Selected stored procedures/scalar functions will not be generated, as 'Entity Types only' was selected");
                 }
 
-                if (!options.UseHandleBars && !options.UseT4)
+                if (!options.UseHandleBars && !options.UseT4 && !options.UseT4Split)
                 {
                     foreach (var file in filePaths.AdditionalFiles)
                     {
@@ -193,6 +198,18 @@ public static ReverseEngineerResult GenerateFiles(ReverseEngineerCommandOptions
                     warnings.Add($"'use-database-names' / 'UseDatabaseNames' has been set to true, but a '{Constants.RenamingFileName}' file was also found. This prevents '{Constants.RenamingFileName}' from functioning.");
                 }
 
+                if (options.UseT4 && options.UseT4Split)
+                {
+                    warnings.Add("Both UseT4 and UseT4Split are set to true.  Only one of thse should be used, UseT4Split will be ignored.");
+                    options.UseT4Split = false;
+                }
+
+                if (options.UseT4Split && options.UseDbContextSplitting)
+                {
+                    warnings.Add("Both UseDbContextSplitting and UseT4Split are set to true.  Only one of thse should be used, UseT4Split will be ignored.");
+                    options.UseT4Split = false;
+                }
+
                 var result = new ReverseEngineerResult
                 {
                     EntityErrors = errors,
@@ -323,6 +340,22 @@ private static List<string> SplitDbContext(string contextFile, bool useDbContext
             return DbContextSplitter.Split(contextFile, contextNamespace, supportNullable, dbContextName);
         }
 
+        // If we didn't split, we might have used EntityTypeConfiguration.t4.  In that case, <ModelName>Configuration.cs files were generated.
+        private static List<string> MoveConfigurationFiles(IList<string> files)
+        {
+            var configurationFiles = files.Where(x => x.EndsWith("Configuration.cs", StringComparison.InvariantCulture)).ToList();
+
+            var movedFiles = new List<string>();
+            foreach (var configurationFile in configurationFiles)
+            {
+                var newFileName = Path.Combine(Path.GetDirectoryName(configurationFile) ?? string.Empty, "Configurations", Path.GetFileName(configurationFile));
+                File.Move(configurationFile, newFileName, overwrite: true);
+                movedFiles.Add(newFileName);
+            }
+
+            return movedFiles;
+        }
+
         private static void RemoveFragments(string contextFile, string contextName, bool includeConnectionString, bool removeDefaultConstructor)
         {
             if (string.IsNullOrEmpty(contextFile))

src/Core/RevEng.Core.60/ReverseEngineerScaffolder.cs

@@ -59,7 +59,8 @@ public SavedModelFiles GenerateDbContext(
             string modelNamespace,
             string contextNamespace,
             string projectPath,
-            string outputPath)
+            string outputPath,
+            string rootNameSpace)
         {
             ArgumentNullException.ThrowIfNull(options);
 
@@ -77,15 +78,15 @@ public SavedModelFiles GenerateDbContext(
 
                 ContextName = code.Identifier(options.ContextClassName),
                 ContextDir = outputContextDir,
-                RootNamespace = null,
+                RootNamespace = rootNameSpace,
                 ContextNamespace = contextNamespace,
                 ModelNamespace = modelNamespace,
                 SuppressConnectionStringWarning = false,
                 ConnectionString = options.ConnectionString,
                 SuppressOnConfiguring = !options.IncludeConnectionString,
                 UseNullableReferenceTypes = options.UseNullableReferences,
 #if CORE70 || CORE80
-                ProjectDir = options.UseT4 ? (options.T4TemplatePath ?? projectPath) : null,
+                ProjectDir = (options.UseT4 || options.UseT4Split) ? (options.T4TemplatePath ?? projectPath) : null,
 #endif
             };
 

src/Core/efcpt.8/HostedServices/ScaffoldHostedService.cs

@@ -74,9 +74,9 @@ protected override async Task ExecuteAsync(CancellationToken stoppingToken)
 
 #pragma warning disable S2589 // Boolean expressions should not be gratuitous
 #pragma warning disable S2583 // Conditionally executed code should be reachable
-        if (commandOptions.UseT4 && Constants.Version > 6)
+        if ((commandOptions.UseT4 || commandOptions.UseT4Split) && Constants.Version > 6)
         {
-            var t4Result = T4Helper.DropT4Templates(commandOptions.T4TemplatePath ?? commandOptions.ProjectPath, Constants.CodeGeneration);
+            var t4Result = T4Helper.DropT4Templates(commandOptions.T4TemplatePath ?? commandOptions.ProjectPath, Constants.CodeGeneration, commandOptions.UseT4Split);
             if (!string.IsNullOrEmpty(t4Result))
             {
                 DisplayService.MarkupLine(t4Result, Color.Default);

src/Core/efcpt.8/efcpt.8.csproj

@@ -34,6 +34,9 @@
     <Content Include="..\..\GUI\lib\T4_800.zip" Link="T4_800.zip">
       <CopyToOutputDirectory>Always</CopyToOutputDirectory>
     </Content>
+    <Content Include="..\..\GUI\lib\T4_800_Split.zip" Link="T4_800_Split.zip">
+      <CopyToOutputDirectory>Always</CopyToOutputDirectory>
+    </Content>
     <Content Include="efcpt-readme.md">
       <CopyToOutputDirectory>Always</CopyToOutputDirectory>
     </Content>

src/GUI/RevEng.Shared/Cli/CliConfigMapper.cs

@@ -72,6 +72,7 @@ public static ReverseEngineerCommandOptions ToCommandOptions(
                 UseInflector = config.CodeGeneration.UseInflector,
                 UseT4 = config.CodeGeneration.UseT4,
                 T4TemplatePath = config.CodeGeneration.T4TemplatePath != null ? PathHelper.GetAbsPath(config.CodeGeneration.T4TemplatePath, projectPath) : null,
+                UseT4Split = config.CodeGeneration.UseT4Split,
                 IncludeConnectionString = !isDacpac && config.CodeGeneration.EnableOnConfiguring,
                 SelectedToBeGenerated = selectedToBeGenerated,
                 Dacpac = isDacpac ? connectionString : null,

src/GUI/RevEng.Shared/Cli/Configuration/CodeGeneration.cs

@@ -85,5 +85,9 @@ public class CodeGeneration
         [JsonPropertyOrder(200)]
         [JsonPropertyName("use-t4")]
         public bool UseT4 { get; set; }
+
+        [JsonPropertyOrder(210)]
+        [JsonPropertyName("use-t4-split")]
+        public bool UseT4Split { get; set; }
     }
 }

src/GUI/RevEng.Shared/Cli/T4Helper.cs

@@ -8,7 +8,7 @@ namespace RevEng.Common.Cli
 {
     public static class T4Helper
     {
-        public static string DropT4Templates(string projectPath, CodeGenerationMode codeGenerationMode)
+        public static string DropT4Templates(string projectPath, CodeGenerationMode codeGenerationMode, bool useEntityTypeSplitting = false)
         {
             string t4Version = "703";
 
@@ -22,6 +22,11 @@ public static string DropT4Templates(string projectPath, CodeGenerationMode code
                 t4Version = "900";
             }
 
+            if (useEntityTypeSplitting)
+            {
+                t4Version += "_Split";
+            }
+
             var zipName = $"T4_{t4Version}.zip";
 
             var toDir = Path.Combine(projectPath, "CodeTemplates");
@@ -57,6 +62,16 @@ public static string DropT4Templates(string projectPath, CodeGenerationMode code
                         return error;
                     }
                 }
+
+                target = Path.Combine(toDir, "EFCore", "EntityTypeConfiguration.t4");
+                if (File.Exists(target))
+                {
+                    var content = File.ReadAllText(target, Encoding.UTF8);
+                    if (content.IndexOf(check, StringComparison.OrdinalIgnoreCase) == -1)
+                    {
+                        return error;
+                    }
+                }
             }
 
             return string.Empty;

src/GUI/RevEng.Shared/ReverseEngineerCommandOptions.cs

@@ -31,6 +31,7 @@ public class ReverseEngineerCommandOptions
         public bool UseHandleBars { get; set; }
         public bool UseT4 { get; set; }
         public string T4TemplatePath { get; set; }
+        public bool UseT4Split { get; set; }
         public int SelectedHandlebarsLanguage { get; set; }
         public bool IncludeConnectionString { get; set; }
         public int SelectedToBeGenerated { get; set; }

src/GUI/RevEng.Shared/ReverseEngineerOptions.cs

@@ -29,6 +29,7 @@ public class ReverseEngineerOptions
         public List<string> UncountableWords { get; set; }
         public bool UseHandleBars { get; set; }
         public bool UseT4 { get; set; }
+        public bool UseT4Split { get; set; }
         public int SelectedHandlebarsLanguage { get; set; } = 2;
         public bool IncludeConnectionString { get; set; }
         public int SelectedToBeGenerated { get; set; }

src/GUI/Shared/Handlers/ReverseEngineer/EfRevEngLauncher.cs

@@ -95,6 +95,7 @@ public static async Task<ReverseEngineerResult> LaunchExternalRunnerAsync(Revers
                 UseHandleBars = options.UseHandleBars,
                 UseT4 = options.UseT4,
                 T4TemplatePath = options.T4TemplatePath != null ? PathHelper.GetAbsPath(options.T4TemplatePath, options.ProjectPath) : null,
+                UseT4Split = options.UseT4Split,
                 UseInflector = options.UseInflector,
                 UseLegacyPluralizer = options.UseLegacyPluralizer,
                 UncountableWords = options.UncountableWords,