private IReverseEngineerScaffolder CreateScaffolder(ReverseEngineerOptions options)
{
var fileService = new InMemoryTemplateFileService();
fileService.InputFiles(ContextClassTemplate, ContextImportsTemplate,
ContextCtorTemplate, ContextOnConfiguringTemplate, ContextDbSetsTemplate,
EntityClassTemplate, EntityImportsTemplate, EntityCtorTemplate, EntityPropertiesTemplate);
var services = new ServiceCollection()
.AddEntityFrameworkDesignTimeServices()
.AddSingleton <IDbContextTemplateService, FakeHbsDbContextTemplateService>()
.AddSingleton <IEntityTypeTemplateService, FakeHbsEntityTypeTemplateService>()
.AddSingleton <IEntityTypeTransformationService, HbsEntityTypeTransformationService>()
.AddSingleton <ITypeScriptHelper, TypeScriptHelper>()
.AddSingleton <ITemplateFileService>(fileService)
.AddSingleton <ITemplateLanguageService, FakeTypeScriptTemplateLanguageService>()
.AddSingleton <IModelCodeGenerator, HbsTypeScriptModelGenerator>()
.AddSingleton(provider =>
{
ICSharpDbContextGenerator contextGenerator = new HbsCSharpDbContextGenerator(
provider.GetRequiredService <IProviderConfigurationCodeGenerator>(),
provider.GetRequiredService <IAnnotationCodeGenerator>(),
provider.GetRequiredService <IDbContextTemplateService>(),
provider.GetRequiredService <IEntityTypeTransformationService>(),
provider.GetRequiredService <ICSharpHelper>(),
provider.GetRequiredService <IOptions <HandlebarsScaffoldingOptions> >());
return(options == ReverseEngineerOptions.DbContextOnly ||
options == ReverseEngineerOptions.DbContextAndEntities
? contextGenerator
: new NullCSharpDbContextGenerator());
})
.AddSingleton(provider =>
{
ICSharpEntityTypeGenerator entityGenerator = new HbsTypeScriptEntityTypeGenerator(
provider.GetRequiredService <IEntityTypeTemplateService>(),
provider.GetRequiredService <IEntityTypeTransformationService>(),
provider.GetRequiredService <ICSharpHelper>(),
provider.GetRequiredService <ITypeScriptHelper>(),
provider.GetRequiredService <IOptions <HandlebarsScaffoldingOptions> >());
return(options == ReverseEngineerOptions.EntitiesOnly ||
options == ReverseEngineerOptions.DbContextAndEntities
? entityGenerator
: new NullCSharpEntityTypeGenerator());
})
.AddSingleton <IHbsHelperService>(provider =>
new HbsHelperService(new Dictionary <string, Action <TextWriter, Dictionary <string, object>, object[]> >
{
{ EntityFrameworkCore.Scaffolding.Handlebars.Helpers.Constants.SpacesHelper, HandlebarsHelpers.SpacesHelper }
}))
.AddSingleton <IHbsBlockHelperService>(provider =>
new HbsBlockHelperService(new Dictionary <string, Action <TextWriter, HelperOptions, Dictionary <string, object>, object[]> >()))
.AddSingleton <IReverseEngineerScaffolder, HbsReverseEngineerScaffolder>();
new SqlServerDesignTimeServices().ConfigureDesignTimeServices(services);
var scaffolder = services
.BuildServiceProvider()
.GetRequiredService <IReverseEngineerScaffolder>();
return(scaffolder);
}
public void ValidateContextNameInReverseEngineerGenerator(string contextName)
{
var cSharpUtilities = new CSharpUtilities();
var fileService = new InMemoryTemplateFileService();
var dbContextTemplateService = new HbsDbContextTemplateService(fileService);
var entityTypeTemplateService = new HbsEntityTypeTemplateService(fileService);
var reverseEngineer = new ReverseEngineerScaffolder(
new FakeDatabaseModelFactory(),
new FakeScaffoldingModelFactory(new TestOperationReporter()),
new HbsCSharpScaffoldingGenerator(
fileService,
dbContextTemplateService,
entityTypeTemplateService,
new HbsCSharpDbContextGenerator(
new FakeScaffoldingProviderCodeGenerator(),
new FakeAnnotationCodeGenerator(),
cSharpUtilities,
new HbsDbContextTemplateService(fileService)),
new HbsCSharpEntityTypeGenerator(
cSharpUtilities,
new HbsEntityTypeTemplateService(fileService))),
cSharpUtilities);
Assert.Equal(
DesignStrings.ContextClassNotValidCSharpIdentifier(contextName),
Assert.Throws <ArgumentException>(
() => reverseEngineer.Generate(
connectionString: "connectionstring",
tables: Enumerable.Empty <string>(),
schemas: Enumerable.Empty <string>(),
projectPath: "FakeProjectPath",
outputPath: null,
rootNamespace: "FakeNamespace",
contextName: contextName,
useDataAnnotations: false,
overwriteFiles: false,
useDatabaseNames: false))
.Message);
}
private Dictionary <string, string> ReverseEngineerFiles(ReverseEngineerOptions options, bool useDataAnnotations)
{
var fileService = new InMemoryTemplateFileService();
fileService.InputFiles(ContextClassTemplate, ContextImportsTemplate, ContextDbSetsTemplate,
EntityClassTemplate, EntityImportsTemplate, EntityCtorTemplate, EntityPropertiesTemplate);
var dbContextTemplateService = new HbsDbContextTemplateService(fileService);
var entityTypeTemplateService = new HbsEntityTypeTemplateService(fileService);
ICSharpUtilities cSharpUtilities = new CSharpUtilities();
ICSharpDbContextGenerator realContextGenerator = new HbsCSharpDbContextGenerator(
new SqlServerScaffoldingCodeGenerator(),
new SqlServerAnnotationCodeGenerator(new AnnotationCodeGeneratorDependencies()),
cSharpUtilities,
new HbsDbContextTemplateService(fileService));
ICSharpDbContextGenerator contextGenerator =
options == ReverseEngineerOptions.DbContextOnly || options == ReverseEngineerOptions.DbContextOnly
? realContextGenerator
: new NullCSharpDbContextGenerator();
ICSharpEntityTypeGenerator realEntityGenerator = new HbsCSharpEntityTypeGenerator(
cSharpUtilities,
new HbsEntityTypeTemplateService(fileService));
ICSharpEntityTypeGenerator entityGenerator =
options == ReverseEngineerOptions.EntitiesOnly || options == ReverseEngineerOptions.DbContextAndEntities
? realEntityGenerator
: new NullCSharpEntityTypeGenerator();
IScaffoldingCodeGenerator scaffoldingGenerator = new HbsCSharpScaffoldingGenerator(
fileService, dbContextTemplateService, entityTypeTemplateService,
contextGenerator, entityGenerator);
var modelFactory = new SqlServerDatabaseModelFactory(
new DiagnosticsLogger <DbLoggerCategory.Scaffolding>(
new TestSqlLoggerFactory(),
new LoggingOptions(),
new DiagnosticListener("Fake")));
var reverseEngineer = new ReverseEngineerScaffolder(
modelFactory,
new FakeScaffoldingModelFactory(new TestOperationReporter()),
scaffoldingGenerator, cSharpUtilities);
// Act
var files = reverseEngineer.Generate(
connectionString: Constants.Connections.SqlServerConnection,
tables: Enumerable.Empty <string>(),
schemas: Enumerable.Empty <string>(),
projectPath: Constants.Parameters.ProjectPath,
outputPath: null,
rootNamespace: Constants.Parameters.RootNamespace,
contextName: Constants.Parameters.ContextName,
useDataAnnotations: useDataAnnotations,
overwriteFiles: false,
useDatabaseNames: false);
var generatedFiles = new Dictionary <string, string>();
if (options == ReverseEngineerOptions.DbContextOnly ||
options == ReverseEngineerOptions.DbContextAndEntities)
{
var contextPath = files.ContextFile;
var context = fileService.RetrieveTemplateFileContents(
Path.GetDirectoryName(contextPath), Path.GetFileName(contextPath));
generatedFiles.Add(Constants.Files.DbContextFile, context);
}
if (options == ReverseEngineerOptions.EntitiesOnly ||
options == ReverseEngineerOptions.DbContextAndEntities)
{
var categoryPath = files.EntityTypeFiles[0];
var category = fileService.RetrieveTemplateFileContents(
Path.GetDirectoryName(categoryPath), Path.GetFileName(categoryPath));
var productPath = files.EntityTypeFiles[1];
var product = fileService.RetrieveTemplateFileContents(
Path.GetDirectoryName(productPath), Path.GetFileName(productPath));
generatedFiles.Add(Constants.Files.CategoryFile, category);
generatedFiles.Add(Constants.Files.ProductFile, product);
}
return(generatedFiles);
}
private IReverseEngineerScaffolder CreateScaffolder(ReverseEngineerOptions revEngOptions, Action <HandlebarsScaffoldingOptions> configureOptions, string filenamePrefix = null)
{
var fileService = new InMemoryTemplateFileService();
fileService.InputFiles(ContextClassTemplate, ContextImportsTemplate,
ContextCtorTemplate, ContextOnConfiguringTemplate, ContextDbSetsTemplate,
EntityClassTemplate, EntityImportsTemplate, EntityCtorTemplate, EntityPropertiesTemplate);
var services = new ServiceCollection()
.AddEntityFrameworkDesignTimeServices()
.AddSingleton <IDbContextTemplateService, FakeHbsDbContextTemplateService>()
.AddSingleton <IEntityTypeTemplateService, FakeHbsEntityTypeTemplateService>()
.AddSingleton <ITemplateFileService>(fileService)
.AddSingleton <ITemplateLanguageService, FakeCSharpTemplateLanguageService>()
.AddSingleton <IModelCodeGenerator, HbsCSharpModelGenerator>();
#pragma warning disable EF1001 // Internal EF Core API usage.
services
.AddSingleton(provider =>
{
ICSharpDbContextGenerator contextGenerator = new HbsCSharpDbContextGenerator(
provider.GetRequiredService <IProviderConfigurationCodeGenerator>(),
provider.GetRequiredService <IAnnotationCodeGenerator>(),
provider.GetRequiredService <IDbContextTemplateService>(),
provider.GetRequiredService <IEntityTypeTransformationService>(),
provider.GetRequiredService <ICSharpHelper>(),
provider.GetRequiredService <IOptions <HandlebarsScaffoldingOptions> >());
return(revEngOptions == ReverseEngineerOptions.DbContextOnly ||
revEngOptions == ReverseEngineerOptions.DbContextAndEntities
? contextGenerator
: new NullCSharpDbContextGenerator());
})
.AddSingleton(provider =>
{
ICSharpEntityTypeGenerator entityGenerator = new HbsCSharpEntityTypeGenerator(
provider.GetRequiredService <IAnnotationCodeGenerator>(),
provider.GetRequiredService <ICSharpHelper>(),
provider.GetRequiredService <IEntityTypeTemplateService>(),
provider.GetRequiredService <IEntityTypeTransformationService>(),
provider.GetRequiredService <IOptions <HandlebarsScaffoldingOptions> >());
return(revEngOptions == ReverseEngineerOptions.EntitiesOnly ||
revEngOptions == ReverseEngineerOptions.DbContextAndEntities
? entityGenerator
: new NullCSharpEntityTypeGenerator());
});
#pragma warning restore EF1001 // Internal EF Core API usage.
services
.AddSingleton <IHbsHelperService>(provider =>
new HbsHelperService(new Dictionary <string, Action <TextWriter, Dictionary <string, object>, object[]> >
{
{ EntityFrameworkCore.Scaffolding.Handlebars.Helpers.Constants.SpacesHelper, HandlebarsHelpers.SpacesHelper }
}))
.AddSingleton <IHbsBlockHelperService>(provider =>
new HbsBlockHelperService(new Dictionary <string, Action <TextWriter, HelperOptions, Dictionary <string, object>, object[]> >()))
.AddSingleton <IReverseEngineerScaffolder, HbsReverseEngineerScaffolder>();
if (string.IsNullOrWhiteSpace(filenamePrefix))
{
services
.AddSingleton <IContextTransformationService, HbsContextTransformationService>()
.AddSingleton <IEntityTypeTransformationService, HbsEntityTypeTransformationService>();
}
else
{
services
.AddSingleton <IContextTransformationService>(y => new HbsContextTransformationService(contextName => $"{filenamePrefix}{contextName}"))
.AddSingleton <IEntityTypeTransformationService>(y => new HbsEntityTypeTransformationService(entityFileNameTransformer: entityName => $"{filenamePrefix}{entityName}"));
}
services.Configure(configureOptions);
#pragma warning disable EF1001 // Internal EF Core API usage.
new SqlServerDesignTimeServices().ConfigureDesignTimeServices(services);
#pragma warning restore EF1001 // Internal EF Core API usage.
var scaffolder = services
.BuildServiceProvider()
.GetRequiredService <IReverseEngineerScaffolder>();
return(scaffolder);
}