/// <summary>
/// Constructor for the HbsCSharpModelGenerator.
/// </summary>
/// <param name="databaseModelFactory">Service to reverse engineer a database into a database model.</param>
/// <param name="scaffoldingModelFactory">Factory to create a scaffolding model.</param>
/// <param name="modelCodeGeneratorSelector">Selects a model code generator service for a given programming language.</param>
/// <param name="cSharpUtilities">C# utilities.</param>
/// <param name="cSharpHelper">C# helper.</param>
/// <param name="connectionStringResolver">Connection string resolver.</param>
public HbsReverseEngineerScaffolderEnhance(
HandlebarsScaffoldingOptions handlebarsScaffoldingOptions,
IDatabaseModelFactory databaseModelFactory,
IScaffoldingModelFactory scaffoldingModelFactory,
IModelCodeGeneratorSelector modelCodeGeneratorSelector,
ICSharpUtilities cSharpUtilities,
ICSharpHelper cSharpHelper,
INamedConnectionStringResolver connectionStringResolver) : base(databaseModelFactory,
scaffoldingModelFactory,
modelCodeGeneratorSelector,
cSharpUtilities,
cSharpHelper,
connectionStringResolver)
{
HandlebarsScaffoldingOptions = handlebarsScaffoldingOptions ?? HandlebarsScaffoldingOptions.Default;
}
public void IModel_Extensions_Should_Not_Filter_If_No_Excluded_Tables()
{
var builder = new ModelBuilder(new ConventionSet());
builder.Entity <Category>()
.ToTable("Category", "dbo");
builder.Entity <Product>()
.ToTable("Product", "prd");
var options = new HandlebarsScaffoldingOptions
{
ExcludedTables = null
};
var entityTypes = builder.Model.GetScaffoldEntityTypes(options);
Assert.Contains(entityTypes, e => e.ClrType.Name == "Category");
Assert.Contains(entityTypes, e => e.ClrType.Name == "Product");
}
/// <summary>
/// Constructor for the HbsCSharpModelGenerator.
/// </summary>
/// <param name="dependencies">Service dependencies parameter class for HbsCSharpModelGenerator.</param>
/// <param name="handlebarsHelperService">Handlebars helper service.</param>
/// <param name="dbContextTemplateService">Template service for DbContext generator.</param>
/// <param name="entityTypeTemplateService">Template service for the entity types generator.</param>
/// <param name="entityTypeTransformationService">Service for transforming entity definitions.</param>
/// <param name="cSharpDbContextGenerator">DbContext generator.</param>
/// <param name="cSharpEntityTypeGenerator">Entity type generator.</param>
public HbsCSharpModelGeneratorEnhance(ModelCodeGeneratorDependencies dependencies,
IHbsHelperService handlebarsHelperService,
IDbContextTemplateService dbContextTemplateService,
IEntityTypeTemplateService entityTypeTemplateService,
IEntityTypeConfigurationTemplateService entityTypeConfigurationTemplateService,
IEntityTypeTransformationService entityTypeTransformationService,
ICSharpDbContextGenerator cSharpDbContextGenerator,
ICSharpEntityTypeGenerator cSharpEntityTypeGenerator,
ICSharpEntityTypeConfigurationGenerator cSharpEntityTypeConfigurationGenerator,
HandlebarsScaffoldingOptions handlebarsScaffoldingOptions) : base(dependencies,
handlebarsHelperService,
dbContextTemplateService,
entityTypeTemplateService,
entityTypeTransformationService,
cSharpDbContextGenerator,
cSharpEntityTypeGenerator)
{
EntityTypeConfigurationTemplateService = entityTypeConfigurationTemplateService;
CSharpEntityTypeConfigurationGenerator = cSharpEntityTypeConfigurationGenerator;
HandlebarsScaffoldingOptions = handlebarsScaffoldingOptions ?? HandlebarsScaffoldingOptions.Default;
}
public void IModel_Extensions_Should_Filter_EntityTypes_From_Options_By_Table_Name_and_Schema()
{
var builder = new ModelBuilder(new ConventionSet());
builder.Entity <Category>()
.ToTable("Category", "dbo");
builder.Entity <Product>()
.ToTable("Product", "prd");
var options = new HandlebarsScaffoldingOptions
{
ExcludedTables = new List <string> {
"dbo.Category", "dbo.Product"
}
};
var entityTypes = builder.Model.GetScaffoldEntityTypes(options);
Assert.DoesNotContain(entityTypes, e => e.ClrType.Name == "Category");
Assert.Contains(entityTypes, e => e.ClrType.Name == "Product");
}
/// <summary>
/// Constructor for the Handlebars DbContext generator.
/// </summary>
/// <param name="handlebarsScaffoldingOptions">Handlebars Scaffolding Options.</param>
/// <param name="legacyProviderCodeGenerators">Legacy provider code generators.</param>
/// <param name="providerCodeGenerators">Generator for scaffolding provider.</param>
/// <param name="annotationCodeGenerator">Annotation code generator.</param>
/// <param name="dbContextTemplateService">Template service for DbContext generator.</param>
/// <param name="entityTypeTransformationService">Service for transforming entity definitions.</param>
/// <param name="cSharpHelper">CSharp helper.</param>
public HbsCSharpDbContextGeneratorEnhance(
#pragma warning disable CS0618 // Type or member is obsolete
IEnumerable <IScaffoldingProviderCodeGenerator> legacyProviderCodeGenerators,
#pragma warning restore CS0618 // Type or member is obsolete
IEnumerable <IProviderConfigurationCodeGenerator> providerCodeGenerators,
IAnnotationCodeGenerator annotationCodeGenerator,
IDbContextTemplateService dbContextTemplateService,
IEntityTypeTransformationService entityTypeTransformationService,
ICSharpHelper cSharpHelper,
HandlebarsScaffoldingOptions handlebarsScaffoldingOptions)
{
if (!legacyProviderCodeGenerators.Any() && !providerCodeGenerators.Any())
{
throw new ArgumentException(AbstractionsStrings.CollectionArgumentIsEmpty(nameof(providerCodeGenerators)));
}
HandlebarsScaffoldingOptions = handlebarsScaffoldingOptions ?? HandlebarsScaffoldingOptions.Default;
LegacyProviderCodeGenerator = legacyProviderCodeGenerators.LastOrDefault();
ProviderConfigurationCodeGenerator = providerCodeGenerators.LastOrDefault();
CodeGenerator = annotationCodeGenerator ?? throw new ArgumentNullException(nameof(annotationCodeGenerator));
DbContextTemplateService = dbContextTemplateService ?? throw new ArgumentNullException(nameof(dbContextTemplateService));
EntityTypeTransformationService = entityTypeTransformationService ?? throw new ArgumentNullException(nameof(entityTypeTransformationService));
CSharpHelper = cSharpHelper ?? throw new ArgumentNullException(nameof(cSharpHelper));
}
/// <summary>
/// <para>
/// Registers the Handlebars scaffolding generator as a service in the <see cref="IServiceCollection" />.
/// This allows you to customize generated DbContext and entity type classes by modifying the Handlebars
/// templates in the CodeTemplates folder.
/// </para>
/// <para>
/// Has <paramref name="configureOptions" /> that allow you to choose whether to generate only the DbContext class,
/// only entity type classes, or both DbContext and entity type classes (the default).
/// It also allows you to exclude tables from the generation.
/// This can be useful when placing model classes in a separate class library.
/// </para>
/// </summary>
/// <param name="services"> The <see cref="IServiceCollection" /> to add services to. </param>
/// <param name="configureOptions">Method for configuring options for reverse engineering classes from an existing database.</param>
/// <returns>The same service collection so that multiple calls can be chained.</returns>
public static IServiceCollection AddHandlebarsScaffolding(this IServiceCollection services,
Action <HandlebarsScaffoldingOptions> configureOptions)
{
var scaffoldingOptions = new HandlebarsScaffoldingOptions();
if (configureOptions == null)
{
configureOptions = options => options.ReverseEngineerOptions = ReverseEngineerOptions.DbContextAndEntities;
}
configureOptions(scaffoldingOptions);
services.Configure(configureOptions);
Type dbContextGeneratorImpl;
var dbContextGeneratorType = typeof(ICSharpDbContextGenerator);
if (scaffoldingOptions.ReverseEngineerOptions == ReverseEngineerOptions.DbContextOnly ||
scaffoldingOptions.ReverseEngineerOptions == ReverseEngineerOptions.DbContextAndEntities)
{
dbContextGeneratorImpl = typeof(HbsCSharpDbContextGenerator);
}
else
{
dbContextGeneratorImpl = typeof(NullCSharpDbContextGenerator);
}
services.AddSingleton(dbContextGeneratorType, dbContextGeneratorImpl);
Type entityGeneratorImpl;
var entityGeneratorType = typeof(ICSharpEntityTypeGenerator);
if (scaffoldingOptions.ReverseEngineerOptions == ReverseEngineerOptions.EntitiesOnly ||
scaffoldingOptions.ReverseEngineerOptions == ReverseEngineerOptions.DbContextAndEntities)
{
if (scaffoldingOptions.LanguageOptions == LanguageOptions.TypeScript)
{
entityGeneratorImpl = typeof(HbsTypeScriptEntityTypeGenerator);
}
else
{
entityGeneratorImpl = typeof(HbsCSharpEntityTypeGenerator);
}
}
else
{
entityGeneratorImpl = typeof(NullCSharpEntityTypeGenerator);
}
services.AddSingleton(entityGeneratorType, entityGeneratorImpl);
if (scaffoldingOptions.LanguageOptions == LanguageOptions.TypeScript)
{
services.AddSingleton <ITypeScriptHelper, TypeScriptHelper>();
services.AddSingleton <IModelCodeGenerator, HbsTypeScriptModelGenerator>();
services.AddSingleton <ITemplateLanguageService, TypeScriptTemplateLanguageService>();
}
else
{
services.AddSingleton <IModelCodeGenerator, HbsCSharpModelGenerator>();
services.AddSingleton <ITemplateLanguageService, CSharpTemplateLanguageService>();
}
if (scaffoldingOptions.EnablePluralization)
{
services.AddSingleton <IPluralizer, HumanizerPluralizer>();
}
if (scaffoldingOptions.EmbeddedTemplatesAssembly != null)
{
services.AddSingleton <ITemplateFileService>(new EmbeddedResourceTemplateFileService(
scaffoldingOptions.EmbeddedTemplatesAssembly, scaffoldingOptions.EmbeddedTemplatesNamespace));
}
else
{
services.AddSingleton <ITemplateFileService, FileSystemTemplateFileService>();
}
services.AddSingleton <IDbContextTemplateService, HbsDbContextTemplateService>();
services.AddSingleton <IEntityTypeTemplateService, HbsEntityTypeTemplateService>();
services.AddSingleton <IReverseEngineerScaffolder, HbsReverseEngineerScaffolder>();
services.AddSingleton <IEntityTypeTransformationService, HbsEntityTypeTransformationService>();
services.AddSingleton <IHbsHelperService, HbsHelperService>(provider =>
{
var helpers = new Dictionary <string, Action <TextWriter, Dictionary <string, object>, object[]> >
{
{ Constants.SpacesHelper, HandlebarsHelpers.SpacesHelper }
};
return(new HbsHelperService(helpers));
});
services.AddSingleton <IHbsBlockHelperService, HbsBlockHelperService>(provider =>
{
var helpers = new Dictionary <string, Action <TextWriter, HelperOptions, Dictionary <string, object>, object[]> >();
return(new HbsBlockHelperService(helpers));
});
return(services);
}
private static void AddSingletonForCSharpEntityTypeGenerator(IServiceCollection services, HandlebarsScaffoldingOptions options)
{
Type entityGeneratorImpl;
var entityGeneratorType = typeof(ICSharpEntityTypeGenerator);
if (options.ReverseEngineerOptions == ReverseEngineerOptions.EntitiesOnly ||
options.ReverseEngineerOptions == ReverseEngineerOptions.DbContextAndEntities)
{
entityGeneratorImpl = typeof(HbsCSharpEntityTypeGenerator);
}
else
{
entityGeneratorImpl = typeof(NullCSharpEntityTypeGenerator);
}
services.AddSingleton(entityGeneratorType, entityGeneratorImpl);
}
private static void AddSingletonForCSharpEntityTypeConfigurationGenerator(IServiceCollection services, HandlebarsScaffoldingOptions options)
{
Type entityTypeCfgGeneratorImpl = null;
var entityTypeCfgGeneratorType = typeof(ICSharpEntityTypeConfigurationGenerator);
if (options.ReverseEngineerOptions == ReverseEngineerOptions.DbContextOnly ||
options.ReverseEngineerOptions == ReverseEngineerOptions.DbContextAndEntities)
{
if (options.RefineFluteAPI)
{
entityTypeCfgGeneratorImpl = typeof(HbsCSharpEntityTypeConfigurationGenerator);
}
}
if (entityTypeCfgGeneratorImpl == null)
{
entityTypeCfgGeneratorImpl = typeof(NullCSharpEntityTypeConfigurationGenerator);
}
services.AddSingleton(entityTypeCfgGeneratorType, entityTypeCfgGeneratorImpl);
}
private static void AddSingletonForCSharpDbContextGenerator(IServiceCollection services, HandlebarsScaffoldingOptions options)
{
Type dbContextGeneratorImpl;
var dbContextGeneratorType = typeof(ICSharpDbContextGenerator);
if (options.ReverseEngineerOptions == ReverseEngineerOptions.DbContextOnly ||
options.ReverseEngineerOptions == ReverseEngineerOptions.DbContextAndEntities)
{
dbContextGeneratorImpl = typeof(HbsCSharpDbContextGeneratorEnhance);
}
else
{
dbContextGeneratorImpl = typeof(NullCSharpDbContextGenerator);
}
services.AddSingleton(dbContextGeneratorType, dbContextGeneratorImpl);
}
/// <summary>
/// <para>
/// 将Handlebars脚手架生成器注册为<see cref =“IServiceCollection”/>中的服务。
/// 这允许您通过修改CodeTemplates文件夹中的Handlebars模板来自定义生成的DbContext和实体类型类。
/// </para>
/// <para>
/// 有<paramref name =“options”/>，它允许您选择是仅生成DbContext类，
/// 仅生成实体类型类，还是生成DbContext和实体类型类（默认值）。
/// 这在将模型类放入a时非常有用。 单独的类库。
/// </para>
/// </summary>
/// <param name="services"> The <see cref="IServiceCollection" /> to add services to. </param>
/// <param name="options">Options for reverse engineering classes from an existing database.</param>
/// <returns>The same service collection so that multiple calls can be chained.</returns>
public static IServiceCollection AddHandlebarsScaffolding(this IServiceCollection services, HandlebarsScaffoldingOptions options = null)
{
if (options == null)
{
options = HandlebarsScaffoldingOptions.Default;
}
services.AddSingleton <HandlebarsScaffoldingOptions>(options);
AddSingletonForCSharpDbContextGenerator(services, options);
AddSingletonForCSharpEntityTypeConfigurationGenerator(services, options);
AddSingletonForCSharpEntityTypeGenerator(services, options);
services.AddSingleton <ITemplateFileService, FileSystemTemplateFileService>();
services.AddSingleton <IDbContextTemplateService, HbsDbContextTemplateService>();
services.AddSingleton <IEntityTypeTemplateService, HbsEntityTypeTemplateService>();
services.AddSingleton <IEntityTypeConfigurationTemplateService, HbsEntityTypeConfigurationTemplateService>();
services.AddSingleton <IModelCodeGenerator, HbsCSharpModelGeneratorEnhance>();
services.AddSingleton <IReverseEngineerScaffolder, HbsReverseEngineerScaffolderEnhance>();
services.AddSingleton <IEntityTypeTransformationService, HbsEntityTypeTransformationService>();
services.AddSingleton <IHbsHelperService, HbsHelperService>(provider =>
{
var helpers = new Dictionary <string, Action <TextWriter, Dictionary <string, object>, object[]> >
{
{ Constants.SpacesHelper, HandlebarsHelpers.SpacesHelper }
};
return(new HbsHelperService(helpers));
});
return(services);
}
