protected void GenerateEntities()
{
var tables = TablesToGenerate.ToList();
tables.ForEach(table =>
{
if (Options.OutputToSingleFile)
{
GenerationContext.SingleFile(fb =>
{
var filePath = $"{Options.OutputDir}{Path.DirectorySeparatorChar}{Options.OutputSingleFileName}";
fb.Path(filePath);
GenerateEntityInterface(table, fb);
GenerateEntity(table, fb);
GenerateModelInterface(table, fb);
GenerateModel(table, fb);
});
}
else
{
GenerationContext
.FileIfPathIsSet(fb => GenerateEntityInterface(table, fb))
.FileIfPathIsSet(fb => GenerateEntity(table, fb))
.FileIfPathIsSet(fb => GenerateModelInterface(table, fb))
.FileIfPathIsSet(fb => GenerateModel(table, fb));
}
});
// generate foreign keys and navigation properties.
tables.ForEach(table =>
{
GenerateForeignKeys(table);
GenerateOneToOnes(table);
GenerateHasMany(table);
GenerateManyToMany(table);
});
}
protected override void GenerateContext()
{
var contextNamespace = ContextNamespace();
var contextClassName = ContextClassName();
Action <FileBuilder> generateContextInline = (FileBuilder fileBuilder) =>
{
if (!Options.OutputToSingleFile)
{
var filePath = $"{Options.OutputDir}{Path.DirectorySeparatorChar}{Options.ContextName}.generated.cs";
fileBuilder.Path(filePath);
}
fileBuilder.Using("Microsoft.EntityFrameworkCore");
fileBuilder.Namespace(contextNamespace, true, ns =>
{
ns.Class(contextClassName, true, contextClass =>
{
contextClass.Partial(true).Inherits(Options.ContextBaseClassName);
TablesToGenerate.ForEach(table =>
{
var tableClassFullName = TableClassFullName(table);
var tableNamePlural = Pluralize(table.Name);
contextClass.Property(tableNamePlural, true, dbSetProp =>
{
dbSetProp.Virtual(true).Type($"DbSet<{tableClassFullName}>");
});
});
// empty constructor.
contextClass.Constructor(c => c.Class(contextClass));
// constructor with options.
contextClass.Constructor(c => c
.Class(contextClass)
.Parameter(p => p.Type($"DbContextOptions<{contextClassName}>").Name("options"))
.BaseParameter("options")
);
// override On Configuring
contextClass.Method(m =>
{
m
.AccessModifier(AccessModifiers.Protected)
.Override(true)
.ReturnType("void")
.Name("OnConfiguring")
.Parameter(p => p.Type("DbContextOptionsBuilder").Name("optionsBuilder"));
if (Options.AddConnectionStringOnGenerate)
{
m.Add(() =>
{
return(IfBuilder.Create()
.RawCondition(c => c.Condition("!optionsBuilder.IsConfigured"))
.Add(RawLineBuilder.Create(
"#warning To protect potentially sensitive information in your connection string, you should move it out of source code. See http://go.microsoft.com/fwlink/?LinkId=723263 for guidance on storing connection strings.")
.NoEndOfLine())
.Add(UseDatabaseEngineConnectionStringLine()));
});
}
});
// model creating.
contextClass.Method(m =>
{
m
.AccessModifier(AccessModifiers.Protected)
.Override(true)
.ReturnType("void")
.Name("OnModelCreating")
.Parameter(p => p.Type("ModelBuilder").Name("modelBuilder"));
TablesToGenerate.ForEach(table =>
{
AddFluentToMethod(m, table);
});
SequenceToGenerate.ForEach(sequence =>
{
var dataType = DataTypeResolver.ResolveType(sequence);
var outputType = dataType.GetOutputType();
m.RawLine($"modelBuilder.HasSequence<{outputType}>(\"{sequence.Name}\").StartsAt({sequence.StartAt}).IncrementsBy({sequence.IncrementsBy})");
});
});
});
});
};
if (Options.OutputToSingleFile)
{
GenerationContext.SingleFile(fb => generateContextInline(fb));
}
else
{
GenerationContext.FileIfPathIsSet(fb => generateContextInline(fb));
}
}
protected override void GenerateContext()
{
var contextNamespace = ContextNamespace();
var contextClassName = ContextClassName();
Action <FileBuilder> generateContextInline = (FileBuilder fileBuilder) =>
{
if (!Options.OutputToSingleFile)
{
var filePath = $"{Options.OutputDir}{Path.DirectorySeparatorChar}{Options.ContextName}.generated.cs";
fileBuilder.Path(filePath);
}
fileBuilder.Using("System.Linq");
fileBuilder.Namespace(contextNamespace, true, ns =>
{
ns.Class(contextClassName, true, contextClass =>
{
contextClass.Partial(true).Inherits(Options.ContextBaseClassName);
TablesToGenerate.ForEach(table =>
{
var tableClassFullName = TableClassFullName(table);
var tableNamePlural = Pluralize(table.Name);
contextClass.Property(tableNamePlural, true, dbSetProp =>
{
dbSetProp.Type($"System.Data.Entity.DbSet<{tableClassFullName}>");
});
});
contextClass.Constructor(c => c
.AccessModifier(AccessModifiers.Omit)
.IsStatic(true)
.Class(contextClass)
.RawLine($"System.Data.Entity.Database.SetInitializer<{Options.ContextName}>(null)")
);
contextClass.Constructor(c => c
.Class(contextClass)
.BaseParameter($"\"{Options.ConnectionStringName ?? Options.ConnectionString}\"")
.RawLine("InitializePartial()")
);
contextClass.Constructor(c => c
.Class(contextClass)
.Parameter(p => p.Type("string").Name("connectionString"))
.BaseParameter("connectionString")
.RawLine("InitializePartial()")
);
contextClass.Constructor(c => c
.Class(contextClass)
.Parameter(p => p.Type("string").Name("connectionString"))
.Parameter(p => p.Type("System.Data.Entity.Infrastructure.DbCompiledModel").Name("model"))
.BaseParameter("connectionString")
.BaseParameter("model")
.RawLine("InitializePartial()")
);
contextClass.Method(addConfigurationMethod =>
{
addConfigurationMethod
.IsStatic(true)
.ReturnType("void")
.AccessModifier(AccessModifiers.Protected)
.Name("AddFluentConfigurations")
.Parameter(p => p.Type("System.Data.Entity.DbModelBuilder").Name("modelBuilder"));
TablesToGenerate.ForEach(table =>
{
var fcc = TableClassFullName(table) + Options.FluentConfigurationClassSuffix;
addConfigurationMethod.RawLine($"modelBuilder.Configurations.Add(new {fcc}())");
});
});
contextClass.Method(m => m
.AccessModifier(AccessModifiers.Omit)
.Name("OnModelCreatingPartial")
.ReturnType("void")
.Partial(true)
.Parameter(p => p.Type("System.Data.Entity.DbModelBuilder").Name("modelBuilder"))
);
contextClass.Method(m => m
.AccessModifier(AccessModifiers.Omit)
.Name("InitializePartial")
.ReturnType("void")
.Partial(true)
);
contextClass.Method(m =>
{
m
.AccessModifier(AccessModifiers.Protected)
.Override(true)
.ReturnType("void")
.Name("OnModelCreating")
.Parameter(p => p.Type("System.Data.Entity.DbModelBuilder").Name("modelBuilder"))
.RawLine("base.OnModelCreating(modelBuilder)")
.RawLine("AddFluentConfigurations(modelBuilder)")
.RawLine("OnModelCreatingPartial(modelBuilder)");
});
contextClass.Method(m =>
{
m
.AccessModifier(AccessModifiers.Public)
.IsStatic(true)
.ReturnType("System.Data.Entity.DbModelBuilder")
.Name("CreateModel")
.Parameter(p => p.Type("System.Data.Entity.DbModelBuilder").Name("modelBuilder"))
.Parameter(p => p.Type("string").Name("schema"))
.RawLine("AddFluentConfigurations(modelBuilder)")
.RawLine("return modelBuilder");
});
});
});
};
if (Options.OutputToSingleFile)
{
GenerationContext.SingleFile(fb => generateContextInline(fb));
}
else
{
GenerationContext.FileIfPathIsSet(fb => generateContextInline(fb));
}
}
