internal static EntityStoreSchemaFilterEffect GetEffectViaFilter(
this EntityStoreSchemaFilterEntry entryToTest, IEnumerable <EntityStoreSchemaFilterEntry> filterEntries)
{
var effect = EntityStoreSchemaFilterEffect.Exclude;
// Look for the all filter for specific type of object; this includes the 'All' types filter
foreach (var entry in filterEntries.Where(e => e.Name == "%" && (e.Types & entryToTest.Types) == entryToTest.Types))
{
effect = entry.Effect;
break;
}
// Look for the specific type of object
foreach (var entry in filterEntries.Where(
e =>
e.Catalog.Equals(entryToTest.Catalog ?? String.Empty, StringComparison.CurrentCulture) &&
e.Schema.Equals(entryToTest.Schema ?? String.Empty, StringComparison.CurrentCulture) &&
e.Name.Equals(entryToTest.Name ?? String.Empty, StringComparison.CurrentCulture)))
{
effect = entry.Effect;
break;
}
return(effect);
}
private void SetStoreMetadataFilters()
{
GetStoreSchemas(Settings).Each(s =>
{
var effect = s == Settings.StoreSchemaNamespace ? EntityStoreSchemaFilterEffect.Allow : EntityStoreSchemaFilterEffect.Exclude;
_storeMetadataFilters[s] = new EntityStoreSchemaFilterEntry(null, s, null, EntityStoreSchemaFilterObjectTypes.Table, effect);
});
}
private EntityStoreSchemaFilterEntry IgnoreTable(string tableName)
{
var filter = new EntityStoreSchemaFilterEntry(
null,
null,
tableName,
EntityStoreSchemaFilterObjectTypes.Table,
EntityStoreSchemaFilterEffect.Exclude);
return(filter);
}
private static void EnsureSchemaAndLeafNode(
TreeNode rootNode,
EntityStoreSchemaFilterEntry entry,
TreeViewImage leafNodeImage)
{
Debug.Assert(rootNode != null, "rootNode must be non-null");
Debug.Assert(entry != null, "entry must be non-null");
var dbObj = DatabaseObject.CreateFromEntityStoreSchemaFilterEntry(entry, null);
EnsureSchemaAndLeafNode(rootNode, dbObj, leafNodeImage, entry);
}
internal static DatabaseObject CreateFromEntityStoreSchemaFilterEntry(EntityStoreSchemaFilterEntry entry, string defaultSchemaName)
{
var dbObj = new DatabaseObject();
dbObj.Name = entry.Name;
dbObj.Schema = entry.Schema;
// sometimes the database returns null for the schema whereas the EDM wants to
// use the EntityContainer name as the default schema name - here we allow
// overriding the schema name if it is not defined from the EntityStoreSchemaFilterEntry
if (null == dbObj.Schema)
{
dbObj.Schema = defaultSchemaName;
}
return(dbObj);
}
public static void EnsureSchemaAndLeafNode(
TreeNode rootNode,
DatabaseObject dbObj,
TreeViewImage leafNodeImage,
EntityStoreSchemaFilterEntry leafNodeTagObject)
{
Debug.Assert(rootNode != null, "rootNode must be non-null");
if (rootNode == null)
{
return;
}
// find or create schema node
var schemaName = (dbObj.Schema ?? Resources.SelectTablesPage_NullSchemaDisplayName);
var schemaNode = FindOrCreateTreeSchemaNode(rootNode, schemaName, TreeViewImage.DbDatabaseSchemaImage);
Debug.Assert(schemaNode != null, "null schemaNode for rootNode with label " + rootNode.Name + ", schemaName " + schemaName);
if (schemaNode != null)
{
// now add child node to schema node
var detailNode = CreateTreeNode(dbObj.Name, false, leafNodeTagObject, dbObj.Name, leafNodeImage, null);
schemaNode.Nodes.Add(detailNode);
}
}
// internal to allow unit testing
internal static StringBuilder AppendFilterEntry(
StringBuilder segment, string alias, EntityStoreSchemaFilterEntry entry, ParameterCollectionBuilder parameters)
{
Debug.Assert(segment != null, "segment != null");
Debug.Assert(alias != null, "alias != null");
Debug.Assert(entry != null, "entry != null");
Debug.Assert(parameters != null, "parameters != null");
var filterText = new StringBuilder();
AppendComparison(filterText, alias, "CatalogName", entry.Catalog, parameters);
AppendComparison(filterText, alias, "SchemaName", entry.Schema, parameters);
AppendComparison(
filterText, alias, "Name",
entry.Catalog == null && entry.Schema == null && entry.Name == null ? "%" : entry.Name,
parameters);
segment
.AppendIfNotEmpty(" OR ")
.Append("(")
.Append(filterText)
.Append(")");
return(segment);
}
// End Added ErikEJ
#region the functions that actually do the interesting things
private static void ModelGen(
string connectionString, string provider, string modelName, Version version, bool includeForeignKeys, bool pluralize, List <string> tables)
{
IList <EdmSchemaError> ssdlErrors = null;
IList <EdmSchemaError> csdlAndMslErrors = null;
// generate the SSDL
string ssdlNamespace = modelName + "Model.Store";
EntityStoreSchemaGenerator essg =
new EntityStoreSchemaGenerator(
provider, connectionString, ssdlNamespace);
essg.GenerateForeignKeyProperties = includeForeignKeys;
//ErikEJ Filter selected tables
var filters = new List <EntityStoreSchemaFilterEntry>();
foreach (var table in tables)
{
var entry = new EntityStoreSchemaFilterEntry(null, null, table);
filters.Add(entry);
}
ssdlErrors = essg.GenerateStoreMetadata(filters, version);
// detect if there are errors or only warnings from ssdl generation
bool hasSsdlErrors = false;
bool hasSsdlWarnings = false;
if (ssdlErrors != null)
{
foreach (EdmSchemaError e in ssdlErrors)
{
if (e.Severity == EdmSchemaErrorSeverity.Error)
{
hasSsdlErrors = true;
}
else if (e.Severity == EdmSchemaErrorSeverity.Warning)
{
hasSsdlWarnings = true;
}
}
}
// write out errors & warnings
if (hasSsdlErrors && hasSsdlWarnings)
{
//System.Console.WriteLine("Errors occurred during generation:");
WriteErrors(ssdlErrors);
}
// if there were errors abort. Continue if there were only warnings
if (hasSsdlErrors)
{
return;
}
// write the SSDL to a string
using (StringWriter ssdl = new StringWriter())
{
XmlWriter ssdlxw = XmlWriter.Create(ssdl);
essg.WriteStoreSchema(ssdlxw);
ssdlxw.Flush();
// generate the CSDL
string csdlNamespace = modelName + "Model";
string csdlEntityContainerName = modelName + "Entities";
EntityModelSchemaGenerator emsg =
new EntityModelSchemaGenerator(
essg.EntityContainer, csdlNamespace, csdlEntityContainerName);
emsg.GenerateForeignKeyProperties = includeForeignKeys;
// Begin Added ErikEJ
if (pluralize)
{
emsg.PluralizationService = System.Data.Entity.Design.PluralizationServices.PluralizationService.CreateService(new System.Globalization.CultureInfo("en-US"));
}
// End Added ErikEJ
csdlAndMslErrors = emsg.GenerateMetadata(version);
// detect if there are errors or only warnings from csdl/msl generation
bool hasCsdlErrors = false;
bool hasCsdlWarnings = false;
if (csdlAndMslErrors != null)
{
foreach (EdmSchemaError e in csdlAndMslErrors)
{
if (e.Severity == EdmSchemaErrorSeverity.Error)
{
hasCsdlErrors = true;
}
else if (e.Severity == EdmSchemaErrorSeverity.Warning)
{
hasCsdlWarnings = true;
}
}
}
// write out errors & warnings
if (hasCsdlErrors || hasCsdlWarnings)
{
//System.Console.WriteLine("Errors occurred during generation:");
WriteErrors(csdlAndMslErrors);
}
// if there were errors, abort. Don't abort if there were only warnigns.
if (hasCsdlErrors)
{
return;
}
// write CSDL to a string
using (StringWriter csdl = new StringWriter())
{
XmlWriter csdlxw = XmlWriter.Create(csdl);
emsg.WriteModelSchema(csdlxw);
csdlxw.Flush();
// write MSL to a string
using (StringWriter msl = new StringWriter())
{
XmlWriter mslxw = XmlWriter.Create(msl);
emsg.WriteStorageMapping(mslxw);
mslxw.Flush();
// write csdl, ssdl & msl to the EDMX file
ToEdmx(
csdl.ToString(), ssdl.ToString(), msl.ToString(), new FileInfo(
modelName + ".edmx"), includeForeignKeys, pluralize);
}
}
}
}
private static void AddFilterEntry(EntityCommand command, StringBuilder segment, string alias, EntityStoreSchemaFilterEntry entry)
{
StringBuilder filterText = new StringBuilder();
AddComparison(command, filterText, alias, "CatalogName", entry.Catalog);
AddComparison(command, filterText, alias, "SchemaName", entry.Schema);
string name = entry.Name;
bool allNull = (entry.Catalog == null && entry.Schema == null && entry.Name == null);
if (allNull)
{
name = "%";
}
AddComparison(command, filterText, alias, "Name", name);
if (segment.Length != 0)
{
segment.Append(" OR ");
}
segment.Append("(");
segment.Append(filterText);
segment.Append(")");
}
private static void AddFilterEntry(EntityCommand command, StringBuilder segment, string alias, EntityStoreSchemaFilterEntry entry)
{
StringBuilder filterText = new StringBuilder();
AddComparison(command, filterText, alias, "CatalogName", entry.Catalog);
AddComparison(command, filterText, alias, "SchemaName", entry.Schema);
string name = entry.Name;
bool allNull = (entry.Catalog == null && entry.Schema == null && entry.Name == null);
if (allNull)
{
name = "%";
}
AddComparison(command, filterText, alias, "Name", name);
if (segment.Length != 0)
{
segment.Append(" OR ");
}
segment.Append("(");
segment.Append(filterText);
segment.Append(")");
}
// internal to allow unit testing
internal static StringBuilder AppendFilterEntry(
StringBuilder segment, string alias, EntityStoreSchemaFilterEntry entry, EntityParameterCollection parameters)
{
Debug.Assert(segment != null, "segment != null");
Debug.Assert(alias != null, "alias != null");
Debug.Assert(entry != null, "entry != null");
Debug.Assert(parameters != null, "parameters != null");
var filterText = new StringBuilder();
AppendComparison(filterText, alias, "CatalogName", entry.Catalog, parameters);
AppendComparison(filterText, alias, "SchemaName", entry.Schema, parameters);
AppendComparison(
filterText, alias, "Name",
entry.Catalog == null && entry.Schema == null && entry.Name == null ? "%" : entry.Name,
parameters);
segment
.AppendIfNotEmpty(" OR ")
.Append("(")
.Append(filterText)
.Append(")");
return segment;
}
public IEnumerable <KeyValuePair <string, string> > generate(string connectionString, string projectName, string @namespace, DatabaseSetting dbSetting)
{
try
{
DatabaseManager dbManager = new DatabaseManager(connectionString, dbSetting);
if (!dbManager.connect())
{
return(null);
}
var schemaFilterEntryBag = new SchemaFilterEntryBag();
var databaseTables = new ArrayList();
databaseTables = dbManager.GetDatabaseTables();
if (databaseTables.Count != 0)
{
for (var i = 0; i < databaseTables.Count; i++)
{
var tableItem = (Tuple <string, string, string>)(databaseTables[i]);
var item = new EntityStoreSchemaFilterEntry(tableItem.Item1,
tableItem.Item2, tableItem.Item3, EntityStoreSchemaFilterObjectTypes.Table,
EntityStoreSchemaFilterEffect.Allow);
schemaFilterEntryBag.IncludedTableEntries.Add(item);
}
}
var databaseViews = new ArrayList();
databaseViews = dbManager.GetDatabaseViews();
if (databaseViews.Count != 0)
{
for (var i = 0; i < databaseViews.Count; i++)
{
var viewItem = (Tuple <string, string, string>)(databaseViews[i]);
var item = new EntityStoreSchemaFilterEntry(viewItem.Item1,
viewItem.Item2, viewItem.Item3, EntityStoreSchemaFilterObjectTypes.View,
EntityStoreSchemaFilterEffect.Allow);
schemaFilterEntryBag.IncludedViewEntries.Add(item);
}
}
var modelBuilderSettings = new ModelBuilderSettings();
modelBuilderSettings._designTimeConnectionString = connectionString;
modelBuilderSettings._designTimeProviderInvariantName =
dbSetting.ProviderInvariantName;
modelBuilderSettings._runtimeProviderInvariantName =
dbSetting.ProviderInvariantName;
modelBuilderSettings.UsePluralizationService = true;
modelBuilderSettings.IncludeForeignKeysInModel = true;
modelBuilderSettings.DatabaseObjectFilters =
schemaFilterEntryBag.CollapseAndOptimize(SchemaFilterPolicy.GetByValEdmxPolicy());
modelBuilderSettings.ModelBuilderEngine = new CodeFirstModelBuilderEngine();
// The latest EntityFramework version
modelBuilderSettings.TargetSchemaVersion = new Version(3, 0, 0, 0);
// Get the providerManifestTokern
IDbDependencyResolver resolver = Microsoft.Data.Entity.Design.VersioningFacade.DependencyResolver.Instance;
var providerServices =
resolver.GetService <System.Data.Entity.Core.Common.DbProviderServices>(dbSetting.ProviderInvariantName);
var factory = DbProviderFactories.GetFactory(dbSetting.ProviderInvariantName);
var dbconnection = factory.CreateConnection();
dbconnection.ConnectionString = connectionString;
Debug.Assert(providerServices != null, "Trying to get unregistered provider.");
modelBuilderSettings.ProviderManifestToken = providerServices.GetProviderManifestToken(dbconnection);
// the function provided by EntityFramework to generate model from a database
var mbe = modelBuilderSettings.ModelBuilderEngine;
mbe.GenerateModel(modelBuilderSettings);
// the function provided by EntityFramework to generate code from a model
var generator = new CodeFirstModelGenerator();
var result = generator.Generate(mbe.Model, @namespace + ".Models", projectName + "DbContext", projectName);
string key = projectName + "DbContext.cs";
if (dbSetting.DBType == DatabaseType.MYSQL)
{
return(result.Where(c => !c.Key.Equals(key)).Concat(
new[] { new KeyValuePair <string, string>(key, addMySqlNamespace(result.First(c => c.Key.Equals(key)).Value)) }));
}
return(result);
}
catch (Exception e)
{
Console.WriteLine(e.Message);
return(null);
}
}
