public ScaffoldedModel ScaffoldModel(string connectionString, ProcedureScaffolderOptions procedureScaffolderOptions)
{
var result = new ScaffoldedModel();
var model = procedureModelFactory.Create(connectionString);
foreach (var procedure in model.Procedures)
{
var name = GenerateIdentifierName(procedure.Name) + "Result";
var classContent = WriteResultClass(procedure, procedureScaffolderOptions.ModelNamespace, name);
result.AdditionalFiles.Add(new ScaffoldedFile
{
Code = classContent,
Path = $"{name}.cs",
});
}
var dbContext = WriteProcedureDbContext(procedureScaffolderOptions, model);
result.ContextFile = new ScaffoldedFile
{
Code = dbContext,
Path = Path.GetFullPath(Path.Combine(procedureScaffolderOptions.ContextDir, procedureScaffolderOptions.ContextName + "Procedures.cs")),
};
return(result);
}
public ScaffoldedModel ScaffoldModel(ProcedureModel model, ProcedureScaffolderOptions procedureScaffolderOptions, ref List <string> errors)
{
if (model == null)
{
throw new ArgumentNullException(nameof(model));
}
var result = new ScaffoldedModel();
errors = model.Errors;
foreach (var procedure in model.Procedures)
{
var name = GenerateIdentifierName(procedure, model) + "Result";
var classContent = WriteResultClass(procedure, procedureScaffolderOptions, name);
result.AdditionalFiles.Add(new ScaffoldedFile
{
Code = classContent,
Path = $"{name}.cs",
});
}
var dbContext = WriteProcedureDbContext(procedureScaffolderOptions, model);
result.ContextFile = new ScaffoldedFile
{
Code = dbContext,
Path = Path.GetFullPath(Path.Combine(procedureScaffolderOptions.ContextDir, procedureScaffolderOptions.ContextName + "Procedures.cs")),
};
return(result);
}
private string WriteResultClass(Procedure storedProcedure, ProcedureScaffolderOptions options, string name)
{
var @namespace = options.ModelNamespace;
_sb = new IndentedStringBuilder();
_sb.AppendLine(PathHelper.Header);
_sb.AppendLine("using System;");
_sb.AppendLine("using System.Collections.Generic;");
_sb.AppendLine("using System.ComponentModel.DataAnnotations.Schema;");
_sb.AppendLine();
if (options.NullableReferences)
{
_sb.AppendLine("#nullable enable");
_sb.AppendLine();
}
_sb.AppendLine($"namespace {@namespace}");
_sb.AppendLine("{");
using (_sb.Indent())
{
GenerateClass(storedProcedure, name, options.NullableReferences);
}
_sb.AppendLine("}");
return(_sb.ToString());
}
private string WriteProcedureDbContext(ProcedureScaffolderOptions procedureScaffolderOptions, ProcedureModel model)
{
_sb = new IndentedStringBuilder();
_sb.AppendLine(PathHelper.Header);
_sb.AppendLine("using Microsoft.EntityFrameworkCore;");
_sb.AppendLine("using Microsoft.Data.SqlClient;");
_sb.AppendLine("using System;");
_sb.AppendLine("using System.Data;");
_sb.AppendLine("using System.Threading;");
_sb.AppendLine("using System.Threading.Tasks;");
_sb.AppendLine($"using {procedureScaffolderOptions.ModelNamespace};");
_sb.AppendLine();
_sb.AppendLine($"namespace {procedureScaffolderOptions.ContextNamespace}");
_sb.AppendLine("{");
using (_sb.Indent())
{
_sb.AppendLine($"public partial class {procedureScaffolderOptions.ContextName}Procedures");
_sb.AppendLine("{");
using (_sb.Indent())
{
_sb.AppendLine($"private readonly {procedureScaffolderOptions.ContextName} _context;");
_sb.AppendLine();
_sb.AppendLine($"public {procedureScaffolderOptions.ContextName}Procedures({procedureScaffolderOptions.ContextName} context)");
_sb.AppendLine("{");
using (_sb.Indent())
{
_sb.AppendLine($"_context = context;");
}
_sb.AppendLine("}");
}
foreach (var procedure in model.Procedures)
{
GenerateProcedure(procedure, model);
}
_sb.AppendLine("}");
}
_sb.AppendLine("}");
return(_sb.ToString());
}
public ScaffoldedModel ScaffoldModel(string connectionString, ProcedureScaffolderOptions procedureScaffolderOptions)
{
var model = procedureModelFactory.Create(connectionString, new ProcedureModelFactoryOptions {
Procedures = procedureScaffolderOptions.Procedures
});
foreach (var procedure in model.Procedures)
{
}
//TODO Generate code and file names here!
return(null);
}
public ReverseEngineerResult GenerateFiles(ReverseEngineerCommandOptions reverseEngineerOptions)
{
var errors = new List<string>();
var warnings = new List<string>();
var reporter = new OperationReporter(
new OperationReportHandler(
m => errors.Add(m),
m => warnings.Add(m)));
var serviceProvider = ServiceProviderBuilder.Build(reverseEngineerOptions);
var scaffolder = serviceProvider.GetService<IReverseEngineerScaffolder>();
var schemas = new List<string>();
if (reverseEngineerOptions.DefaultDacpacSchema != null)
{
schemas.Add(reverseEngineerOptions.DefaultDacpacSchema);
}
if (reverseEngineerOptions.FilterSchemas)
{
schemas.AddRange(reverseEngineerOptions.Schemas.Select(s => s.Name));
}
var outputDir = !string.IsNullOrEmpty(reverseEngineerOptions.OutputPath)
? Path.IsPathFullyQualified(reverseEngineerOptions.OutputPath)
? reverseEngineerOptions.OutputPath
: Path.GetFullPath(Path.Combine(reverseEngineerOptions.ProjectPath, reverseEngineerOptions.OutputPath))
: reverseEngineerOptions.ProjectPath;
var outputContextDir = !string.IsNullOrEmpty(reverseEngineerOptions.OutputContextPath)
? Path.IsPathFullyQualified(reverseEngineerOptions.OutputContextPath)
? reverseEngineerOptions.OutputContextPath
: Path.GetFullPath(Path.Combine(reverseEngineerOptions.ProjectPath, reverseEngineerOptions.OutputContextPath))
: outputDir;
var modelNamespace = !string.IsNullOrEmpty(reverseEngineerOptions.ModelNamespace)
? reverseEngineerOptions.ProjectRootNamespace + "." + reverseEngineerOptions.ModelNamespace
: PathHelper.GetNamespaceFromOutputPath(outputDir, reverseEngineerOptions.ProjectPath, reverseEngineerOptions.ProjectRootNamespace);
var contextNamespace = !string.IsNullOrEmpty(reverseEngineerOptions.ContextNamespace)
? reverseEngineerOptions.ProjectRootNamespace + "." + reverseEngineerOptions.ContextNamespace
: PathHelper.GetNamespaceFromOutputPath(outputContextDir, reverseEngineerOptions.ProjectPath, reverseEngineerOptions.ProjectRootNamespace);
SavedModelFiles procedurePaths = null;
var procedureModelScaffolder = serviceProvider.GetService<IProcedureScaffolder>();
if (procedureModelScaffolder != null
&& reverseEngineerOptions.Tables.Where(t => t.ObjectType == RevEng.Shared.ObjectType.Procedure).Count() > 0)
{
var procedureOptions = new ProcedureScaffolderOptions
{
ContextDir = outputContextDir,
ContextName = reverseEngineerOptions.ContextClassName,
ContextNamespace = contextNamespace,
ModelNamespace = modelNamespace,
};
var procedureModelOptions = new ProcedureModelFactoryOptions
{
FullModel = true,
Procedures = reverseEngineerOptions.Tables.Where(t => t.ObjectType == RevEng.Shared.ObjectType.Procedure).Select(m => m.Name),
};
var procedureModel = procedureModelScaffolder.ScaffoldModel(reverseEngineerOptions.ConnectionString, procedureOptions, procedureModelOptions, ref errors);
if (procedureModel != null)
{
procedurePaths = procedureModelScaffolder.Save(
procedureModel,
Path.GetFullPath(Path.Combine(reverseEngineerOptions.ProjectPath, reverseEngineerOptions.OutputPath ?? string.Empty)),
contextNamespace);
}
}
var modelOptions = new ModelReverseEngineerOptions
{
UseDatabaseNames = reverseEngineerOptions.UseDatabaseNames,
#if CORE50
NoPluralize = !reverseEngineerOptions.UseInflector,
#endif
};
var codeOptions = new ModelCodeGenerationOptions
{
UseDataAnnotations = !reverseEngineerOptions.UseFluentApiOnly,
Language = "C#",
ContextName = reverseEngineerOptions.ContextClassName,
ContextDir = outputContextDir,
RootNamespace = null,
ContextNamespace = contextNamespace,
ModelNamespace = modelNamespace,
SuppressConnectionStringWarning = false,
ConnectionString = reverseEngineerOptions.ConnectionString,
#if CORE50
SuppressOnConfiguring = !reverseEngineerOptions.IncludeConnectionString,
#endif
};
var dbOptions = new DatabaseModelFactoryOptions(reverseEngineerOptions.Tables.Where(t => t.ObjectType.HasColumns()).Select(m => m.Name), schemas);
var scaffoldedModel = scaffolder.ScaffoldModel(
reverseEngineerOptions.Dacpac ?? reverseEngineerOptions.ConnectionString,
dbOptions,
modelOptions,
codeOptions);
var filePaths = scaffolder.Save(
scaffoldedModel,
Path.GetFullPath(Path.Combine(reverseEngineerOptions.ProjectPath, reverseEngineerOptions.OutputPath ?? string.Empty)),
overwriteFiles: true);
#if CORE50
#else
RemoveOnConfiguring(filePaths.ContextFile, reverseEngineerOptions.IncludeConnectionString);
#endif
foreach (var file in filePaths.AdditionalFiles)
{
PostProcess(file);
}
PostProcess(filePaths.ContextFile);
var entityTypeConfigurationPaths = SplitDbContext(filePaths.ContextFile, reverseEngineerOptions.UseDbContextSplitting, contextNamespace);
var cleanUpPaths = new SavedModelFiles(filePaths.ContextFile, filePaths.AdditionalFiles);
if (procedurePaths != null)
{
cleanUpPaths.AdditionalFiles.Add(procedurePaths.ContextFile);
foreach (var additionalFile in procedurePaths.AdditionalFiles)
{
cleanUpPaths.AdditionalFiles.Add(additionalFile);
}
}
CleanUp(cleanUpPaths, entityTypeConfigurationPaths);
var result = new ReverseEngineerResult
{
EntityErrors = errors,
EntityWarnings = warnings,
EntityTypeFilePaths = filePaths.AdditionalFiles,
ContextFilePath = filePaths.ContextFile,
ContextConfigurationFilePaths = entityTypeConfigurationPaths,
};
return result;
}
