private static MethodDefinition GetOnModelCreatingMethod(EntityFrameworkCoreProject project)
{
var lines = new List <ILine>();
var selection = project.GlobalSelection();
if (selection.Settings.UseDataAnnotations)
{
var primaryKeys = project
.Database
.Tables
.Where(item => item.PrimaryKey != null)
.Select(item => item.GetColumnsFromConstraint(item.PrimaryKey)
.Select(c => c.Name)
.First())
.ToList();
foreach (var view in project.Database.Views)
{
var result = view.Columns.Where(item => primaryKeys.Contains(item.Name)).ToList();
if (result.Count == 0)
{
lines.Add(new CodeLine("modelBuilder.Entity<{0}>().HasKey(e => new {{ {1} }});", project.GetEntityName(view), string.Join(", ", view.Columns.Select(item => string.Format("e.{0}", item.GetPropertyName())))));
lines.Add(new CodeLine());
}
else
{
lines.Add(new CodeLine("modelBuilder.Entity<{0}>().HasKey(e => new {{ {1} }});", project.GetEntityName(view), string.Join(", ", result.Select(item => string.Format("e.{0}", item.GetPropertyName())))));
lines.Add(new CodeLine());
}
}
}
else
{
if (project.Database.Tables.Count > 0)
{
lines.Add(new CommentLine(" Apply all configurations for tables"));
lines.Add(new CodeLine());
lines.Add(new CodeLine("modelBuilder"));
foreach (var table in project.Database.Tables)
{
lines.Add(new CodeLine(1, ".ApplyConfiguration(new {0}())", project.GetEntityConfigurationName(table)));
}
lines.Add(new CodeLine(";"));
lines.Add(new CodeLine());
}
if (project.Database.Views.Count > 0)
{
lines.Add(new CommentLine(" Apply all configurations for views"));
lines.Add(new CodeLine());
lines.Add(new CodeLine("modelBuilder"));
foreach (var view in project.Database.Views)
{
lines.Add(new CodeLine(1, ".ApplyConfiguration(new {0}())", project.GetEntityConfigurationName(view)));
}
lines.Add(new CodeLine(";"));
lines.Add(new CodeLine());
}
}
lines.Add(new CodeLine("base.OnModelCreating(modelBuilder);"));
return(new MethodDefinition(AccessModifier.Protected, "void", "OnModelCreating", new ParameterDefinition("ModelBuilder", "modelBuilder"))
{
IsOverride = true,
Lines = lines
});
}
public static EntityConfigurationClassDefinition GetEntityConfigurationClassDefinition(this EntityFrameworkCoreProject project, ITable table)
{
var definition = new EntityConfigurationClassDefinition
{
Namespaces =
{
"Microsoft.EntityFrameworkCore",
"Microsoft.EntityFrameworkCore.Metadata.Builders"
},
AccessModifier = AccessModifier.Public,
Name = project.GetEntityConfigurationName(table),
DbObject = table
};
definition.Namespaces.AddUnique(project.GetEntityLayerNamespace(project.Database.HasDefaultSchema(table) ? string.Empty : table.Schema));
if (project.Database.HasDefaultSchema(table))
{
definition.Namespace = project.GetDataLayerConfigurationsNamespace();
}
else
{
definition.Namespace = project.GetDataLayerConfigurationsNamespace(table.Schema);
}
// todo: Check logic to build property's name
var propertyType = string.Join(".", (new string[] { project.Name, project.ProjectNamespaces.EntityLayer, project.Database.HasDefaultSchema(table) ? string.Empty : table.Schema, project.GetEntityName(table) }).Where(item => !string.IsNullOrEmpty(item)));
definition.Implements.Add(string.Format("IEntityTypeConfiguration<{0}>", propertyType));
var configLines = new List <ILine>
{
new CommentLine(" Set configuration for entity")
};
if (string.IsNullOrEmpty(table.Schema))
{
configLines.Add(new CodeLine("builder.ToTable(\"{0}\");", table.Name));
}
else
{
configLines.Add(new CodeLine("builder.ToTable(\"{0}\", \"{1}\");", table.Name, table.Schema));
}
configLines.Add(new CodeLine());
var columns = default(List <Column>);
if (table.PrimaryKey == null || table.PrimaryKey.Key.Count == 0)
{
configLines.Add(LineHelper.Warning("Add configuration for entity's key"));
configLines.Add(new CodeLine());
}
else
{
configLines.Add(new CommentLine(" Set key for entity"));
if (table.PrimaryKey.Key.Count == 1)
{
configLines.Add(new CodeLine("builder.HasKey(p => p.{0});", project.CodeNamingConvention.GetPropertyName(table.PrimaryKey.Key[0])));
configLines.Add(new CodeLine());
}
else if (table.PrimaryKey.Key.Count > 1)
{
configLines.Add(new CodeLine("builder.HasKey(p => new {{ {0} }});", string.Join(", ", table.PrimaryKey.Key.Select(item => string.Format("p.{0}", project.CodeNamingConvention.GetPropertyName(item))))));
configLines.Add(new CodeLine());
}
}
if (table.Identity != null)
{
configLines.Add(new CommentLine(" Set identity for entity (auto increment)"));
configLines.Add(new CodeLine("builder.Property(p => p.{0}).UseSqlServerIdentityColumn();", project.CodeNamingConvention.GetPropertyName(table.Identity.Name)));
configLines.Add(new CodeLine());
}
columns = table.Columns;
configLines.Add(new CommentLine(" Set configuration for columns"));
for (var i = 0; i < columns.Count; i++)
{
var column = columns[i];
System.Type ValueConversion = null;
if (project.Database.HasTypeMappedToClr(column))
{
var lines = new List <string>
{
string.Format("builder.Property(p => p.{0})", project.GetPropertyName(table, column))
};
if (string.Compare(column.Name, project.GetPropertyName(table, column)) != 0)
{
lines.Add(string.Format("HasColumnName(\"{0}\")", column.Name));
}
if (project.Database.ColumnIsString(column))
{
lines.Add(column.Length <= 0 ? string.Format("HasColumnType(\"{0}(max)\")", column.Type) : string.Format("HasColumnType(\"{0}({1})\")", column.Type, column.Length));
}
else if (project.Database.ColumnIsDecimal(column))
{
lines.Add(string.Format("HasColumnType(\"{0}({1}, {2})\")", column.Type, column.Prec, column.Scale));
}
else if (project.Database.ColumnIsDouble(column) || project.Database.ColumnIsSingle(column))
{
lines.Add(string.Format("HasColumnType(\"{0}({1})\")", column.Type, column.Prec));
}
else if (project.Database.ColumnIsByteArray(column))
{
lines.Add(string.Format("HasColumnType(\"{0}({1})\")", column.Type, column.Length));
}
else
{
lines.Add(string.Format("HasColumnType(\"{0}\")", column.Type));
}
// Use ValueConversionMaps to detect and apply ValueConversion Type based on Type
if (project.ValueConversionMaps?.TryGetValue(column.Type, out ValueConversion) == true)
{
lines.Add($"HasConversion(typeof({ValueConversion?.FullName}))");
}
if (!column.Nullable)
{
lines.Add("IsRequired()");
}
configLines.Add(new CodeLine("{0};", string.Join(".", lines)));
}
else
{
configLines.Add(new CodeLine("builder.Ignore(p => p.{0});", project.GetPropertyName(table, column)));
}
}
configLines.Add(new CodeLine());
var projectSelection = project.GetSelection(table);
for (var i = 0; i < columns.Count; i++)
{
var column = columns[i];
if (!string.IsNullOrEmpty(projectSelection.Settings.ConcurrencyToken) && string.Compare(column.Name, projectSelection.Settings.ConcurrencyToken) == 0)
{
configLines.Add(new CommentLine(" Set concurrency token for entity"));
configLines.Add(new CodeLine("builder"));
configLines.Add(new CodeLine(1, ".Property(p => p.{0})", project.GetPropertyName(table, column)));
configLines.Add(new CodeLine(1, ".ValueGeneratedOnAddOrUpdate()"));
configLines.Add(new CodeLine(1, ".IsConcurrencyToken();"));
configLines.Add(new CodeLine());
}
}
if (table.Uniques.Count > 0)
{
configLines.Add(new CommentLine(" Add configuration for uniques"));
foreach (var unique in table.Uniques)
{
configLines.Add(new CodeLine("builder"));
if (unique.Key.Count == 1)
{
configLines.Add(new CodeLine(1, ".HasIndex(p => p.{0})", project.CodeNamingConvention.GetPropertyName(unique.Key.First())));
configLines.Add(new CodeLine(1, ".IsUnique()"));
}
else
{
configLines.Add(new CodeLine(1, ".HasIndex(p => new {{ {0} }})", string.Join(", ", unique.Key.Select(item => string.Format("p.{0}", project.CodeNamingConvention.GetPropertyName(item))))));
configLines.Add(new CodeLine(1, ".IsUnique()"));
}
configLines.Add(new CodeLine(1, ".HasName(\"{0}\");", unique.ConstraintName));
configLines.Add(new CodeLine());
}
}
if (projectSelection.Settings.DeclareNavigationProperties && table.ForeignKeys.Count > 0)
{
configLines.Add(new CommentLine(" Add configuration for foreign keys"));
foreach (var foreignKey in table.ForeignKeys)
{
var foreignTable = project.Database.FindTable(foreignKey.References);
if (foreignTable == null || foreignKey.Key.Count == 0)
{
continue;
}
if (foreignKey.Key.Count == 1)
{
var foreignProperty = foreignKey.GetParentNavigationProperty(foreignTable, project);
configLines.Add(new CodeLine("builder"));
configLines.Add(new CodeLine(1, ".HasOne(p => p.{0})", foreignProperty.Name));
configLines.Add(new CodeLine(1, ".WithMany(b => b.{0})", project.GetNavigationPropertyName(table)));
configLines.Add(new CodeLine(1, ".HasForeignKey(p => {0})", string.Format("p.{0}", project.CodeNamingConvention.GetPropertyName(foreignKey.Key.First()))));
configLines.Add(new CodeLine(1, ".HasConstraintName(\"{0}\");", foreignKey.ConstraintName));
configLines.Add(new CodeLine());
}
else
{
configLines.Add(LineHelper.Warning(" Add logic for foreign key with multiple key"));
}
}
}
definition.Methods.Add(new MethodDefinition(AccessModifier.Public, "void", "Configure", new ParameterDefinition(string.Format("EntityTypeBuilder<{0}>", propertyType), "builder"))
{
Lines = configLines
});
return(definition);
}
public static EntityConfigurationClassDefinition GetEntityConfigurationClassDefinition(this EntityFrameworkCoreProject project, IView view)
{
var definition = new EntityConfigurationClassDefinition
{
Namespaces =
{
"Microsoft.EntityFrameworkCore",
"Microsoft.EntityFrameworkCore.Metadata.Builders"
},
Namespace = project.GetDataLayerConfigurationsNamespace(),
AccessModifier = AccessModifier.Public,
Name = project.GetEntityConfigurationName(view),
Implements =
{
string.Format("IEntityTypeConfiguration<{0}>", project.GetEntityName(view))
},
DbObject = view
};
definition.Namespaces.AddUnique(project.GetEntityLayerNamespace(project.Database.HasDefaultSchema(view) ? string.Empty : view.Schema));
var configLines = new List <ILine>
{
new CommentLine(" Set configuration for entity")
};
if (string.IsNullOrEmpty(view.Schema))
{
configLines.Add(new CodeLine("builder.ToTable(\"{0}\");", view.Name));
}
else
{
configLines.Add(new CodeLine("builder.ToTable(\"{0}\", \"{1}\");", view.Name, view.Schema));
}
configLines.Add(new CodeLine());
var primaryKeys = project
.Database
.Tables
.Where(item => item.PrimaryKey != null)
.Select(item => item.GetColumnsFromConstraint(item.PrimaryKey).Select(c => c.Name).First())
.ToList();
var result = view.Columns.Where(item => primaryKeys.Contains(item.Name)).ToList();
if (result.Count == 0)
{
result = view.Columns.Where(item => !item.Nullable).ToList();
}
configLines.Add(new CommentLine(" Add configuration for entity's key"));
configLines.Add(new CodeLine("builder.HasKey(p => new {{ {0} }});", string.Join(", ", result.Select(item => string.Format("p.{0}", project.CodeNamingConvention.GetPropertyName(item.Name))))));
configLines.Add(new CodeLine());
configLines.Add(new CommentLine(" Set configuration for columns"));
for (var i = 0; i < view.Columns.Count; i++)
{
var column = view.Columns[i];
System.Type ValueConversion = null;
if (project.Database.HasTypeMappedToClr(column))
{
var lines = new List <string>
{
string.Format("builder.Property(p => p.{0})", project.GetPropertyName(view, column))
};
if (string.Compare(column.Name, project.GetPropertyName(view, column)) != 0)
{
lines.Add(string.Format("HasColumnName(\"{0}\")", column.Name));
}
if (project.Database.ColumnIsString(column))
{
lines.Add(column.Length <= 0 ? string.Format("HasColumnType(\"{0}(max)\")", column.Type) : string.Format("HasColumnType(\"{0}({1})\")", column.Type, column.Length));
}
else if (project.Database.ColumnIsDecimal(column))
{
lines.Add(string.Format("HasColumnType(\"{0}({1}, {2})\")", column.Type, column.Prec, column.Scale));
}
else if (project.Database.ColumnIsDouble(column) || project.Database.ColumnIsSingle(column))
{
lines.Add(string.Format("HasColumnType(\"{0}({1})\")", column.Type, column.Prec));
}
else
{
lines.Add(string.Format("HasColumnType(\"{0}\")", column.Type));
}
// Use ValueConversionMaps to detect and apply ValueConversion Type based on Type
if (project.ValueConversionMaps?.TryGetValue(column.Type, out ValueConversion) == true)
{
lines.Add($"HasConversion(typeof({ValueConversion?.FullName}))");
}
configLines.Add(new CodeLine("{0};", string.Join(".", lines)));
}
else
{
var lines = new List <string>
{
string.Format("builder.Ignore(p => p.{0})", project.GetPropertyName(view, column))
};
configLines.Add(new CodeLine("{0};", string.Join(".", lines)));
}
}
definition.Methods.Add(new MethodDefinition(AccessModifier.Public, "void", "Configure", new ParameterDefinition(string.Format("EntityTypeBuilder<{0}>", project.GetEntityName(view)), "builder"))
{
Lines = configLines
});
return(definition);
}
public void TestEntityFrameworkCoreProject()
{
// Arrange
var project = new EntityFrameworkCoreProject
{
Name = "Store",
Database = StoreDatabase.Mock,
OutputDirectory = "C:\\Temp\\CatFactory\\EntityFrameworkCore",
AuthorInfo = new AuthorInfo
{
Name = "Hans H.",
Email = "*****@*****.**"
}
};
project.BuildFeatures();
project.GlobalSelection(settings =>
{
settings.UseDataAnnotations = true;
settings.AddDataBindings = true;
});
project.Select("Sales.Order", settings => settings.EntitiesWithDataContracts = true);
project.ScaffoldingDefinition += (source, args) =>
{
};
project.ScaffoldedDefinition += (source, args) =>
{
};
// Act
foreach (var table in project.Database.Tables)
{
var selection = project.Selections.FirstOrDefault(item => item.Pattern == table.FullName) ?? project.GlobalSelection();
var codeBuilder = new CSharpClassCodeBuilder
{
ObjectDefinition = project.GetEntityClassDefinition(table, selection),
OutputDirectory = project.OutputDirectory,
ForceOverwrite = true
};
codeBuilder.TranslatedDefinition += (source, args) =>
{
if (project.AuthorInfo != null)
{
codeBuilder.Lines.Insert(0, new CommentLine("// Author name: {0}", project.AuthorInfo.Name));
codeBuilder.Lines.Insert(1, new CommentLine("// Email: {0}", project.AuthorInfo.Email));
codeBuilder.Lines.Insert(2, new CodeLine());
}
};
project.Scaffolding(codeBuilder);
codeBuilder.CreateFile();
project.Scaffolded(codeBuilder);
}
// Assert
Assert.True(project.Selections.Count == 2);
}
public void DefineProjectForV2x()
{
var project = EntityFrameworkCoreProject.CreateForV2x("OnlineStore", new ObjectRelationalMapping.Database(), "");
Assert.True(project.Version <= EntityFrameworkCoreVersion.Version_2_2);
}
private static MethodDefinition GetOnModelCreatingMethod(EntityFrameworkCoreProject project)
{
var lines = new List <ILine>();
var selection = project.GlobalSelection();
if (selection.Settings.UseDataAnnotations)
{
var primaryKeys = project
.Database
.Tables
.Where(item => item.PrimaryKey != null)
.Select(item => item.GetColumnsFromConstraint(item.PrimaryKey).Select(key => key.Name).First())
.ToList();
foreach (var view in project.Database.Views)
{
var result = view.Columns.Where(item => primaryKeys.Contains(item.Name)).ToList();
if (result.Count == 0)
{
lines.Add(
new CodeLine("modelBuilder.Entity<{0}>().HasKey(e => new {{ {1} }});", project.GetEntityName(view), string.Join(", ", view.Columns.Select(item => string.Format("e.{0}", project.GetPropertyName(view, item))))));
lines.Add(new EmptyLine());
}
else
{
lines.Add(
new CodeLine("modelBuilder.Entity<{0}>().HasKey(e => new {{ {1} }});", project.GetEntityName(view), string.Join(", ", result.Select(item => string.Format("e.{0}", project.GetPropertyName(view, item))))));
lines.Add(new EmptyLine());
}
}
}
else
{
var schemas = project.Database.DbObjects.Select(item => item.Schema).Distinct().OrderBy(item => item);
if (project.Database.Tables.Count > 0)
{
lines.Add(new CommentLine(" Apply all configurations for tables"));
lines.Add(new EmptyLine());
foreach (var schema in schemas)
{
var tables = project.Database.Tables.Where(item => item.Schema == schema).ToList();
if (tables.Count == 0)
{
continue;
}
lines.Add(new CommentLine(" Schema '{0}'", schema));
lines.Add(new CodeLine("modelBuilder"));
foreach (var table in tables)
{
var existingViews = project.Database.Views.Count(item => item.Name == table.Name);
var genericTypeName = existingViews == 0 ? project.GetEntityName(table) : project.GetFullEntityName(table);
var name = existingViews == 0 ? project.GetEntityConfigurationName(table) : project.GetFullEntityConfigurationName(table);
lines.Add(new CodeLine(1, ".ApplyConfiguration(new {0}())", name));
}
lines.Add(new CodeLine(";"));
lines.Add(new EmptyLine());
}
}
if (project.Database.Views.Count > 0)
{
lines.Add(new CommentLine(" Apply all configurations for views"));
lines.Add(new EmptyLine());
foreach (var schema in schemas)
{
var views = project.Database.Views.Where(item => item.Schema == schema).ToList();
if (views.Count == 0)
{
continue;
}
lines.Add(new CommentLine(" Schema '{0}'", schema));
lines.Add(new CodeLine("modelBuilder"));
foreach (var view in views)
{
var existingTables = project.Database.Tables.Count(item => item.Name == view.Name);
var genericTypeName = existingTables == 0 ? project.GetEntityName(view) : project.GetFullEntityName(view);
var name = existingTables == 0 ? project.GetEntityConfigurationName(view) : project.GetFullEntityConfigurationName(view);
lines.Add(new CodeLine(1, ".ApplyConfiguration(new {0}())", name));
}
lines.Add(new CodeLine(";"));
lines.Add(new EmptyLine());
}
}
if (project.Database.TableFunctions.Count > 0)
{
lines.Add(new CommentLine(" Register query types for table functions"));
lines.Add(new EmptyLine());
foreach (var view in project.Database.TableFunctions)
{
lines.Add(new CodeLine("modelBuilder.Query<{0}>();", project.GetEntityResultName(view)));
}
lines.Add(new EmptyLine());
}
if (project.Database.StoredProcedures.Count > 0)
{
lines.Add(new CommentLine(" Register query types for stored procedures"));
lines.Add(new EmptyLine());
foreach (var view in project.Database.StoredProcedures)
{
lines.Add(new CodeLine("modelBuilder.Query<{0}>();", project.GetEntityResultName(view)));
}
lines.Add(new EmptyLine());
}
}
lines.Add(new CodeLine("base.OnModelCreating(modelBuilder);"));
return(new MethodDefinition
{
AccessModifier = AccessModifier.Protected,
Type = "void",
Name = "OnModelCreating",
Parameters =
{
new ParameterDefinition("ModelBuilder", "modelBuilder")
},
IsOverride = true,
Lines = lines
});
}
public static string GetEntityLayerNamespace(this EntityFrameworkCoreProject project)
=> string.Join(".", namingConvention.GetClassName(project.Name), namingConvention.GetNamespace(project.Namespaces.EntityLayer));
public static CSharpClassDefinition GetEntityTypeConfigurationClassDefinition(this EntityFrameworkCoreProject project, IView view)
{
var classDefinition = new CSharpClassDefinition();
if (project.Settings.UseMefForEntitiesMapping)
{
classDefinition.Namespaces.Add("System.Composition");
classDefinition.Attributes.Add(new MetadataAttribute("Export", "typeof(IEntityTypeConfiguration)"));
}
classDefinition.Namespaces.Add("Microsoft.EntityFrameworkCore");
classDefinition.Namespaces.AddUnique(project.GetEntityLayerNamespace(view.HasDefaultSchema() ? string.Empty : view.Schema));
classDefinition.Namespace = project.GetDataLayerConfigurationsNamespace();
classDefinition.Name = view.GetEntityTypeConfigurationName();
classDefinition.Implements.Add("IEntityTypeConfiguration");
var mapLines = new List <ILine>();
mapLines.Add(new CodeLine("modelBuilder.Entity<{0}>(builder =>", view.GetSingularName()));
mapLines.Add(new CodeLine("{"));
mapLines.Add(new CommentLine(1, " Set configuration for entity"));
if (string.IsNullOrEmpty(view.Schema))
{
mapLines.Add(new CodeLine(1, "builder.ToTable(\"{0}\");", view.Name));
}
else
{
mapLines.Add(new CodeLine(1, "builder.ToTable(\"{0}\", \"{1}\");", view.Name, view.Schema));
}
mapLines.Add(new CodeLine());
var primaryKeys = project.Database.Tables.Where(item => item.PrimaryKey != null).Select(item => item.PrimaryKey?.GetColumns(item).Select(c => c.Name).First()).ToList();
var result = view.Columns.Where(item => !item.Nullable && primaryKeys.Contains(item.Name)).ToList();
if (result.Count == 0)
{
result = view.Columns.Where(item => !item.Nullable).ToList();
}
mapLines.Add(new CommentLine(1, " Add configuration for entity's key"));
mapLines.Add(new CodeLine(1, "builder.HasKey(p => new {{ {0} }});", string.Join(", ", result.Select(item => string.Format("p.{0}", classDefinition.NamingConvention.GetPropertyName(item.Name))))));
mapLines.Add(new CodeLine());
mapLines.Add(new CommentLine(1, " Set configuration for columns"));
for (var i = 0; i < view.Columns.Count; i++)
{
var column = view.Columns[i];
var lines = new List <string>()
{
string.Format("builder.Property(p => p.{0})", column.GetPropertyName())
};
if (string.Compare(column.Name, column.GetPropertyName()) != 0)
{
lines.Add(string.Format("HasColumnName(\"{0}\")", column.Name));
}
if (column.IsString())
{
lines.Add(column.Length == 0 ? string.Format("HasColumnType(\"{0}(max)\")", column.Type) : string.Format("HasColumnType(\"{0}({1})\")", column.Type, column.Length));
}
else if (column.IsDecimal())
{
lines.Add(string.Format("HasColumnType(\"{0}({1}, {2})\")", column.Type, column.Prec, column.Scale));
}
else if (column.IsDouble() || column.IsSingle())
{
lines.Add(string.Format("HasColumnType(\"{0}({1})\")", column.Type, column.Prec));
}
else
{
lines.Add(string.Format("HasColumnType(\"{0}\")", column.Type));
}
mapLines.Add(new CodeLine(1, "{0};", string.Join(".", lines)));
}
mapLines.Add(new CodeLine("});"));
var mapMethod = new MethodDefinition("void", "Configure", new ParameterDefinition("ModelBuilder", "modelBuilder"))
{
Lines = mapLines
};
classDefinition.Methods.Add(mapMethod);
return(classDefinition);
}
public static RepositoryExtensionsClassDefinition GetRepositoryExtensionsClassDefinition(this EntityFrameworkCoreProject project)
{
var definition = new RepositoryExtensionsClassDefinition
{
Namespaces =
{
"System",
"System.Linq",
project.GetDataLayerNamespace(),
project.GetEntityLayerNamespace()
},
Namespace = project.GetDataLayerRepositoriesNamespace(),
AccessModifier = AccessModifier.Public,
IsStatic = true,
Name = "RepositoryExtensions"
};
definition.Methods.Add(new MethodDefinition("IQueryable<TEntity>", "Paging", new ParameterDefinition(project.GetDbContextName(project.Database), "dbContext"), new ParameterDefinition("int", "pageSize", "0"), new ParameterDefinition("int", "pageNumber", "0"))
{
AccessModifier = AccessModifier.Public,
IsExtension = true,
IsStatic = true,
GenericTypes =
{
new GenericTypeDefinition
{
Name = "TEntity",
Constraint = "TEntity : class"
}
},
Lines =
{
new CodeLine("var query = dbContext.Set<TEntity>().AsQueryable();"),
new CodeLine(),
new CodeLine("return pageSize > 0 && pageNumber > 0 ? query.Skip((pageNumber - 1) * pageSize).Take(pageSize) : query;")
}
});
definition.Methods.Add(new MethodDefinition("IQueryable<TModel>", "Paging", new ParameterDefinition("IQueryable<TModel>", "query"), new ParameterDefinition("int", "pageSize", "0"), new ParameterDefinition("int", "pageNumber", "0"))
{
AccessModifier = AccessModifier.Public,
IsExtension = true,
IsStatic = true,
GenericTypes =
{
new GenericTypeDefinition
{
Name = "TModel",
Constraint = "TModel : class"
}
},
Lines =
{
new CodeLine("return pageSize > 0 && pageNumber > 0 ? query.Skip((pageNumber - 1) * pageSize).Take(pageSize) : query;")
}
});
return(definition);
}
public static EntityClassDefinition GetEntityClassDefinition(this EntityFrameworkCoreProject project, ITable table)
{
var definition = new EntityClassDefinition
{
Namespaces =
{
"System"
},
Namespace = project.Database.HasDefaultSchema(table) ? project.GetEntityLayerNamespace() : project.GetEntityLayerNamespace(table.Schema),
AccessModifier = AccessModifier.Public,
Name = project.GetEntityName(table),
IsPartial = true,
Constructors =
{
new ClassConstructorDefinition(AccessModifier.Public)
},
DbObject = table
};
if (!string.IsNullOrEmpty(table.Description))
{
definition.Documentation.Summary = table.Description;
}
var projectSelection = project.GetSelection(table);
if (projectSelection.Settings.UseDataAnnotations)
{
definition.Namespaces.Add("System.ComponentModel.DataAnnotations");
definition.Namespaces.Add("System.ComponentModel.DataAnnotations.Schema");
}
if (projectSelection.Settings.EnableDataBindings)
{
definition.Namespaces.Add("System.ComponentModel");
definition.Implements.Add("INotifyPropertyChanged");
definition.Events.Add(new EventDefinition("PropertyChangedEventHandler", "PropertyChanged"));
}
if (table.PrimaryKey != null)
{
var constructor = new ClassConstructorDefinition
{
AccessModifier = AccessModifier.Public
};
foreach (var key in table.GetColumnsFromConstraint(table.PrimaryKey))
{
var col = (Column)key;
var propertyType = project.Database.ResolveDatabaseType(col);
constructor.Parameters.Add(new ParameterDefinition(propertyType, project.GetParameterName(col)));
constructor.Lines.Add(new CodeLine("{0} = {1};", project.GetPropertyName(key.Name), project.GetParameterName(col)));
}
definition.Constructors.Add(constructor);
}
var columns = table.Columns;
foreach (var column in columns)
{
var propertyType = project.Database.ResolveDatabaseType(column);
if (projectSelection.Settings.EnableDataBindings)
{
definition.AddViewModelProperty(propertyType, project.GetPropertyName(table, column));
}
else
{
if (projectSelection.Settings.BackingFields.Contains(table.GetFullColumnName(column)))
{
definition.AddPropertyWithField(propertyType, project.GetPropertyName(table, column));
}
else if (projectSelection.Settings.UseAutomaticPropertiesForEntities)
{
definition.Properties.Add(new PropertyDefinition
{
AccessModifier = AccessModifier.Public,
Type = propertyType,
Name = project.GetPropertyName(table, column),
IsAutomatic = true
});
}
else
{
definition.AddPropertyWithField(propertyType, project.GetPropertyName(table, column));
}
}
}
if (projectSelection.Settings.AuditEntity == null)
{
definition.Implements.Add(projectSelection.Settings.EntityInterfaceName);
}
else
{
var count = 0;
foreach (var column in columns)
{
if (projectSelection.Settings.AuditEntity.Names.Contains(column.Name))
{
count += 1;
}
}
if (count == projectSelection.Settings.AuditEntity.Names.Count())
{
definition.Implements.Add("IAuditEntity");
}
else
{
definition.Implements.Add("IEntity");
}
}
if (projectSelection.Settings.SimplifyDataTypes)
{
definition.SimplifyDataTypes();
}
if (projectSelection.Settings.DeclareNavigationProperties)
{
foreach (var foreignKey in table.ForeignKeys)
{
var foreignTable = project.Database.FindTable(foreignKey.References);
if (foreignTable == null)
{
continue;
}
if (definition.Namespace != project.GetEntityLayerNamespace(foreignTable.Schema))
{
definition.Namespaces
.AddUnique(project.Database.HasDefaultSchema(foreignTable) ? project.GetEntityLayerNamespace() : project.GetEntityLayerNamespace(foreignTable.Schema));
}
var fkProperty = foreignKey.GetParentNavigationProperty(foreignTable, project);
if (!definition.Properties.Any(item => item.Name == fkProperty.Name))
{
definition.Properties.Add(fkProperty);
}
}
foreach (var child in project.Database.Tables)
{
foreach (var foreignKey in child.ForeignKeys)
{
if (foreignKey.References.EndsWith(table.FullName))
{
definition.Namespaces
.AddUnique(projectSelection.Settings.NavigationPropertyEnumerableNamespace);
if (definition.Namespace != project.GetEntityLayerNamespace(child.Schema))
{
definition.Namespaces
.AddUnique(project.Database.HasDefaultSchema(child) ? project.GetEntityLayerNamespace() : project.GetEntityLayerNamespace(child.Schema));
}
var navigationProperty = project.GetChildNavigationProperty(projectSelection, child, foreignKey);
if (!definition.Properties.Any(item => item.Name == navigationProperty.Name))
{
definition.Properties.Add(navigationProperty);
}
}
}
}
}
return(definition);
}
public static CSharpClassDefinition GetEntityTypeConfigurationClassDefinition(this EntityFrameworkCoreProject project, ITable table)
{
var classDefinition = new CSharpClassDefinition();
if (project.Settings.UseMefForEntitiesMapping)
{
classDefinition.Namespaces.Add("System.Composition");
classDefinition.Attributes.Add(new MetadataAttribute("Export", "typeof(IEntityTypeConfiguration)"));
}
classDefinition.Namespaces.Add("Microsoft.EntityFrameworkCore");
classDefinition.Namespaces.AddUnique(project.GetEntityLayerNamespace(table.HasDefaultSchema() ? string.Empty : table.Schema));
classDefinition.Namespace = project.GetDataLayerConfigurationsNamespace();
classDefinition.Name = table.GetEntityTypeConfigurationName();
classDefinition.Implements.Add("IEntityTypeConfiguration");
var mapLines = new List <ILine>();
mapLines.Add(new CodeLine("modelBuilder.Entity<{0}>(builder =>", table.GetSingularName()));
mapLines.Add(new CodeLine("{"));
mapLines.Add(new CommentLine(1, " Set configuration for entity"));
if (string.IsNullOrEmpty(table.Schema))
{
mapLines.Add(new CodeLine(1, "builder.ToTable(\"{0}\");", table.Name));
}
else
{
mapLines.Add(new CodeLine(1, "builder.ToTable(\"{0}\", \"{1}\");", table.Name, table.Schema));
}
mapLines.Add(new CodeLine());
var columns = default(List <Column>);
if (table.PrimaryKey == null || table.PrimaryKey.Key.Count == 0)
{
mapLines.Add(LineHelper.Warning("Add configuration for entity's key"));
mapLines.Add(new CodeLine());
}
else
{
mapLines.Add(new CommentLine(1, " Set key for entity"));
if (table.PrimaryKey.Key.Count == 1)
{
mapLines.Add(new CodeLine(1, "builder.HasKey(p => p.{0});", classDefinition.NamingConvention.GetPropertyName(table.PrimaryKey.Key[0])));
mapLines.Add(new CodeLine());
}
else if (table.PrimaryKey.Key.Count > 1)
{
mapLines.Add(new CodeLine(1, "builder.HasKey(p => new {{ {0} }});", string.Join(", ", table.PrimaryKey.Key.Select(item => string.Format("p.{0}", classDefinition.NamingConvention.GetPropertyName(item))))));
mapLines.Add(new CodeLine());
}
}
if (table.Identity != null)
{
mapLines.Add(new CommentLine(1, " Set identity for entity (auto increment)"));
mapLines.Add(new CodeLine(1, "builder.Property(p => p.{0}).UseSqlServerIdentityColumn();", classDefinition.NamingConvention.GetPropertyName(table.Identity.Name)));
mapLines.Add(new CodeLine());
}
columns = table.Columns;
mapLines.Add(new CommentLine(1, " Set configuration for columns"));
for (var i = 0; i < columns.Count; i++)
{
var column = columns[i];
var lines = new List <string>()
{
string.Format("builder.Property(p => p.{0})", column.GetPropertyName())
};
if (string.Compare(column.Name, column.GetPropertyName()) != 0)
{
lines.Add(string.Format("HasColumnName(\"{0}\")", column.Name));
}
if (column.IsString())
{
lines.Add(column.Length == 0 ? string.Format("HasColumnType(\"{0}(max)\")", column.Type) : string.Format("HasColumnType(\"{0}({1})\")", column.Type, column.Length));
}
else if (column.IsDecimal())
{
lines.Add(string.Format("HasColumnType(\"{0}({1}, {2})\")", column.Type, column.Prec, column.Scale));
}
else if (column.IsDouble() || column.IsSingle())
{
lines.Add(string.Format("HasColumnType(\"{0}({1})\")", column.Type, column.Prec));
}
else
{
lines.Add(string.Format("HasColumnType(\"{0}\")", column.Type));
}
if (!column.Nullable)
{
lines.Add("IsRequired()");
}
mapLines.Add(new CodeLine(1, "{0};", string.Join(".", lines)));
}
mapLines.Add(new CodeLine());
for (var i = 0; i < columns.Count; i++)
{
var column = columns[i];
if (!string.IsNullOrEmpty(project.Settings.ConcurrencyToken) && string.Compare(column.Name, project.Settings.ConcurrencyToken) == 0)
{
mapLines.Add(new CommentLine(1, " Set concurrency token for entity"));
mapLines.Add(new CodeLine(1, "builder"));
mapLines.Add(new CodeLine(2, ".Property(p => p.{0})", column.GetPropertyName()));
mapLines.Add(new CodeLine(2, ".ValueGeneratedOnAddOrUpdate()"));
mapLines.Add(new CodeLine(2, ".IsConcurrencyToken();"));
mapLines.Add(new CodeLine());
}
}
if (table.Uniques.Count > 0)
{
mapLines.Add(new CommentLine(1, " Add configuration for uniques"));
foreach (var unique in table.Uniques)
{
mapLines.Add(new CodeLine(1, "builder"));
if (unique.Key.Count == 1)
{
mapLines.Add(new CodeLine(2, ".HasIndex(p => p.{0})", classDefinition.NamingConvention.GetPropertyName(unique.Key.First())));
mapLines.Add(new CodeLine(2, ".IsUnique()"));
}
else
{
mapLines.Add(new CodeLine(2, ".HasIndex(p => new {{ {0} }})", string.Join(", ", table.PrimaryKey.Key.Select(item => string.Format("p.{0}", classDefinition.NamingConvention.GetPropertyName(item))))));
mapLines.Add(new CodeLine(2, ".IsUnique()"));
}
mapLines.Add(new CodeLine(2, ".HasName(\"{0}\");", unique.ConstraintName));
mapLines.Add(new CodeLine());
}
}
if (table.ForeignKeys.Count > 0)
{
mapLines.Add(new CommentLine(1, " Add configuration for foreign keys"));
foreach (var foreignKey in table.ForeignKeys)
{
var foreignTable = project.Database.FindTableByFullName(foreignKey.References);
if (foreignTable == null)
{
continue;
}
if (foreignKey.Key.Count == 0)
{
continue;
}
else if (foreignKey.Key.Count == 1)
{
var foreignProperty = foreignKey.GetParentNavigationProperty(project, foreignTable);
mapLines.Add(new CodeLine(1, "builder"));
mapLines.Add(new CodeLine(2, ".HasOne(p => p.{0})", foreignProperty.Name));
mapLines.Add(new CodeLine(2, ".WithMany(b => b.{0})", table.GetPluralName()));
mapLines.Add(new CodeLine(2, ".HasForeignKey(p => {0})", string.Format("p.{0}", classDefinition.NamingConvention.GetPropertyName(foreignKey.Key[0]))));
mapLines.Add(new CodeLine(2, ".HasConstraintName(\"{0}\");", foreignKey.ConstraintName));
mapLines.Add(new CodeLine());
}
else
{
mapLines.Add(LineHelper.Warning(" Add logic for foreign key with multiple key"));
}
}
}
mapLines.Add(new CodeLine("});"));
var mapMethod = new MethodDefinition("void", "Configure", new ParameterDefinition("ModelBuilder", "modelBuilder"))
{
Lines = mapLines
};
classDefinition.Methods.Add(mapMethod);
return(classDefinition);
}
public static CSharpInterfaceDefinition GetEntityTypeConfigurationInterfaceDefinition(this EntityFrameworkCoreProject project)
{
var interfaceDefinition = new CSharpInterfaceDefinition();
interfaceDefinition.Namespaces.Add("Microsoft.EntityFrameworkCore");
interfaceDefinition.Namespace = project.GetDataLayerConfigurationsNamespace();
interfaceDefinition.Name = "IEntityTypeConfiguration";
interfaceDefinition.Methods.Add(new MethodDefinition("void", "Configure", new ParameterDefinition("ModelBuilder", "modelBuilder")));
return(interfaceDefinition);
}
public static CSharpInterfaceDefinition GetEntityInterfaceDefinition(this EntityFrameworkCoreProject project)
=> new CSharpInterfaceDefinition
{
Namespace = project.GetEntityLayerNamespace(),
Name = "IEntity"
};
public static string GetEntityLayerNamespace(this EntityFrameworkCoreProject project, string ns)
=> string.IsNullOrEmpty(ns) ? GetEntityLayerNamespace(project) : string.Join(".", project.Name, project.Namespaces.EntityLayer, ns);
public static RepositoryBaseClassDefinition GetRepositoryBaseClassDefinition(this EntityFrameworkCoreProject project)
{
var definition = new RepositoryBaseClassDefinition
{
Namespaces =
{
"System",
"System.Threading.Tasks",
},
Namespace = project.GetDataLayerContractsNamespace(),
AccessModifier = AccessModifier.Public,
Name = "Repository",
Fields =
{
new FieldDefinition(AccessModifier.Protected, "bool", "Disposed"),
new FieldDefinition(AccessModifier.Protected, project.GetDbContextName(project.Database), "DbContext")
},
Constructors =
{
new ClassConstructorDefinition(AccessModifier.Public, new ParameterDefinition(project.GetDbContextName(project.Database), "dbContext"))
{
Lines =
{
new CodeLine("DbContext = dbContext;")
}
}
},
Methods =
{
new MethodDefinition(AccessModifier.Public, "void", "Dispose")
{
Lines =
{
new CodeLine("if (!Disposed)"),
new CodeLine("{"),
new CodeLine(1, "DbContext?.Dispose();"),
new CodeLine(),
new CodeLine(1, "Disposed = true;"),
new CodeLine("}")
}
},
GetAddMethod(project),
GetUpdateMethod(project),
GetRemoveMethod(project),
new MethodDefinition(AccessModifier.Public, "int", "CommitChanges")
{
Lines =
{
new CodeLine("return DbContext.SaveChanges();")
}
},
new MethodDefinition(AccessModifier.Public, "Task<int>", "CommitChangesAsync")
{
Lines =
{
new CodeLine("return DbContext.SaveChangesAsync();")
}
}
}
};
var selection = project.GlobalSelection();
if (selection.Settings.AuditEntity != null)
{
definition.Namespaces.Add(project.GetEntityLayerNamespace());
}
return(definition);
}
public static AuditEntityInterfaceDefinition GetAuditEntityInterfaceDefinition(this EntityFrameworkCoreProject project)
=> new AuditEntityInterfaceDefinition
{
Namespaces =
{
"System"
},
Namespace = project.GetEntityLayerNamespace(),
AccessModifier = AccessModifier.Public,
Name = "IAuditEntity",
Implements =
{
"IEntity"
},
Properties =
{
new PropertyDefinition("string", "CreationUser"),
new PropertyDefinition("DateTime?", "CreationDateTime"),
new PropertyDefinition("string", "LastUpdateUser"),
new PropertyDefinition("DateTime?", "LastUpdateDateTime")
}
};
public static DbContextClassDefinition GetDbContextClassDefinition(this EntityFrameworkCoreProject project, ProjectSelection <EntityFrameworkCoreProjectSettings> projectSelection)
{
var definition = new DbContextClassDefinition
{
Namespaces =
{
"System",
"Microsoft.EntityFrameworkCore",
project.GetEntityLayerNamespace()
},
Namespace = project.GetDataLayerNamespace(),
AccessModifier = AccessModifier.Public,
Name = project.GetDbContextName(project.Database),
BaseClass = "DbContext"
};
if (!projectSelection.Settings.UseDataAnnotations)
{
definition.Namespaces.Add(project.GetDataLayerConfigurationsNamespace());
}
definition.Constructors.Add(new ClassConstructorDefinition
{
AccessModifier = AccessModifier.Public,
Parameters =
{
new ParameterDefinition(string.Format("DbContextOptions<{0}>", definition.Name), "options")
},
Invocation = "base(options)"
});
definition.Methods.Add(GetOnModelCreatingMethod(project));
foreach (var table in project.Database.Tables)
{
if (!project.Database.HasDefaultSchema(table))
{
definition.Namespaces.AddUnique(project.GetEntityLayerNamespace(table.Schema));
}
var existingViews = project.Database.Views.Count(item => item.Name == table.Name);
var genericTypeName = existingViews == 0 ? project.GetEntityName(table) : project.GetFullEntityName(table);
var name = existingViews == 0 ? project.GetDbSetPropertyName(table) : project.GetFullDbSetPropertyName(table);
definition.Properties.Add(
new PropertyDefinition
{
AccessModifier = AccessModifier.Public,
Type = string.Format("DbSet<{0}>", genericTypeName),
Name = name,
IsAutomatic = true
}
);
}
foreach (var view in project.Database.Views)
{
if (!project.Database.HasDefaultSchema(view))
{
definition.Namespaces.AddUnique(project.GetEntityLayerNamespace(view.Schema));
}
var existingTables = project.Database.Tables.Count(item => item.Name == view.Name);
var genericTypeName = existingTables == 0 ? project.GetEntityName(view) : project.GetFullEntityName(view);
var name = existingTables == 0 ? project.GetDbSetPropertyName(view) : project.GetFullDbSetPropertyName(view);
definition.Properties.Add(
new PropertyDefinition
{
AccessModifier = AccessModifier.Public,
Type = string.Format("DbSet<{0}>", genericTypeName),
Name = name,
IsAutomatic = true
}
);
}
foreach (var table in project.Database.Tables)
{
if (!projectSelection.Settings.UseDataAnnotations && !project.Database.HasDefaultSchema(table))
{
definition.Namespaces.AddUnique(project.GetDataLayerConfigurationsNamespace(table.Schema));
}
}
foreach (var view in project.Database.Views)
{
if (!projectSelection.Settings.UseDataAnnotations && !project.Database.HasDefaultSchema(view))
{
definition.Namespaces.AddUnique(project.GetDataLayerConfigurationsNamespace(view.Schema));
}
}
foreach (var scalarFunction in project.Database.ScalarFunctions)
{
var parameterType = string.Empty;
if (project.Database.HasTypeMappedToClr(scalarFunction.Parameters[0]))
{
var clrType = project.Database.GetClrMapForType(scalarFunction.Parameters[0]);
parameterType = clrType.AllowClrNullable ? string.Format("{0}?", clrType.GetClrType().Name) : clrType.GetClrType().Name;
}
else
{
parameterType = "object";
}
var method = new MethodDefinition
{
Attributes =
{
new MetadataAttribute("DbFunction")
{
Sets =
{
new MetadataAttributeSet("FunctionName", string.Format("\"{0}\"", scalarFunction.Name)),
new MetadataAttributeSet("Schema", string.Format("\"{0}\"", scalarFunction.Schema))
}
}
},
IsStatic = true,
Type = parameterType,
AccessModifier = AccessModifier.Public,
Name = project.GetScalarFunctionMethodName(scalarFunction),
Lines =
{
new CodeLine("throw new Exception();")
}
};
var parameters = scalarFunction.Parameters.Where(item => !string.IsNullOrEmpty(item.Name)).ToList();
foreach (var parameter in parameters)
{
var propertyType = project.Database.ResolveDatabaseType(parameter);
method.Parameters.Add(new ParameterDefinition(parameterType, project.GetPropertyName(parameter)));
}
definition.Methods.Add(method);
}
if (projectSelection.Settings.SimplifyDataTypes)
{
definition.SimplifyDataTypes();
}
return(definition);
}
public static EntityClassDefinition GetEntityClassDefinition(this EntityFrameworkCoreProject project, ITable table)
{
var definition = new EntityClassDefinition
{
Namespaces =
{
"System"
},
Namespace = project.Database.HasDefaultSchema(table) ? project.GetEntityLayerNamespace() : project.GetEntityLayerNamespace(table.Schema),
Name = project.GetEntityName(table),
IsPartial = true,
Constructors =
{
new ClassConstructorDefinition()
}
};
if (!string.IsNullOrEmpty(table.Description))
{
definition.Documentation.Summary = table.Description;
}
var projectSelection = project.GetSelection(table);
if (projectSelection.Settings.UseDataAnnotations)
{
definition.Namespaces.Add("System.ComponentModel.DataAnnotations");
definition.Namespaces.Add("System.ComponentModel.DataAnnotations.Schema");
}
if (projectSelection.Settings.EnableDataBindings)
{
definition.Namespaces.Add("System.ComponentModel");
definition.Implements.Add("INotifyPropertyChanged");
definition.Events.Add(new EventDefinition("PropertyChangedEventHandler", "PropertyChanged"));
}
if (table.PrimaryKey != null)
{
var constructor = new ClassConstructorDefinition();
foreach (var key in table.GetColumnsFromConstraint(table.PrimaryKey))
{
var propertyType = string.Empty;
if (project.Database.HasTypeMappedToClr(key))
{
var clrType = project.Database.GetClrMapForType(key);
propertyType = clrType.AllowClrNullable ? string.Format("{0}?", clrType.GetClrType().Name) : clrType.GetClrType().Name;
}
else
{
propertyType = "object";
}
constructor.Parameters.Add(new ParameterDefinition(propertyType, project.GetParameterName(key)));
constructor.Lines.Add(new CodeLine("{0} = {1};", key.GetPropertyName(), project.GetParameterName(key)));
}
definition.Constructors.Add(constructor);
}
var columns = table.Columns;
foreach (var column in columns)
{
var propertyType = string.Empty;
if (project.Database.HasTypeMappedToClr(column))
{
var clrType = project.Database.GetClrMapForType(column);
propertyType = clrType.AllowClrNullable ? string.Format("{0}?", clrType.GetClrType().Name) : clrType.GetClrType().Name;
}
else
{
propertyType = "object";
}
if (projectSelection.Settings.EnableDataBindings)
{
definition.AddViewModelProperty(propertyType, column.HasSameNameEnclosingType(table) ? column.GetNameForEnclosing() : table.GetPropertyNameHack(column));
}
else
{
if (projectSelection.Settings.BackingFields.Contains(table.GetFullColumnName(column)))
{
definition.AddPropertyWithField(propertyType, column.HasSameNameEnclosingType(table) ? column.GetNameForEnclosing() : table.GetPropertyNameHack(column));
}
else if (projectSelection.Settings.UseAutomaticPropertiesForEntities)
{
definition.Properties.Add(new PropertyDefinition(propertyType, column.HasSameNameEnclosingType(table) ? column.GetNameForEnclosing() : table.GetPropertyNameHack(column)));
}
else
{
definition.AddPropertyWithField(propertyType, column.HasSameNameEnclosingType(table) ? column.GetNameForEnclosing() : table.GetPropertyNameHack(column));
}
}
}
if (projectSelection.Settings.AuditEntity == null)
{
definition.Implements.Add(projectSelection.Settings.EntityInterfaceName);
}
else
{
var count = 0;
foreach (var column in columns)
{
if (projectSelection.Settings.AuditEntity.Names.Contains(column.Name))
{
count += 1;
}
}
if (count == projectSelection.Settings.AuditEntity.Names.Length)
{
definition.Implements.Add("IAuditEntity");
}
else
{
definition.Implements.Add("IEntity");
}
}
if (projectSelection.Settings.SimplifyDataTypes)
{
definition.SimplifyDataTypes();
}
if (projectSelection.Settings.DeclareNavigationProperties)
{
foreach (var foreignKey in table.ForeignKeys)
{
var foreignTable = project.Database.FindTable(foreignKey.References);
if (foreignTable == null)
{
continue;
}
definition.Namespaces
.AddUnique(project.Database.HasDefaultSchema(foreignTable) ? project.GetEntityLayerNamespace() : project.GetEntityLayerNamespace(foreignTable.Schema));
definition.Namespace = project.Database.HasDefaultSchema(table) ? project.GetEntityLayerNamespace() : project.GetEntityLayerNamespace(table.Schema);
var fkProperty = foreignKey.GetParentNavigationProperty(foreignTable, project);
if (definition.Properties.FirstOrDefault(item => item.Name == fkProperty.Name) == null)
{
definition.Properties.Add(fkProperty);
}
}
foreach (var child in project.Database.Tables)
{
foreach (var foreignKey in child.ForeignKeys)
{
if (foreignKey.References.EndsWith(table.FullName))
{
definition.Namespaces
.AddUnique(projectSelection.Settings.NavigationPropertyEnumerableNamespace);
definition.Namespaces
.AddUnique(project.Database.HasDefaultSchema(child) ? project.GetEntityLayerNamespace() : project.GetEntityLayerNamespace(child.Schema));
var navigationProperty = project.GetChildNavigationProperty(projectSelection, child, foreignKey);
if (definition.Properties.FirstOrDefault(item => item.Name == navigationProperty.Name) == null)
{
definition.Properties.Add(navigationProperty);
}
}
}
}
}
return(definition);
}
public void ProjectScaffoldingForOnlineStoreDatabaseTest()
{
// Create database factory
var databaseFactory = new SqlServerDatabaseFactory
{
DatabaseImportSettings = new DatabaseImportSettings
{
ConnectionString = "server=(local);database=OnlineStore;integrated security=yes;",
ImportTableFunctions = true,
Exclusions =
{
"dbo.sysdiagrams",
"dbo.fn_diagramobjects"
}
}
};
// Import database
var database = databaseFactory.Import();
// Create instance of Entity Framework Core project
var project = new EntityFrameworkCoreProject
{
Name = "OnlineStore.Core",
Database = database,
OutputDirectory = @"C:\Temp\CatFactory.EntityFrameworkCore\OnlineStore.Core"
};
// Apply settings for Entity Framework Core project
project.GlobalSelection(settings =>
{
settings.ForceOverwrite = true;
settings.ConcurrencyToken = "Timestamp";
settings.AuditEntity = new AuditEntity
{
CreationUserColumnName = "CreationUser",
CreationDateTimeColumnName = "CreationDateTime",
LastUpdateUserColumnName = "LastUpdateUser",
LastUpdateDateTimeColumnName = "LastUpdateDateTime"
};
});
project.Selection("Sales.OrderHeader", settings => settings.EntitiesWithDataContracts = true);
// Build features for project, group all entities by schema into a feature
project.BuildFeatures();
// Add event handlers to before and after of scaffold
project.ScaffoldingDefinition += (source, args) =>
{
// Add code to perform operations with code builder instance before to create code file
};
project.ScaffoldedDefinition += (source, args) =>
{
// Add code to perform operations after of create code file
};
// Scaffolding =^^=
project
.ScaffoldEntityLayer()
.ScaffoldDataLayer();
}
public static CSharpClassDefinition GetRepositoryBaseClassDefinition(this EntityFrameworkCoreProject project)
{
var classDefinition = new CSharpClassDefinition();
classDefinition.Namespaces.Add("System");
classDefinition.Namespaces.Add("System.Linq");
classDefinition.Namespaces.Add("System.Threading.Tasks");
classDefinition.Namespaces.Add("Microsoft.EntityFrameworkCore");
if (project.Settings.AuditEntity != null)
{
classDefinition.Namespaces.Add(project.GetEntityLayerNamespace());
}
classDefinition.Namespace = project.GetDataLayerContractsNamespace();
classDefinition.Name = "Repository";
classDefinition.Fields.Add(new FieldDefinition(AccessModifier.Protected, "Boolean", "Disposed"));
classDefinition.Fields.Add(new FieldDefinition(AccessModifier.Protected, project.Database.GetDbContextName(), "DbContext"));
classDefinition.Constructors.Add(new ClassConstructorDefinition(new ParameterDefinition(project.Database.GetDbContextName(), "dbContext"))
{
Lines = new List <ILine>()
{
new CodeLine("DbContext = dbContext;")
}
});
classDefinition.Methods.Add(new MethodDefinition("void", "Dispose")
{
Lines = new List <ILine>
{
new CodeLine("if (!Disposed)"),
new CodeLine("{"),
new CodeLine(1, "DbContext?.Dispose();"),
new CodeLine(),
new CodeLine(1, "Disposed = true;"),
new CodeLine("}")
}
});
classDefinition.Methods.Add(GetAddMethod(project));
classDefinition.Methods.Add(GetUpdateMethod(project));
classDefinition.Methods.Add(GetRemoveMethod(project));
classDefinition.Methods.Add(new MethodDefinition("Int32", "CommitChanges")
{
Lines = new List <ILine>
{
new CodeLine("return DbContext.SaveChanges();")
}
});
classDefinition.Methods.Add(new MethodDefinition("Task<Int32>", "CommitChangesAsync")
{
Lines = new List <ILine>
{
new CodeLine("return DbContext.SaveChangesAsync();")
}
});
return(classDefinition);
}
