<# // Copyright (C) Simon Hughes 2012 // v3.9.0 // If you want to submit a pull request, please modify the Generator C# project as this file // is automatically constructed from the C# Generator project during the build process. #> <#@ template debug="true" hostspecific="true" language="C#" #> <#@ include file="EF6.Utility.CS.ttinclude"#><#@ assembly name="System.Configuration" #> <#@ assembly name="System.Windows.Forms" #> <#@ import namespace="System.Data.Entity.Infrastructure.Pluralization" #> <#@ import namespace="System" #> <#@ import namespace="System.Collections" #> <#@ import namespace="System.Collections.Generic" #> <#@ import namespace="System.ComponentModel" #> <#@ import namespace="System.Data" #> <#@ import namespace="System.Data.Common" #> <#@ import namespace="System.Data.SqlClient" #> <#@ import namespace="System.Diagnostics" #> <#@ import namespace="System.Globalization" #> <#@ import namespace="System.IO" #> <#@ import namespace="System.Linq" #> <#@ import namespace="System.Reflection" #> <#@ import namespace="System.Security" #> <#@ import namespace="System.Security.Cryptography" #> <#@ import namespace="System.Text" #> <#@ import namespace="System.Text.RegularExpressions" #> <#@ import namespace="System.Threading" #> <#@ import namespace="EnvDTE" #> <#@ import namespace="Microsoft.VisualStudio.TextTemplating" #> <#@ output extension=".cs" encoding="utf-8" #> <# // WriteLine("// T4 framework version = " + AppDomain.CurrentDomain.SetupInformation.TargetFrameworkName); var DefaultNamespace = new CodeGenerationTools(this).VsNamespaceSuggestion() ?? "DebugMode"; Settings.Root = Host.ResolvePath(string.Empty); Settings.TemplateFile = Path.GetFileNameWithoutExtension(DynamicTextTransformation.Create(this).Host.TemplateFile); // System.Diagnostics.Debugger.Launch(); #><#+ public static class Settings { // Main settings ********************************************************************************************************************** // The following entries are the only required settings. public static DatabaseType DatabaseType = DatabaseType.SqlServer; // SqlServer, SqlCe, SQLite, PostgreSQL. Coming next: MySql, Oracle public static TemplateType TemplateType = TemplateType.EfCore8; // EfCore8, EfCore7, EfCore6, EfCore3, Ef6, FileBasedCore3-8. FileBased specify folder using Settings.TemplateFolder public static GeneratorType GeneratorType = GeneratorType.EfCore; // EfCore, Ef6, Custom. Custom edit GeneratorCustom class to provide your own implementation public static ForeignKeyNamingStrategy ForeignKeyNamingStrategy = ForeignKeyNamingStrategy.Legacy; // Please use Legacy for now, Latest (not yet ready) public static bool UseMappingTables = false; // Can only be set to true for EF6. If true, mapping will be used and no mapping tables will be generated. If false, all tables will be generated. public static FileManagerType FileManagerType = FileManagerType.EfCore; // .NET Core project = EfCore; .NET 4.x project = VisualStudio; No output (testing only) = Null public static string ConnectionString = ""; // This is used by the generator to reverse engineer your database public static string ConnectionStringName = "MyDbContext"; // ConnectionString key as specified in your app.config/web.config/appsettings.json public static string DbContextName = "MyDbContext"; // Class name for the DbContext to be generated. public static bool GenerateSeparateFiles = false; public static string Namespace = typeof(Settings).Namespace; // Override the default namespace here. Example: Namespace = "CustomNamespace"; public static string TemplateFolder = ""; // Only used if Settings.TemplateType = TemplateType.FileBased. Specify folder name where the mustache folders can be found. Please read https://github.com/sjh37/EntityFramework-Reverse-POCO-Code-First-Generator/wiki/Custom-file-based-templates public static bool AddUnitTestingDbContext = true; // Will add a FakeDbContext and FakeDbSet for easy unit testing // Elements to generate *************************************************************************************************************** // Add the elements that should be generated when the template is executed. // Multiple projects can now be used that separate the different concerns. public static Elements ElementsToGenerate = Elements.Poco | Elements.Context | Elements.Interface | Elements.PocoConfiguration | Elements.Enum; // Generate files in sub-folders ****************************************************************************************************** // Only activated if Settings.FileManagerType = FileManagerType.EfCore && Settings.GenerateSeparateFiles = true public static string ContextFolder = ""; // Sub-folder you would like your DbContext to be added to. e.g. @"Data" public static string InterfaceFolder = ""; // Sub-folder you would like your Interface to be added to. e.g. @"Data\Interface" public static string PocoFolder = ""; // Sub-folder you would like your Poco's to be added to. e.g. @"Data\Entities" public static string PocoConfigurationFolder = ""; // Sub-folder you would like your Configuration mappings to be added to. e.g. @"Data\Configuration" public static int CommandTimeout = 600; // SQL Command timeout in seconds. 600 is 10 minutes, 0 will wait indefinitely. Some databases can be slow retrieving schema information. public static string DbContextInterfaceBaseClasses = "IDisposable"; // Specify what the base classes are for your database context interface public static string DbContextBaseClass = "DbContext"; // Specify what the base class is for your DbContext. For ASP.NET Identity use "IdentityDbContext"; public static OnConfiguration OnConfiguration = OnConfiguration.ConnectionString; // EFCore only. Determines the code generated within DbContext.OnConfiguration(). Please read https://github.com/sjh37/EntityFramework-Reverse-POCO-Code-First-Generator/wiki/Settings.OnConfiguration public static bool AddParameterlessConstructorToDbContext = true; // If true, then DbContext will have a default (parameter-less) constructor which automatically passes in the connection string name, if false then no parameter-less constructor will be created. public static string ConfigurationClassName = "Configuration"; // Configuration, Mapping, Map, etc. This is appended to the Poco class name to configure the mappings. public static string DatabaseReaderPlugin = ""; // Eg, "c:\\Path\\YourDatabaseReader.dll,Full.Name.Of.Class.Including.Namespace". See #501. This will allow you to specify a pluggable provider for reading your database. public static string EntityClassesModifiers = "public"; // "public partial"; public static string ConfigurationClassesModifiers = "public"; // "public partial"; public static string DbContextClassModifiers = "public"; // "public partial"; public static string DbContextInterfaceModifiers = "public"; // "public partial"; public static string ResultClassModifiers = "public"; // "public partial"; public static bool UsePascalCase = true; // This will rename the generated C# tables & properties to use PascalCase. If false table & property names will be left alone. public static bool UsePascalCaseForEnumMembers = true; // This will rename the generated Enum Members to use PascalCase. If false Enum members will be left alone. public static bool UseDataAnnotations = false; // If true, will add data annotations to the poco classes. public static bool UsePropertyInitialisers = false; // Removes POCO constructor and instead uses C# 6 property initialisers to set defaults public static bool UseLazyLoading = true; // Marks all navigation properties as virtual or not, to support or disable EF Lazy Loading feature public static bool UseInheritedBaseInterfaceFunctions = false; // If true, the main DBContext interface functions will come from the DBContextInterfaceBaseClasses and not generated. If false, the functions will be generated. public static CommentsStyle IncludeComments = CommentsStyle.AtEndOfField; // Adds comments to the generated code public static CommentsStyle IncludeExtendedPropertyComments = CommentsStyle.InSummaryBlock; // Adds extended properties as comments to the generated code public static bool DisableGeographyTypes = false; // Turns off use of System.Data.Entity.Spatial.DbGeography and System.Data.Entity.Spatial.DbGeometry as OData doesn't support entities with geometry/geography types. public static string CollectionInterfaceType = "ICollection"; // = "System.Collections.Generic.List"; // Determines the declaration type of collections for the Navigation Properties. ICollection is used if not set. public static string CollectionType = "List"; // Determines the type of collection for the Navigation Properties. "ObservableCollection" for example. Add "System.Collections.ObjectModel" to AdditionalNamespaces if setting the CollectionType = "ObservableCollection". public static bool NullableShortHand = true; // true => T?, false => Nullable public static bool AddIDbContextFactory = true; // Will add a default IDbContextFactory implementation for easy dependency injection public static bool IncludeQueryTraceOn9481Flag = false; // If SqlServer 2014 appears frozen / take a long time when this file is saved, try setting this to true (you will also need elevated privileges). public static bool UsePrivateSetterForComputedColumns = true; // If the columns is computed, use a private setter. public static bool IncludeGeneratorVersionInCode = false; // If true, will include the version number of the generator in the generated code (Settings.ShowLicenseInfo must also be true). public static bool TrimCharFields = false; // EF Core option only. If true, will TrimEnd() 'char' fields when read from the database. public static bool IncludeFieldNameConstants = false; // Will include public const string {{NameHumanCase}}Field = "{{NameHumanCase}}"; in the generated POCO class. It allows you to use a constant instead of magic strings. public static bool UsePropertiesForStoredProcResultSets = false; // Stored procedure result set return models are rendered as fields (false) or properties (true). public static bool MergeMultipleStoredProcModelsIfAllSame = true; // Some stored procedures are reported as having multiple result sets when in fact there is only one. Set this to true to merge identical result sets. public static List AdditionalNamespaces = new List(); // To include extra namespaces, include them here. i.e. "Microsoft.AspNet.Identity.EntityFramework" public static List AdditionalContextInterfaceItems = new List(); // example: "void SetAutoDetectChangesEnabled(bool flag);" public static List AdditionalFileHeaderText = new List(); // This will put additional lines verbatim at the top of each file under the comments, 1 line per entry public static List AdditionalFileFooterText = new List(); // This will put additional lines verbatim at the end of each file above the // , 1 line per entry // Language choices public static GenerationLanguage GenerationLanguage = GenerationLanguage.CSharp; public static string FileExtension = ".cs"; // Code suppression ******************************************************************************* public static bool UseRegions = true; // If false, suppresses the use of #region public static bool UseNamespace = true; // If false, suppresses the writing of a namespace public static bool UsePragma = false; // If false, suppresses the writing of #pragma public static bool AllowNullStrings = false; // If true, will allow string? properties and will add '#nullable enable' to the top of each file public static bool UseResharper = false; // If true, will add a list of 'ReSharper disable' comments to the top of each file public static bool ShowLicenseInfo = false; // If true, will add the licence info comment to the top of each file public static bool IncludeConnectionSettingComments = false; // Add comments describing connection settings used to generate file public static bool IncludeCodeGeneratedAttribute = false; // If true, will include the [GeneratedCode] attribute before classes, false to remove it. public static bool IncludeColumnsWithDefaults = true; // If true, will set properties to the default value from the database.ro // Create enumerations from database tables // List the enumeration tables you want read and generated for // Also look at the AddEnum callback below to add your own during reverse generation of tables. public static List Enumerations = new List { // Example /*new EnumerationSettings { Name = "DaysOfWeek", // Enum to generate. e.g. "DaysOfWeek" would result in "public enum DaysOfWeek {...}" if the GroupField is set to a value then {GroupField} must be used in this name. e.g. "DaysOfWeek{GroupField}" Table = "EnumTest.DaysOfWeek", // Database table containing enum values. e.g. "DaysOfWeek" NameField = "TypeName", // Column containing the name for the enum. e.g. "TypeName" ValueField = "TypeId", // Column containing the values for the enum. e.g. "TypeId" GroupField = string.Empty // [optional] Column containing the group name for the enum. This is used if multiple Enums are in the same table. if this is populated, use {GroupField} in the Name property. e.g. "{GroupField}Enum" }, new EnumerationSettings { Name = "CarOptions", Table = "car_options", NameField = "enum_name", ValueField = "value" }*/ // Code will be generated as: // public enum Name // { // NameField = ValueField, // etc // } }; // Use the following list to add use of HiLo sequences for identity columns public static List HiLoSequences = new List { // Example // For column dbo.match_table_name.match_column_name this will use .UseHiLo("sequence_name", "sequence_schema") instead of .UseSqlServerIdentityColumn() /*new HiLoSequence { Schema = "dbo", Table = "match_table_name", Column = "match_column_name", SequenceName = "sequence_name", SequenceSchema = "sequence_schema" }, new HiLoSequence { Schema = "dbo", Table = "Employees", Column = "EmployeeID", SequenceName = "EmployeeSequence", SequenceSchema = "dbo" }*/ }; // If you need to serialise your entities with the JsonSerializer from Newtonsoft, this would serialise // all properties including the Reverse Navigation and Foreign Keys. The simplest way to exclude them is // to use the data annotation [JsonIgnore] on reverse navigation and foreign keys. // For more control, take a look at ForeignKeyAnnotationsProcessing() further down public static string[] AdditionalReverseNavigationsDataAnnotations = new string[] { // "JsonIgnore" // Also add "Newtonsoft.Json" to the AdditionalNamespaces array above }; public static string[] AdditionalForeignKeysDataAnnotations = new string[] { // "JsonIgnore" // Also add "Newtonsoft.Json" to the AdditionalNamespaces array above }; // Reference other namespaces ********************************************************************************************************* // Use these namespaces to specify where the different elements now live. These may even be in different assemblies. // NOTE: These are only used if ElementsToGenerate is not set to generate all the elements. // Please note the following does not create the files in these locations, it only adds a using statement to say where they are. // The way to generate files in other folders is to either specify sub-folders above, or add the "EntityFramework Reverse POCO Code First Generator" // into each of the folders you require, then set your .tt files to only generate the relevant section(s) you need by setting: // ElementsToGenerate = Elements.Poco; in your Entity folder, // ElementsToGenerate = Elements.Context | Elements.Interface; in your Context folder, // ElementsToGenerate = Elements.PocoConfiguration; in your Configuration folder. // You also need to set the following to the namespace where they now live: public static string ContextNamespace = ""; // "YourProject.Data"; public static string InterfaceNamespace = ""; // "YourProject.Data"; public static string PocoNamespace = ""; // "YourProject.Data.Entities"; public static string PocoConfigurationNamespace = ""; // "YourProject.Data.Configuration"; // Schema ***************************************************************************************************************************** // If there are multiple schemas, then the table name is prefixed with the schema, except for dbo. // Ie. dbo.hello will be Hello. // abc.hello will be Abc_Hello. public static bool PrependSchemaName = true; // Control if the schema name is prepended to the table name public static string DefaultSchema = null; // Set via DatabaseReader.DefaultSchema() // Table Suffix *********************************************************************************************************************** // Appends the suffix to the generated classes names // Ie. If TableSuffix is "Dto" then Order will be OrderDto // If TableSuffix is "Entity" then Order will be OrderEntity public static string TableSuffix = null; // AddRelationship is a helper function that creates ForeignKey objects and adds them to the foreignKeys list public static Action, Tables> AddExtraForeignKeys = delegate (IDbContextFilter filter, Generator gen, List foreignKeys, Tables tablesAndViews) { // Northwind example: // [Orders] (Table) to [Invoices] (View) is one-to-many using Orders.OrderID = Invoices.OrderID // gen.AddRelationship(filter, foreignKeys, tablesAndViews, "orders_to_invoices", Settings.DefaultSchema, "Orders", "OrderID", "dbo", "Invoices", "OrderID", null, null, true); // [Orders] (Table) to [Orders Qry] (View) is one-to-zeroOrOne ( [Orders].OrderID = [Orders Qry].OrderID ) // gen.AddRelationship(filter, foreignKeys, tablesAndViews, "orders_to_ordersQry", Settings.DefaultSchema, "Orders", "OrderID", "dbo", "Orders Qry", "OrderID", "ParentFkName", "ChildFkName", true); // [Order Details] (Table) to [Invoices] (View) is one-to-zeroOrOne - but uses a composite-key: ( [Order Details].OrderID,ProductID = [Invoices].OrderID,ProductID ) // gen.AddRelationship(filter, foreignKeys, tablesAndViews, "orderDetails_to_invoices", Settings.DefaultSchema, "Order Details", new[] { "OrderID", "ProductID" }, "dbo", "Invoices", new[] { "OrderID", "ProductID" }, null, null, true); }; // StoredProcedure return types ******************************************************************************************************* // Override generation of return models for stored procedures that return entities. // If a stored procedure returns an entity, add it to the list below. // This will suppress the generation of the return model, and instead return the entity. // Example: Proc name Return this entity type instead //StoredProcedureReturnTypes.Add("SalesByYear", "SummaryOfSalesByYear"); public static Dictionary StoredProcedureReturnTypes = new Dictionary(); // Renaming *********************************************************************************************************************** // Table renaming (single context generation only) ************************************************************************************ // Use the following function to rename tables such as tblOrders to Orders, Shipments_AB to Shipments, etc. // Example: public static Func TableRename = delegate (string name, string schema, bool isView) { // Example //if (name.StartsWith("tbl")) // name = name.Remove(0, 3); //name = name.Replace("_AB", ""); //if(isView) // name = name + "View"; // If you turn pascal casing off (UsePascalCase = false), and use the pluralisation service, and some of your // tables names are all UPPERCASE, some words ending in IES such as CATEGORIES get singularised as CATEGORy. // Therefore you can make them lowercase by using the following //return Inflector.MakeLowerIfAllCaps(name); // If you are using the pluralisation service and you want to rename a table, make sure you rename the table to the plural form. // For example, if the table is called Treez (with a z), and your pluralisation entry is // new CustomPluralizationEntry("Tree", "Trees") // Use this TableRename function to rename Treez to the plural (not singular) form, Trees: //if (name == "Treez") return "Trees"; return name; }; // Use the following function if you need to apply additional modifications to a table // Called just before UpdateColumn public static Action UpdateTable = delegate (Table table) { // Add an extra comment //if (table.NameHumanCase.Equals("SomeTable", StringComparison.InvariantCultureIgnoreCase)) // table.AdditionalComment = "Example comment"; // To add a base class to a table //if (table.NameHumanCase == "User") // table.BaseClasses = " : IdentityUser"; //if (table.NameHumanCase == "LogData" || table.NameHumanCase == "ReturnData" || table.NameHumanCase == "DataBlob") // table.BaseClasses = " : ReportData"; // To add attributes //table.Attributes.Add("[Serializable]"); }; // Use the following function if you need to apply additional modifications to a column // eg. normalise names etc. public static Action> UpdateColumn = delegate (Column column, Table table, List enumDefinitions) { // Rename column //if (column.IsPrimaryKey && column.NameHumanCase == "PkId") // column.NameHumanCase = "Id"; // .IsConcurrencyToken() must be manually configured. However .IsRowVersion() can be automatically detected. //if (table.NameHumanCase.Equals("SomeTable", StringComparison.InvariantCultureIgnoreCase) && column.NameHumanCase.Equals("SomeColumn", StringComparison.InvariantCultureIgnoreCase)) // column.IsConcurrencyToken = true; // Remove table name from primary key //if (column.IsPrimaryKey && column.NameHumanCase.Equals(table.NameHumanCase + "Id", StringComparison.InvariantCultureIgnoreCase)) // column.NameHumanCase = "Id"; // Remove column from poco class as it will be inherited from a base class //if (column.IsPrimaryKey && // ( // table.NameHumanCase.Equals("LogData", StringComparison.InvariantCultureIgnoreCase) || // table.NameHumanCase.Equals("ReturnData", StringComparison.InvariantCultureIgnoreCase) || // table.NameHumanCase.Equals("DataBlob", StringComparison.InvariantCultureIgnoreCase) // )) // column.ExistsInBaseClass = true; // If true, does not generate the property for this column as it will exist in a base class // Use the extended properties to perform tasks to column //if (column.ExtendedProperty == "HIDE") // column.Hidden = true; // Hidden means the generator does not generate any code for this column at all. // Apply the "override" access modifier to a specific column. //if (column.NameHumanCase == "id") // column.OverrideModifier = true; // This will create: public override long id { get; set; } // Perform Enum property type replacement var enumDefinition = enumDefinitions?.FirstOrDefault(e => (e.Schema.Equals(table.Schema.DbName, StringComparison.InvariantCultureIgnoreCase)) && (e.Table == "*" || e.Table.Equals(table.DbName, StringComparison.InvariantCultureIgnoreCase) || e.Table.Equals(table.NameHumanCase, StringComparison.InvariantCultureIgnoreCase)) && (e.Column.Equals(column.DbName, StringComparison.InvariantCultureIgnoreCase) || e.Column.Equals(column.NameHumanCase, StringComparison.InvariantCultureIgnoreCase))); if (enumDefinition != null) { column.PropertyType = enumDefinition.EnumType; if (!string.IsNullOrEmpty(column.Default)) column.Default = "(" + enumDefinition.EnumType + ") " + column.Default; } }; // Configures the key property to either use IDENTITY or HILO database feature to generate values for new entities. public static Func ColumnIdentity = delegate (Column c) { if(!IsEfCore3Plus()) return ".UseSqlServerIdentityColumn()"; // At this point we are using EFCore 3, 5+ which supports HiLo sequences. // Example of using a HiLo sequence using this function. /*if (c.ParentTable.NameHumanCase.Equals("SomeTable", StringComparison.InvariantCultureIgnoreCase) && c.NameHumanCase .Equals("SomeColumn", StringComparison.InvariantCultureIgnoreCase)) { return ".UseHiLo(\"your_sequence_name\",\"your_sequence_schema\")"; }*/ var hiLoSequence = HiLoSequences?.FirstOrDefault(x => x.Schema.Equals(c.ParentTable.Schema.DbName, StringComparison.InvariantCultureIgnoreCase) && (x.Table == "*" || x.Table.Equals(c.ParentTable.DbName, StringComparison.InvariantCultureIgnoreCase))); if (hiLoSequence != null) return string.Format(".UseHiLo(\"{0}\", \"{1}\")", hiLoSequence.SequenceName, hiLoSequence.SequenceSchema); return ".UseIdentityColumn()"; }; // In order to use this function, Settings.ElementsToGenerate must contain both Elements.Poco and Elements.Enum; public static Action AddEnum = delegate (Table table) { /*if (table.HasPrimaryKey && table.PrimaryKeys.Count() == 1 && table.Columns.Any(x => x.PropertyType == "string")) { // Example: choosing tables with certain naming conventions for enums. Please use your own conventions. if (table.NameHumanCase.StartsWith("Enum", StringComparison.InvariantCultureIgnoreCase) || table.NameHumanCase.EndsWith ("Enum", StringComparison.InvariantCultureIgnoreCase)) { try { Enumerations.Add(new EnumerationSettings { Name = table.NameHumanCase.Replace("Enum","").Replace("Enum","") + "Enum", Table = table.Schema.DbName + "." + table.DbName, NameField = table.Columns.First(x => x.PropertyType == "string").DbName, // Or specify your own ValueField = table.PrimaryKeys.Single().DbName, // Or specify your own GroupField = string.Empty // Or specify your own }); // This will cause this table to not be reverse-engineered. // This means it was only required to generate an enum and can now be removed. table.RemoveTable = true; // Remove this line if you want to keep it in your dbContext. } catch { // Swallow exception } } }*/ }; // Use the following function if you need to apply additional modifications to a enum // Called just before UpdateEnumMember public static Action UpdateEnum = delegate (Enumeration enumeration) { //enumeration.EnumAttributes.Add("[DataContract]"); }; // Use the following function if you need to apply additional modifications to a enum member public static Action UpdateEnumMember = delegate (EnumerationMember enumerationMember) { //enumerationMember.Attributes.Add("[EnumMember]"); //enumerationMember.Attributes.Add("[SomeAttribute(\"" + enumerationMember.AllValues["SomeName"] + " \")]"); }; // Writes any boilerplate stuff inside the POCO class body public static Func WriteInsideClassBody = delegate (Table t) { // Example: //return " // " + t.NameHumanCase + Environment.NewLine; // Do nothing by default return string.Empty; }; // Using Views ***************************************************************************************************************** // SQL Server does not support the declaration of primary-keys in VIEWs. Entity Framework's EDMX designer (and this generator) // assume that all non-null columns in a VIEW are primary-key columns, this will be incorrect for most non-trivial applications. // This callback will be invoked for each VIEW found in the database. Use it to declare which columns participate in that VIEW's // primary-key by setting 'IsPrimaryKey = true'. // If no columns are marked with 'IsPrimaryKey = true' then this T4 template defaults to marking all non-NULL columns as primary key columns. // To set-up Foreign-Key relationships between VIEWs and Tables (or even other VIEWs) use the 'AddForeignKeys' callback below. public static Action ViewProcessing = delegate (Table view) { // Below is example code for the Northwind database that configures the 'VIEW [Orders Qry]' and 'VIEW [Invoices]' /*switch (view.DbName) { case "Orders Qry": // VIEW [Orders Qry] uniquely identifies rows with the 'OrderID' column: view.Columns.Single(col => col.DbName == "OrderID").IsPrimaryKey = true; break; case "Invoices": // VIEW [Invoices] has a composite primary key (OrderID+ProductID), so both columns must be marked as a Primary Key: foreach (var col in view.Columns.Where(c => c.DbName == "OrderID" || c.DbName == "ProductID")) col.IsPrimaryKey = true; break; }*/ }; // StoredProcedure renaming ************************************************************************************************************ // Use the following function to rename stored procs such as sp_CreateOrderHistory to CreateOrderHistory, my_sp_shipments to Shipments, etc. public static Func StoredProcedureRename = delegate (StoredProcedure sp) { // Example: //if (sp.NameHumanCase.StartsWith("sp_")) // return sp.NameHumanCase.Remove(0, 3); //return sp.NameHumanCase.Replace("my_sp_", ""); return sp.NameHumanCase; // Do nothing by default }; // Use the following function to rename the return model automatically generated for stored procedure. // By default it's ReturnModel. public static Func StoredProcedureReturnModelRename = delegate (string name, StoredProcedure sp) { // Example: //if (sp.NameHumanCase.Equals("ComputeValuesForDate", StringComparison.InvariantCultureIgnoreCase)) // return "ValueSet"; //if (sp.NameHumanCase.Equals("SalesByYear", StringComparison.InvariantCultureIgnoreCase)) // return "SalesSet"; return name; // Do nothing by default }; // Mapping Table renaming ********************************************************************************************************************* // By default, name of the properties created relate to the table the foreign key points to and not the mapping table. // Use the following function to rename the properties created by ManyToMany relationship tables especially if you have 2 relationships between the same tables. // Example: public static Func MappingTableRename = delegate (string mappingTable, string tableName, string entityName) { // Example: If you have two mapping tables such as one being UserRequiredSkills snd one being UserOptionalSkills, this would change the name of one property //if (mappingTable == "UserRequiredSkills" && tableName == "User") // return "RequiredSkills"; // or if you want to give the same property name on both classes //if (mappingTable == "UserRequiredSkills") // return "UserRequiredSkills"; return entityName; }; public static Func ForeignKeyName = delegate (string tableName, ForeignKey foreignKey, string foreignKeyName, Relationship relationship, short attempt) { string fkName; // 5 Attempts to correctly name the foreign key switch (attempt) { case 1: // Try without appending foreign key name fkName = tableName; break; case 2: // Only called if foreign key name ends with "id" // Use foreign key name without "id" at end of string fkName = foreignKeyName.Remove(foreignKeyName.Length - 2, 2); break; case 3: // Use foreign key name only fkName = foreignKeyName; break; case 4: // Use table name and foreign key name fkName = tableName + "_" + foreignKeyName; break; case 5: // Used in for loop 1 to 99 to append a number to the end fkName = tableName; break; default: // Give up fkName = tableName; break; } // Apply custom foreign key renaming rules. Can be useful in applying pluralization. // For example: /*if (tableName == "Employee" && foreignKey.FkColumn == "ReportsTo") return "Manager"; if (tableName == "Territories" && foreignKey.FkTableName == "EmployeeTerritories") return "Locations"; if (tableName == "Employee" && foreignKey.FkTableName == "Orders" && foreignKey.FkColumn == "EmployeeID") return "ContactPerson"; */ // FK_TableName_FromThisToParentRelationshipName_FromParentToThisChildsRelationshipName // (e.g. FK_CustomerAddress_Customer_Addresses will extract navigation properties "address.Customer" and "customer.Addresses") // Feel free to use and change the following /*if (foreignKey.ConstraintName.StartsWith("FK_") && foreignKey.ConstraintName.Count(x => x == '_') == 3) { var parts = foreignKey.ConstraintName.Split('_'); if (!string.IsNullOrWhiteSpace(parts[2]) && !string.IsNullOrWhiteSpace(parts[3]) && parts[1] == foreignKey.FkTableName) { if (relationship == Relationship.OneToMany) fkName = parts[3]; else if (relationship == Relationship.ManyToOne) fkName = parts[2]; } }*/ return fkName; }; // This foreign key filter used in addition to SingleContextFilter.ForeignKeyFilter() // Return null to exclude this foreign key public static Func ForeignKeyFilterFunc = delegate (ForeignKey fk) { // Return null to exclude this foreign key, or set IncludeReverseNavigation = false // to include the foreign key but not generate reverse navigation properties. // Example, to exclude all foreign keys for the Categories table, use: //if (fk.PkTableName == "Categories") // return null; // Example, to exclude reverse navigation properties for tables ending with Type, use: //if (fk.PkTableName.EndsWith("Type")) // fk.IncludeReverseNavigation = false; // You can also change the access modifier of the foreign-key's navigation property: //if(fk.PkTableName == "Categories") // fk.AccessModifier = "internal"; return fk; }; public static Func ForeignKeyAnnotationsProcessing = delegate (Table fkTable, Table pkTable, string propName, string fkPropName) { // Example: // Each navigation property that is a reference to User are left intact //if(pkTable.NameHumanCase.Equals("User") && propName.Equals("User")) // return null; // all the others are marked with this attribute //return new[] { "System.Runtime.Serialization.IgnoreDataMember" }; return null; }; // Column modification **************************************************************************************************************** // Use the following list to replace column byte types with Enums. // As long as the type can be mapped to your new type, all is well. public static Action> AddEnumDefinitions = delegate (List enumDefinitions) { // Examples: //enumDefinitions.Add(new EnumDefinition { Schema = Settings.DefaultSchema, Table = "match_table_name", Column = "match_column_name", EnumType = "name_of_enum" }); // This will replace OrderHeader.OrderStatus type to be an OrderStatusType enum //enumDefinitions.Add(new EnumDefinition { Schema = Settings.DefaultSchema, Table = "OrderHeader", Column = "OrderStatus", EnumType = "OrderStatusType" }); // This will replace any table *.OrderStatus type to be an OrderStatusType enum //enumDefinitions.Add(new EnumDefinition { Schema = Settings.DefaultSchema, Table = "*", Column = "OrderStatus", EnumType = "OrderStatusType" }); }; // Generate multiple db contexts in a single go *************************************************************************************** // Generating multiple contexts at a time requires you specifying which tables, and columns to generate for each context. // As this generator can now generate multiple db contexts in a single go, filtering is done a per db context, and no longer global. // If GenerateSingleDbContext = true (default), please modify SingleContextFilter, this is where your previous global settings should go. // If GenerateSingleDbContext = false, this will generate multiple db contexts. Please read https://github.com/sjh37/EntityFramework-Reverse-POCO-Code-First-Generator/wiki/Generating-multiple-database-contexts-in-a-single-go public static bool GenerateSingleDbContext = true; public static string MultiContextSettingsConnectionString = ""; // Leave empty to read data from same database in ConnectionString above. If settings are in another database, specify the connection string here. public static string MultiContextSettingsPlugin = ""; // Only used for unit testing Generator project as you can't (yet) inherit from IMultiContextSettingsPlugin. "c:\\Path\\YourMultiDbSettingsReader.dll,Full.Name.Of.Class.Including.Namespace". This will allow you to specify a pluggable provider for reading your MultiContext settings. public static char MultiContextAttributeDelimiter = '~'; // The delimiter used for splitting MultiContext attributes public static Action> MultiContextAllFieldsColumnProcessing = delegate (Column column, Table table, Dictionary allFields) { // Examples of how to use additional custom fields from the MultiContext.[Column] table // INT example /*if (allFields.ContainsKey("DummyInt")) { var o = allFields["DummyInt"]; column.ExtendedProperty += string.Format(" DummyInt = {0}", (int) o); }*/ // VARCHAR example /*if (allFields.ContainsKey("Test")) { var o = allFields["Test"]; column.ExtendedProperty += string.Format(" Test = {0}", o.ToString()); }*/ // DATETIME example /*if (allFields.ContainsKey("date_of_birth")) { var o = allFields["date_of_birth"]; var date = Convert.ToDateTime(o); column.ExtendedProperty += string.Format(" date_of_birth = {0}", date.ToLongDateString()); }*/ }; public static Action> MultiContextAllFieldsTableProcessing = delegate (Table table, Dictionary allFields) { // Examples of how to use additional custom fields from the MultiContext.[Table] table // VARCHAR example /*if (allFields.ContainsKey("Notes")) { var o = allFields["Notes"]; if (string.IsNullOrEmpty(table.AdditionalComment)) table.AdditionalComment = string.Empty; table.AdditionalComment += string.Format(" Test = {0}", o.ToString()); }*/ }; public static Action> MultiContextAllFieldsStoredProcedureProcessing = delegate (StoredProcedure sp, Dictionary allFields) { // Examples of how to use additional custom fields from the MultiContext.[Table] table // VARCHAR example /*if (allFields.ContainsKey("CustomRename")) { var o = allFields["CustomRename"]; sp.NameHumanCase = o.ToString(); }*/ }; public static Action> MultiContextAllFieldsFunctionProcessing = delegate (StoredProcedure sp, Dictionary allFields) { // Examples of how to use additional custom fields from the MultiContext.[Table] table // VARCHAR example /*if (allFields.ContainsKey("CustomRename")) { var o = allFields["CustomRename"]; sp.NameHumanCase = o.ToString(); }*/ }; // Helper functions *************************************************************************************************************** public static bool DbContextClassIsPartial() { return DbContextClassModifiers != null && DbContextClassModifiers.Contains("partial"); } public static bool EntityClassesArePartial() { return EntityClassesModifiers != null && EntityClassesModifiers.Contains("partial"); } public static bool ConfigurationClassesArePartial() { return ConfigurationClassesModifiers != null && ConfigurationClassesModifiers.Contains("partial"); } private static string _dbContextInterfaceName; public static string DbContextInterfaceName { get { return _dbContextInterfaceName ?? ("I" + DbContextName); } set { _dbContextInterfaceName = value; } } private static bool _explicitDefaultConstructorArgument; private static string _defaultConstructorArgument; public static string DefaultConstructorArgument { // = null; // Defaults to "Name=" + ConnectionStringName, use null in order not to call the base constructor get { return _explicitDefaultConstructorArgument ? _defaultConstructorArgument : string.Format('"' + "Name={0}" + '"', ConnectionStringName); } set { _explicitDefaultConstructorArgument = true; _defaultConstructorArgument = value; } } // Don't forget to take a look at SingleContextFilter and FilterSettings classes! // That's it, nothing else to configure *********************************************************************************************** public static bool IsEf6() => TemplateType == TemplateType.Ef6; public static bool IsEfCore3Plus() => EfCoreVersion() >= 3; public static bool IsEfCore6Plus() => EfCoreVersion() >= 6; public static bool IsEfCore7Plus() => EfCoreVersion() >= 7; public static bool IsEfCore8Plus() => EfCoreVersion() >= 8; public static int EfCoreVersion() { switch (TemplateType) { case TemplateType.EfCore3: case TemplateType.FileBasedCore3: return 3; case TemplateType.EfCore6: case TemplateType.FileBasedCore6: return 6; case TemplateType.EfCore7: case TemplateType.FileBasedCore7: return 7; case TemplateType.EfCore8: case TemplateType.FileBasedCore8: return 8; case TemplateType.Ef6: case TemplateType.FileBasedEf6: default: return 0; } } public static string DatabaseProvider() { switch (DatabaseType) { case DatabaseType.PostgreSQL: return "UseNpgsql"; case DatabaseType.MySql: return "UseMySql"; case DatabaseType.Oracle: return "UseOracle"; case DatabaseType.SQLite: return "UseSqlite"; default: return "UseSqlServer"; } } public static string SqlParameter() { switch (DatabaseType) { case DatabaseType.PostgreSQL: return "NpgsqlParameter"; case DatabaseType.MySql: return "MySqlParameter"; case DatabaseType.Oracle: return "OracleParameter"; case DatabaseType.SQLite: return "SqliteParameter"; default: return "SqlParameter"; } } public static string SqlParameterValue() { switch (DatabaseType) { case DatabaseType.PostgreSQL: return "NpgsqlValue"; case DatabaseType.MySql: return "Value"; case DatabaseType.Oracle: return "Value"; case DatabaseType.SQLite: return "Value"; default: return "SqlValue"; } } public static string Root; public static string TemplateFile; public static int FilterCount; } // Filtering ************************************************************************************************************************** // These settings are only used by the single context filter SingleContextFilter (Settings.GenerateSingleDbContext = true) // Please read https://github.com/sjh37/EntityFramework-Reverse-POCO-Code-First-Generator/wiki/Filtering // For multi-context filtering (Settings.GenerateSingleDbContext = false), please read https://github.com/sjh37/EntityFramework-Reverse-POCO-Code-First-Generator/wiki/Generating-multiple-database-contexts-in-a-single-go // Use the following filters to exclude or include schemas/tables/views/columns/stored procedures. // You can have as many as you like, and mix and match them. // They run in the order defined below. For help with Regex's try https://regexr.com // Feel free to add more filter types and include them below. public static class FilterSettings { public static bool IncludeViews; public static bool IncludeSynonyms; public static bool IncludeStoredProcedures; public static bool IncludeTableValuedFunctions; public static bool IncludeScalarValuedFunctions; public static readonly List> SchemaFilters; public static readonly List> TableFilters; public static readonly List> ColumnFilters; public static readonly List> StoredProcedureFilters; static FilterSettings() { SchemaFilters = new List>(); TableFilters = new List>(); ColumnFilters = new List>(); StoredProcedureFilters = new List>(); } public static void Reset() { SchemaFilters .RemoveAll(x => true); TableFilters .RemoveAll(x => true); ColumnFilters .RemoveAll(x => true); StoredProcedureFilters.RemoveAll(x => true); } public static void AddDefaults() { IncludeViews = true; IncludeSynonyms = false; IncludeStoredProcedures = true; IncludeTableValuedFunctions = false; // If true, for EF6 install the "EntityFramework.CodeFirstStoreFunctions" NuGet Package. IncludeScalarValuedFunctions = false; AddDefaultSchemaFilters(); AddDefaultTableFilters(); AddDefaultColumnFilters(); AddDefaultStoredProcedureFilters(); } public static void CheckSettings() { if (IncludeTableValuedFunctions || IncludeScalarValuedFunctions) IncludeStoredProcedures = true; // Must be set if table/scalar functions are wanted } public static void AddDefaultSchemaFilters() { SchemaFilters.AddRange(new List> { new PeriodFilter(), // Keep this first as EF does not allow schemas to contain a period character // To include the only the schemas 'dbo' and 'events' //new RegexIncludeFilter("^dbo$|^events$"), // Add your own code to these custom filter classes new SchemaFilter(), new HasNameFilter(FilterType.Schema) }); } public static void AddDefaultTableFilters() { TableFilters.AddRange(new List> { //new PeriodFilter(), // Keep this first as EF does not allow tables to contain a period character // To include all the customer tables, but not the customer billing tables //new RegexExcludeFilter(".*[Bb]illing.*"), // This excludes all tables with 'billing' anywhere in the name //new RegexIncludeFilter("^[Cc]ustomer.*"), // This includes any remaining tables with names beginning with 'customer' // To exclude all tables that contain '_FR_' or begin with 'data_' //new RegexExcludeFilter("(.*_FR_.*)|(^data_.*)"), // Pass in your own custom Regex //new RegexIncludeFilter(new Regex("^tableName1$|^tableName2$", RegexOptions.IgnoreCase, TimeSpan.FromMilliseconds(200))), // Add your own code to these custom filter classes new TableFilter(), new HasNameFilter(FilterType.Table), }); } public static void AddDefaultColumnFilters() { ColumnFilters.AddRange(new List> { // Exclude any columns that begin with 'FK_' //new RegexExcludeFilter("^FK_.*$"), // Add your own code to these custom filter classes new ColumnFilter(), new HasNameFilter(FilterType.Column), }); } public static void AddDefaultStoredProcedureFilters() { StoredProcedureFilters.AddRange(new List> { new PeriodFilter(), // Keep this first as EF does not allow stored procedures to contain a period character // Add your own code to these custom filter classes new StoredProcedureFilter(), new HasNameFilter(FilterType.StoredProcedure) }); } } ///

/// Filtering can now be done via one or more Regex's and one or more functions. /// Gone are the days of a single do-it-all regex, you can now split them up into many smaller Regex's. /// It's now up to you how to want to mix and match them. ///

public class SingleContextFilter : DbContextFilter { public List EnumDefinitions; protected readonly List> SchemaFilters; protected readonly List> TableFilters; protected readonly List> ColumnFilters; protected readonly List> StoredProcedureFilters; private bool _hasMergedIncludeFilters; public SingleContextFilter() { IncludeViews = FilterSettings.IncludeViews; IncludeSynonyms = FilterSettings.IncludeSynonyms; IncludeTableValuedFunctions = FilterSettings.IncludeTableValuedFunctions; IncludeScalarValuedFunctions = FilterSettings.IncludeScalarValuedFunctions; IncludeStoredProcedures = IncludeScalarValuedFunctions || IncludeTableValuedFunctions || FilterSettings.IncludeStoredProcedures; SchemaFilters = FilterSettings.SchemaFilters; TableFilters = FilterSettings.TableFilters; ColumnFilters = FilterSettings.ColumnFilters; StoredProcedureFilters = FilterSettings.StoredProcedureFilters; _hasMergedIncludeFilters = false; EnumDefinitions = new List(); Settings.AddEnumDefinitions?.Invoke(EnumDefinitions); } public override bool IsExcluded(EntityName item) { if(!_hasMergedIncludeFilters) { MergeIncludeFilters(); _hasMergedIncludeFilters = true; } var schema = item as Schema; if (schema != null) return SchemaFilters.Any(filter => filter.IsExcluded(schema)); var table = item as Table; if (table != null) return TableFilters.Any(filter => filter.IsExcluded(table)) || SchemaFilters.Any(filter => filter.IsExcluded(table.Schema)); var column = item as Column; if (column != null) return ColumnFilters.Any(filter => filter.IsExcluded(column)); var sp = item as StoredProcedure; if (sp != null) return StoredProcedureFilters.Any(filter => filter.IsExcluded(sp)) || SchemaFilters.Any(filter => filter.IsExcluded(sp.Schema)); return false; } public override string TableRename(string name, string schema, bool isView) { // Callback to Settings, which can be set within .tt if (Settings.TableRename != null) return Settings.TableRename(name, schema, isView); return name; } public override string MappingTableRename(string mappingTable, string tableName, string entityName) { // Callback to Settings, which can be set within .tt if (Settings.MappingTableRename != null) return Settings.MappingTableRename(mappingTable, tableName, entityName); return entityName; } public override void UpdateTable(Table table) { // Callback to Settings, which can be set within .tt Settings.UpdateTable?.Invoke(table); } public override void UpdateColumn(Column column, Table table) { // Callback to Settings, which can be set within .tt Settings.UpdateColumn?.Invoke(column, table, EnumDefinitions); } public override void AddEnum(Table table) { Settings.AddEnum?.Invoke(table); } public override void UpdateEnum(Enumeration enumeration) { Settings.UpdateEnum?.Invoke(enumeration); } public override void UpdateEnumMember(EnumerationMember enumerationMember) { Settings.UpdateEnumMember?.Invoke(enumerationMember); } public override void ViewProcessing(Table view) { // Callback to Settings, which can be set within .tt Settings.ViewProcessing?.Invoke(view); } public override string StoredProcedureRename(StoredProcedure sp) { // Callback to Settings, which can be set within .tt if (Settings.StoredProcedureRename != null) return Settings.StoredProcedureRename(sp); return sp.NameHumanCase; // Do nothing by default } public override string StoredProcedureReturnModelRename(string name, StoredProcedure sp) { // Callback to Settings, which can be set within .tt if (Settings.StoredProcedureReturnModelRename != null) return Settings.StoredProcedureReturnModelRename(name, sp); return name; // Do nothing by default } public override ForeignKey ForeignKeyFilter(ForeignKey fk) { // Return null to exclude this foreign key, or set IncludeReverseNavigation = false // to include the foreign key but not generate reverse navigation properties. // Example, to exclude all foreign keys for the Categories table, use: //if (fk.PkTableName == "Categories") // return null; // Example, to exclude reverse navigation properties for tables ending with Type, use: //if (fk.PkTableName.EndsWith("Type")) // fk.IncludeReverseNavigation = false; // You can also change the access modifier of the foreign-key's navigation property: //if(fk.PkTableName == "Categories") // fk.AccessModifier = "internal"; return fk; } public override string[] ForeignKeyAnnotationsProcessing(Table fkTable, Table pkTable, string propName, string fkPropName) { // Callback to Settings, which can be set within .tt if (Settings.ForeignKeyAnnotationsProcessing != null) return Settings.ForeignKeyAnnotationsProcessing(fkTable, pkTable, propName, fkPropName); return null; } private void MergeIncludeFilters() { MergeIncludeFilters(SchemaFilters); MergeIncludeFilters(TableFilters); MergeIncludeFilters(ColumnFilters); MergeIncludeFilters(StoredProcedureFilters); } private static void MergeIncludeFilters(List> filters) { var list = filters .Where(x => x.GetType() == typeof(RegexIncludeFilter)) .Select(x => (RegexIncludeFilter) x) .ToList(); if (list.Count < 2) return; // Nothing to merge var singleRegex = string.Join("|", list.Select(x => x.Pattern())); filters.RemoveAll(filter => filter.GetType() == typeof(RegexIncludeFilter)); var singleIncludeFilter = (IFilterType) new RegexIncludeFilter(singleRegex); filters.Add(singleIncludeFilter); } } // **************************************************************************************************************************************** // **************************** No more settings to adjust. Rest of the generator code below. ********************************************* // **************************************************************************************************************************************** public static class AssemblyHelper { public static object LoadPlugin(string assemblyAndType) { var assemblyInfo = assemblyAndType.Split(','); return LoadPlugin(assemblyInfo[0], assemblyInfo[1]); } ///

/// Load a plugin ///

/// Full path including DLL name. i.e. "C:\\S\\Source (open source)\\EntityFramework-Reverse-POCO-Code-Generator\\Generator.Tests.Unit\\\bin\\Debug\\Generator.Tests.Unit.dll" /// Fully qualified class name, including any namespaces. i.e. "Generator.Tests.Unit.MultiContextSettingsPlugin" /// public static object LoadPlugin(string assemblyFile, string typeName) { var asm = Assembly.LoadFrom(assemblyFile.Trim()); var dynType = asm.GetType(typeName.Trim(), true, false); return Activator.CreateInstance(dynType); } } public class Column : EntityName { public string DisplayName; // Name used in the data annotation [Display(Name = " goes here")] public bool OverrideModifier = false; // Adds 'override' to the property declaration public List Attributes = new List(); // List of attributes to add to this columns poco property public bool Hidden; // If true, does not generate any code for this column. public bool ExistsInBaseClass; // If true, does not generate the property for this column as it will exist in a base class public int Scale; public string PropertyType; public string SqlPropertyType; public int DateTimePrecision; public string Default; public string HasDefaultValueSql; public int MaxLength; public int Precision; public int Ordinal; public int PrimaryKeyOrdinal; public string ExtendedProperty; public string SummaryComments; public string InlineComments; public string UniqueIndexName; public bool AllowEmptyStrings = true; public bool IsIdentity; public bool IsRowGuid; public bool IsComputed; public ColumnGeneratedAlwaysType GeneratedAlwaysType; public bool IsNullable; public bool IsPrimaryKey; public bool IsUniqueConstraint; public bool IsUnique; public bool IsStoreGenerated; public bool IsRowVersion; public bool IsConcurrencyToken; // Manually set via callback public bool IsFixedLength; public bool IsUnicode; public bool IsMaxLength; public bool IsForeignKey; public bool IsSpatial; public string Config; public List ConfigFk = new List(); public List EntityFk = new List(); public List Indexes = new List(); public Table ParentTable; public static readonly List NotNullable = new List { Settings.AllowNullStrings ? "" : "string", "byte[]", "datatable", "system.data.datatable", "object", "microsoft.sqlserver.types.sqlgeography", "microsoft.sqlserver.types.sqlgeometry", "sqlgeography", "sqlgeometry", "system.data.entity.spatial.dbgeography", "system.data.entity.spatial.dbgeometry", "dbgeography", "dbgeometry", "system.data.entity.hierarchy.hierarchyid", "hierarchyid", "nettopologysuite.geometries.point", "nettopologysuite.geometries.geometry" }; public static readonly List StoredProcedureNotNullable = new List { "string", "byte[]", "datatable", "system.data.datatable", "object", "microsoft.sqlserver.types.sqlgeography", "microsoft.sqlserver.types.sqlgeometry", "sqlgeography", "sqlgeometry", "system.data.entity.spatial.dbgeography", "system.data.entity.spatial.dbgeometry", "dbgeography", "dbgeometry", "system.data.entity.hierarchy.hierarchyid", "hierarchyid", "nettopologysuite.geometries.point", "nettopologysuite.geometries.geometry" }; public static readonly List CanUseSqlServerIdentityColumn = new List { "sbyte", "short", "smallint", "int", "long" }; public static readonly List ExcludedHasColumnType = new List { "user-defined" }; public void ResetNavigationProperties() { ConfigFk = new List(); EntityFk = new List(); } public bool IsColumnNullable() { return IsNullable && !NotNullable.Contains(PropertyType.ToLower()); } public void CleanUpDefault() { if (string.IsNullOrWhiteSpace(Default) || IsSpatial) { Default = string.Empty; return; } // Remove outer brackets while (Default.First() == '(' && Default.Last() == ')' && Default.Length > 2) { Default = Default.Substring(1, Default.Length - 2); } // Check for sequence var lower = Default.ToLower(); if (lower.Contains("next value for")) { HasDefaultValueSql = Default.Trim(); Default = string.Empty; return; } // Remove unicode prefix if (IsUnicode && Default.StartsWith("N") && !Default.Equals("NULL", StringComparison.InvariantCultureIgnoreCase)) Default = Default.Substring(1, Default.Length - 1); if (Default.First() == '\'' && Default.Last() == '\'' && Default.Length >= 2) Default = string.Format("\"{0}\"", Default.Substring(1, Default.Length - 2)); lower = Default.ToLower(); var lowerPropertyType = PropertyType.ToLower(); // Cleanup default switch (lowerPropertyType) { case "bool": Default = (Default == "0" || lower == "\"false\"" || lower == "false") ? "false" : "true"; break; case "string": case "datetime": case "datetime2": case "system.datetime": case "timespan": case "system.timespan": case "datetimeoffset": case "system.datetimeoffset": if (Default.First() != '"') Default = string.Format("\"{0}\"", Default); if (Default.Contains('\\') || Default.Contains('\r') || Default.Contains('\n')) Default = "@" + Default; else Default = string.Format("\"{0}\"", Default.Substring(1, Default.Length - 2) .Replace("\"", "\\\"")); // #281 Default values must be escaped if contain double quotes break; case "long": case "short": case "int": case "double": case "float": case "decimal": case "byte": case "guid": case "system.guid": if (Default.First() == '\"' && Default.Last() == '\"' && Default.Length > 2) Default = Default.Substring(1, Default.Length - 2); break; case "byte[]": case "system.data.entity.spatial.dbgeography": case "system.data.entity.spatial.dbgeometry": case "nettopologysuite.geometries.point": case "nettopologysuite.geometries.geometry": Default = string.Empty; break; } // Ignore defaults we cannot interpret (we would need SQL to C# compiler) if (lower.StartsWith("create default")) { Default = string.Empty; return; } if (string.IsNullOrWhiteSpace(Default)) { Default = string.Empty; return; } // Validate default switch (lowerPropertyType) { case "long": long l; if (!long.TryParse(Default, out l)) Default = string.Empty; break; case "short": short s; if (!short.TryParse(Default, out s)) Default = string.Empty; break; case "int": int i; if (!int.TryParse(Default, out i)) Default = string.Empty; break; case "datetime": case "datetime2": case "system.datetime": DateTime dt; if (!DateTime.TryParse(Default, out dt)) Default = (lower.Contains("getdate()") || lower.Contains("sysdatetime")) ? "DateTime.Now" : (lower.Contains("getutcdate()") || lower.Contains("sysutcdatetime")) ? "DateTime.UtcNow" : string.Empty; else Default = string.Format("DateTime.Parse({0})", Default); break; case "datetimeoffset": case "system.datetimeoffset": DateTimeOffset dto; if (!DateTimeOffset.TryParse(Default, out dto)) Default = (lower.Contains("getdate()") || lower.Contains("sysdatetimeoffset")) ? "DateTimeOffset.Now" : (lower.Contains("getutcdate()") || lower.Contains("sysutcdatetime")) ? "DateTimeOffset.UtcNow" : string.Empty; else Default = string.Format("DateTimeOffset.Parse({0})", Default); break; case "timespan": case "system.timespan": TimeSpan ts; Default = TimeSpan.TryParse(Default, out ts) ? string.Format("TimeSpan.Parse({0})", Default) : string.Empty; break; case "double": double d; if (!double.TryParse(Default, out d)) Default = string.Empty; if (Default.ToLowerInvariant().EndsWith(".")) Default += "0"; break; case "float": float f; if (!float.TryParse(Default, out f)) Default = string.Empty; if (!Default.ToLowerInvariant().EndsWith("f")) Default += "f"; break; case "decimal": decimal dec; if (!decimal.TryParse(Default, out dec)) Default = string.Empty; else Default += "m"; break; case "byte": byte b; if (!byte.TryParse(Default, out b)) Default = string.Empty; break; case "bool": bool x; if (!bool.TryParse(Default, out x)) Default = string.Empty; break; case "string": if (lower.Contains("newid()") || lower.Contains("newsequentialid()")) Default = "Guid.NewGuid().ToString()"; if (lower.StartsWith("space(")) Default = "\"\""; if (lower == "null") Default = string.Empty; break; case "guid": case "system.guid": if (lower.Contains("newid()") || lower.Contains("newsequentialid()")) Default = "Guid.NewGuid()"; else if (lower.Contains("null")) Default = "null"; else Default = string.Format("Guid.Parse(\"{0}\")", Default); break; } } public static string ToDisplayName(string str) { if (string.IsNullOrEmpty(str)) return string.Empty; var sb = new StringBuilder(30); str = Regex.Replace(str, @"[^a-zA-Z0-9]", " "); // Anything that is not a letter or digit, convert to a space str = Regex.Replace(str, @"([A-Z])([A-Z])([a-z])|([a-z])([A-Z])", "$1$4 $2$3$5"); // Add space between case changes var hasUpperCased = false; var lastChar = '\0'; foreach (var original in str.Trim()) { var c = original; if (lastChar == '\0') { c = char.ToUpperInvariant(original); } else { var isLetter = char.IsLetter(original); var isDigit = char.IsDigit(original); var isWhiteSpace = !isLetter && !isDigit; // Is this char is different to last time var isDifferent = false; if (isLetter && !char.IsLetter(lastChar)) isDifferent = true; else if (isDigit && !char.IsDigit(lastChar)) isDifferent = true; else if (char.IsUpper(original) && !char.IsUpper(lastChar)) isDifferent = true; if (isDifferent || isWhiteSpace) sb.Append(' '); // Add a space if (hasUpperCased && isLetter) c = char.ToLowerInvariant(original); } lastChar = original; if (!hasUpperCased && char.IsUpper(c)) hasUpperCased = true; sb.Append(c); } str = sb.ToString(); str = Regex.Replace(str, @"\s+", " ").Trim(); // Multiple white space to one space str = Regex.Replace(str, @"\bid\b", "ID"); // Make ID word uppercase return str; } public string WrapIfNullable() { if (!IsColumnNullable()) return PropertyType; return string.Format(Settings.NullableShortHand ? "{0}?" : "System.Nullable<{0}>", PropertyType); } } public enum ColumnGeneratedAlwaysType { NotApplicable = 0, AsRowStart = 1, AsRowEnd = 2 } [Flags] public enum CommentsStyle { None, InSummaryBlock, AtEndOfField }; public enum DatabaseType { SqlServer, SqlCe, SQLite, Plugin, // See Settings.DatabaseReaderPlugin PostgreSQL, MySql, // Not yet implemented Oracle // Not yet implemented } public static class EfrpgVersion { public static string Version() { return "v3.9.0"; } } // Settings to allow selective code generation [Flags] public enum Elements { None = 0, Poco = 1, Context = 2, Interface = 4, PocoConfiguration = 8, Enum = 16 }; public abstract class EntityName { public string DbName; // Raw name as obtained from the database public string NameHumanCase; // Name adjusted for C# generator output } public class EnumDefinition { public string Schema; public string Table; public string Column; public string EnumType; } public class Enumeration { public readonly string EnumName; public readonly List Items; public List EnumAttributes = new List(); public Enumeration(string enumName, List items) { EnumName = enumName; Items = items; } } public class EnumerationMember { public readonly string Key; public readonly string Value; public readonly Dictionary AllValues; public List Attributes = new List(); public EnumerationMember(string key, string value, Dictionary allValues) { Key = key; Value = value; AllValues = allValues; } } public class EfCoreFileManager : IFileManager { private readonly List _blocks; private string _filename; private StringBuilder _sb; private const int StringBuilderSize = 2048; public EfCoreFileManager() { _blocks = new List(); _filename = null; _sb = new StringBuilder(StringBuilderSize); } public void Init(GeneratedTextTransformation textTransformation) { } public void StartHeader() { } public void StartFooter() { } public void EndBlock() { AddCurrentBlock(); } public void Process(bool split) { AddCurrentBlock(); foreach (var fileBlock in _blocks) { var filename = Path.Combine(Settings.Root, fileBlock.Filename); using (var file = new StreamWriter(filename)) { file.Write(fileBlock.Text); } } } public void ProcessToAnotherFileManager(IFileManager fileManager, GeneratedTextTransformation outer) { AddCurrentBlock(); foreach (var fileBlock in _blocks) { fileManager.StartNewFile(fileBlock.Filename); outer.WriteLine(fileBlock.Text); fileManager.EndBlock(); } } public void StartNewFile(string name) { _filename = name; } public void WriteLine(string text) { _sb.AppendLine(text); } private void AddCurrentBlock() { if (_sb.Length == 0) return; if (string.IsNullOrEmpty(_filename)) { _sb = new StringBuilder(StringBuilderSize); return; } _blocks.Add(new FileBlock { Text = _sb.ToString(), Filename = _filename }); _filename = null; _sb = new StringBuilder(StringBuilderSize); } private class FileBlock { public string Text { get; set; } public string Filename { get; set; } } } ///

/// This class is responsible for: /// 1. Recording what files were created. /// 2. Write this log to into a text file, same name as the database.tt filename, but with .txt file extension. /// 3. Read this file back in at the start, and to delete the previous runs files prior to re-generating. ///

public class FileAuditService { // List of file, including paths, relative to Settings.Root private readonly List _files; private readonly DateTime _start; public FileAuditService() { _start = DateTime.Now; _files = new List { "# This file contains a list of the files generated by the " + Settings.TemplateFile + ".tt file.", "# Please do not edit this file. It is used to delete files that may get filtered out during the next run.", "# Time start = " + _start.ToLocalTime() }; } public void AddFile(string file) { _files.Add(file); } public void WriteAuditFile() { var end = DateTime.Now; _files.Add($"# Time end = {end.ToLocalTime()}, duration = {(end - _start).TotalSeconds:F} seconds."); var filename = GetFilename(); DeleteFilesNotRecreated(filename); File.WriteAllLines(filename, _files); } private void DeleteFilesNotRecreated(string filename) { if (!File.Exists(filename)) return; var filesToDelete = File.ReadAllLines(filename) .Where(x => !x.StartsWith("#") && !string.IsNullOrWhiteSpace(x) && !_files.Contains(x)) .ToList(); foreach (var file in filesToDelete) { try { var path = Path.Combine(Settings.Root, file); if (File.Exists(path)) File.Delete(path); } catch (Exception) { // Ignore if cannot delete, or file is missing } } } private static string GetFilename() { return Path.Combine(Settings.Root, Settings.TemplateFile + "Audit.txt"); } } public class FileManagementService : IFileManager { private readonly GeneratedTextTransformation _outer; private readonly Dictionary _fileManagers; private IFileManager _fileManager; private VisualStudioFileManager _visualStudioFileManager; private readonly FileAuditService _auditService; private bool _writeToOuter; public bool ForceWriteToOuter; public FileManagementService(GeneratedTextTransformation outer) { if (outer == null) throw new ArgumentNullException(nameof(outer)); _outer = outer; _fileManagers = new Dictionary(); _fileManager = null; _visualStudioFileManager = null; _auditService = new FileAuditService(); } public static void DeleteFile(string filename) { try { var path = Path.Combine(Settings.Root, filename); File.Delete(path); } catch { // ignored } } public void Init(Dictionary filters, Type fileManagerType) { Settings.FilterCount = filters.Count; _writeToOuter = Settings.GenerateSingleDbContext && !Settings.GenerateSeparateFiles; // For debug /*var a = _writeToOuter; var b = Settings.FilterCount; var c = Settings.GenerateSeparateFiles; var d = Settings.TemplateType; var e = Settings.GenerateSingleDbContext; var f = filters.First().Key;*/ if (fileManagerType == typeof(VisualStudioFileManager)) { _visualStudioFileManager = (VisualStudioFileManager)Activator.CreateInstance(fileManagerType); _visualStudioFileManager.Init(_outer); // Switch to the EfCoreFileManager for the rest fileManagerType = typeof(EfCoreFileManager); } foreach (var filter in filters) { var fileManager = (IFileManager)Activator.CreateInstance(fileManagerType); fileManager.Init(_outer); if (!string.IsNullOrWhiteSpace(filter.Key)) fileManager.StartNewFile(filter.Key + Settings.FileExtension); _fileManagers.Add(filter.Key, fileManager); } } public void UseFileManager(string key) { _fileManager = _fileManagers[key]; } public void Error(string error) { // Write any errors to the primary output cs file _outer.WriteLine(error); } public void WriteLine(string text) { if (_writeToOuter || ForceWriteToOuter) _outer.WriteLine(text); else _fileManager.WriteLine(text); } public void Init(GeneratedTextTransformation textTransformation) { throw new NotImplementedException(); } public void StartHeader() { _fileManager.StartHeader(); } public void StartFooter() { _fileManager.StartFooter(); } public void EndBlock() { _fileManager.EndBlock(); } public void Process(bool split) { _auditService.WriteAuditFile(); foreach (var fileManager in _fileManagers) { if (_visualStudioFileManager == null) { fileManager.Value.Process(split); continue; } if (fileManager.Value.GetType() == typeof(EfCoreFileManager)) ((EfCoreFileManager)fileManager.Value).ProcessToAnotherFileManager(_visualStudioFileManager, _outer); else fileManager.Value.Process(split); } _visualStudioFileManager?.Process(split); } public void StartNewFile(string name) { _fileManager.StartNewFile(name); _auditService.AddFile(name); } } public static class FileManagerFactory { public static Type GetFileManagerType() { switch (Settings.FileManagerType) { case FileManagerType.VisualStudio: return typeof(VisualStudioFileManager); #pragma warning disable CS0618 // Type or member is obsolete case FileManagerType.Custom: #pragma warning restore CS0618 // Type or member is obsolete case FileManagerType.EfCore: return typeof(EfCoreFileManager); case FileManagerType.Null: return typeof(NullFileManager); default: throw new ArgumentOutOfRangeException(); } } } public interface IFileManager { void Init(GeneratedTextTransformation textTransformation); void StartHeader(); void StartFooter(); void EndBlock(); void Process(bool split); void StartNewFile(string name); void WriteLine(string text); } public class NullFileManager : IFileManager { public void Init(GeneratedTextTransformation textTransformation) { } public void StartHeader() { } public void StartFooter() { } public void EndBlock() { } public void Process(bool split) { } public void StartNewFile(string name) { } public void WriteLine(string text) { } } // This will make use of the real file manager within EF6.Utility.CS.ttinclude public class VisualStudioFileManager : IFileManager { private EntityFrameworkTemplateFileManager _wrapped; public void Init(GeneratedTextTransformation textTransformation) { _wrapped = EntityFrameworkTemplateFileManager.Create(textTransformation); } public void StartHeader() { _wrapped.StartHeader(); } public void StartFooter() { _wrapped.StartFooter(); } public void EndBlock() { _wrapped.EndBlock(); } public void Process(bool split) { _wrapped.Process(split); } public void StartNewFile(string name) { _wrapped.StartNewFile(name); } public void WriteLine(string text) { } } public enum FileManagerType { // Use this for .NET 4.x projects. // It will make use of the `EF6.Utility.CS.ttinclude` to add/remove files to the Visual Studio project. VisualStudio, // Use this for .NET Core projects. // It will write the files directly. // Visual Studio will automatically detect new files and include them in the project. EfCore, [Obsolete("Please use FileManagerType.EfCore instead")] Custom, Null // For testing only. Does nothing. } public class ColumnFilter : IFilterType { // Filtering of columns using a function. // Return true to exclude the column, return false to include it. public bool IsExcluded(Column c) { // Example: Exclude any columns whose table is in 'dbo' schema and column name starts with 'bank' //if(c.ParentTable.Schema.DbName.Equals(Settings.DefaultSchema, StringComparison.InvariantCultureIgnoreCase) && // c.NameHumanCase.ToLowerInvariant().StartsWith("bank")) // return true; return false; } } public abstract class DbContextFilter : IDbContextFilter { public string SubNamespace { get; set; } public Tables Tables { get; set; } public List StoredProcs { get; set; } public List Enums { get; set; } public List Sequences { get; set; } public bool IncludeViews { get; set; } public bool IncludeSynonyms { get; set; } public bool IncludeStoredProcedures { get; set; } public bool IncludeTableValuedFunctions { get; set; } public bool IncludeScalarValuedFunctions { get; set; } protected DbContextFilter() { Tables = new Tables(); StoredProcs = new List(); Enums = new List(); Sequences = new List(); SubNamespace = string.Empty; } public abstract bool IsExcluded(EntityName item); public abstract string TableRename(string name, string schema, bool isView); public abstract string MappingTableRename(string mappingTable, string tableName, string entityName); public abstract void UpdateTable(Table table); public abstract void UpdateColumn(Column column, Table table); public abstract void AddEnum(Table table); public abstract void UpdateEnum(Enumeration enumeration); public abstract void UpdateEnumMember(EnumerationMember enumerationMember); public abstract void ViewProcessing(Table view); public abstract string StoredProcedureRename(StoredProcedure sp); public abstract string StoredProcedureReturnModelRename(string name, StoredProcedure sp); public abstract ForeignKey ForeignKeyFilter(ForeignKey fk); public abstract string[] ForeignKeyAnnotationsProcessing(Table fkTable, Table pkTable, string propName, string fkPropName); } public class DbContextFilterList : IDbContextFilterList { private List _multiContextSettings; private Dictionary _filters; // Key = database context name, which also becomes the sub-namespace used to encapsulate the many db contexts public bool ReadDbContextSettings(DatabaseReader reader, string singleDbContextSubNamespace = "") { _filters = new Dictionary(); if (Settings.GenerateSingleDbContext) { // No need to read the database for settings, as they are provided by the user customisable class SingleContextFilter var filter = new SingleContextFilter { SubNamespace = singleDbContextSubNamespace }; _filters.Add(string.IsNullOrWhiteSpace(singleDbContextSubNamespace) ? string.Empty : singleDbContextSubNamespace, filter); return true; } // Read in multi database context settings if (!string.IsNullOrWhiteSpace(Settings.MultiContextSettingsPlugin)) { // Use plugin // We know the plugin implements (IMultiContextSettingsPlugin) interface but we can't direct cast it so we copy the object var plugin = AssemblyHelper.LoadPlugin(Settings.MultiContextSettingsPlugin); var pluginType = plugin.GetType(); // remoteSettingsListObject is a List object var remoteSettingsListObject = (IList) pluginType.InvokeMember("ReadSettings", System.Reflection.BindingFlags.InvokeMethod, null, plugin, null); _multiContextSettings = new List(); var remoteSettingsList = remoteSettingsListObject.Cast { // Filtering of tables using a function. // Return true to exclude the table, return false to include it. public bool IsExcluded(Table t) { // Example: Exclude any table in 'dbo' schema and with 'order' anywhere in its name. //if(t.Schema.DbName.Equals("dbo", StringComparison.InvariantCultureIgnoreCase) && t.DbName.ToLowerInvariant().Contains("order")) // return true; return false; } } public class ForeignKey { public readonly string FkTableName; public readonly string FkSchema; public readonly string PkTableName; public readonly string FkTableNameFiltered; public readonly string PkTableNameFiltered; public readonly string PkSchema; public readonly string FkColumn; public readonly string PkColumn; public readonly string ConstraintName; public readonly int Ordinal; public readonly bool CascadeOnDelete; public readonly string ParentName; public readonly string ChildName; public readonly bool HasUniqueConstraint; // Record unique name for this foreign key public string UniqueName; // User settable via ForeignKeyFilter callback public string AccessModifier { get; set; } public bool IncludeReverseNavigation { get; set; } public bool IsNotEnforced { get; set; } public ForeignKey(string fkTableName, string fkSchema, string pkTableName, string pkSchema, string fkColumn, string pkColumn, string constraintName, string fkTableNameFiltered, string pkTableNameFiltered, int ordinal, bool cascadeOnDelete, bool isNotEnforced, string parentName, string childName, bool hasUniqueConstraint) { ConstraintName = constraintName; ParentName = parentName; ChildName = childName; PkColumn = pkColumn; FkColumn = fkColumn; PkSchema = pkSchema; PkTableName = pkTableName; FkSchema = fkSchema; FkTableName = fkTableName; FkTableNameFiltered = fkTableNameFiltered; PkTableNameFiltered = pkTableNameFiltered; Ordinal = ordinal; CascadeOnDelete = cascadeOnDelete; IsNotEnforced = isNotEnforced; HasUniqueConstraint = hasUniqueConstraint; UniqueName = string.Empty; IncludeReverseNavigation = true; } public ForeignKey(RawForeignKey rfk, string fkTableNameFiltered, string pkTableNameFiltered) { ConstraintName = rfk.ConstraintName; ParentName = rfk.ParentName; ChildName = rfk.ChildName; PkColumn = rfk.PkColumn; FkColumn = rfk.FkColumn; PkSchema = rfk.PkSchema; PkTableName = rfk.PkTableName; FkSchema = rfk.FkSchema; FkTableName = rfk.FkTableName; FkTableNameFiltered = fkTableNameFiltered; PkTableNameFiltered = pkTableNameFiltered; Ordinal = rfk.Ordinal; CascadeOnDelete = rfk.CascadeOnDelete; IsNotEnforced = rfk.IsNotEnforced; HasUniqueConstraint = rfk.HasUniqueConstraint; UniqueName = string.Empty; IncludeReverseNavigation = true; } public string PkTableHumanCase(string suffix) { var singular = Inflector.MakeSingular(DatabaseReader.CleanUp(PkTableNameFiltered)); var pkTableHumanCase = (Settings.UsePascalCase ? Inflector.ToTitleCase(singular) : singular) .Replace(" ", string.Empty) .Replace("$", string.Empty); if (string.Compare(PkSchema, Settings.DefaultSchema, StringComparison.OrdinalIgnoreCase) != 0 && Settings.PrependSchemaName) pkTableHumanCase = PkSchema + "_" + pkTableHumanCase; pkTableHumanCase += suffix; return pkTableHumanCase; } } public enum ForeignKeyNamingStrategy { Legacy, // Same as versions <= v3.9.0 Latest } public class BaseForeignKeyNamingStrategy { protected readonly Table _table; protected readonly IDbContextFilter _filter; public BaseForeignKeyNamingStrategy(IDbContextFilter filter, Table table) { _filter = filter; _table = table; } protected static string CheckForUserSpecifiedName(bool isParent, ForeignKey foreignKey) { // User specified name via AddRelationship if (isParent && !string.IsNullOrEmpty(foreignKey.ParentName)) return foreignKey.ParentName; // User specified name via AddRelationship if (!isParent && !string.IsNullOrEmpty(foreignKey.ChildName)) return foreignKey.ChildName; return null; } } public static class ForeignKeyNamingStrategyFactory { public static IForeignKeyNamingStrategy Create(IDbContextFilter filter, Table table) { switch (Settings.ForeignKeyNamingStrategy) { case ForeignKeyNamingStrategy.Legacy: return new LegacyForeignKeyNamingStrategy(filter, table); default: return new LatestForeignKeyNamingStrategy(filter, table); } } } public interface IForeignKeyNamingStrategy { string GetUniqueForeignKeyName(bool isParent, string tableNameHumanCase, ForeignKey foreignKey, bool checkForFkNameClashes, bool makeSingular, Relationship relationship); void ResetNavigationProperties(); } // Not complete. Please use LegacyForeignKeyNamingStrategy public class LatestForeignKeyNamingStrategy : BaseForeignKeyNamingStrategy, IForeignKeyNamingStrategy { public LatestForeignKeyNamingStrategy(IDbContextFilter filter, Table table) : base(filter, table) { } public string GetUniqueForeignKeyName(bool isParent, string tableNameHumanCase, ForeignKey foreignKey, bool checkForFkNameClashes, bool makeSingular, Relationship relationship) { var userSpecifiedName = CheckForUserSpecifiedName(isParent, foreignKey); if (!string.IsNullOrEmpty(userSpecifiedName)) return userSpecifiedName; var addReverseNavigationUniquePropName = checkForFkNameClashes && (_table.DbName == foreignKey.FkTableName || (_table.DbName == foreignKey.PkTableName && foreignKey.IncludeReverseNavigation)); // Attempt 1 var fkName = (Settings.UsePascalCase ? Inflector.ToTitleCase(foreignKey.FkColumn) : foreignKey.FkColumn).Replace(" ", string.Empty).Replace("$", string.Empty); var name = Settings.ForeignKeyName(tableNameHumanCase, foreignKey, fkName, relationship, 1); if (addReverseNavigationUniquePropName || !checkForFkNameClashes) { foreignKey.UniqueName = name; } // todo return name; } public void ResetNavigationProperties() { // todo } } // v0.0.0 <= v3.9.0 public class LegacyForeignKeyNamingStrategy : BaseForeignKeyNamingStrategy, IForeignKeyNamingStrategy { public List ReverseNavigationUniquePropName; public List ReverseNavigationUniquePropNameClashes; public LegacyForeignKeyNamingStrategy(IDbContextFilter filter, Table table) : base(filter, table) { ReverseNavigationUniquePropNameClashes = new List(); } public string GetUniqueForeignKeyName(bool isParent, string tableNameHumanCase, ForeignKey foreignKey, bool checkForFkNameClashes, bool makeSingular, Relationship relationship) { var userSpecifiedName = CheckForUserSpecifiedName(isParent, foreignKey); if (!string.IsNullOrEmpty(userSpecifiedName)) return userSpecifiedName; var addReverseNavigationUniquePropName = checkForFkNameClashes && (_table.DbName == foreignKey.FkTableName || (_table.DbName == foreignKey.PkTableName && foreignKey.IncludeReverseNavigation)); // Generate name if (ReverseNavigationUniquePropName.Count == 0) { // Reserve table name and all column names ReverseNavigationUniquePropName.Add(_table.NameHumanCase); ReverseNavigationUniquePropName.AddRange(_table.Columns.Select(c => c.NameHumanCase)); } if (!makeSingular) tableNameHumanCase = Inflector.MakePlural(tableNameHumanCase); if (checkForFkNameClashes && ReverseNavigationUniquePropName.Contains(tableNameHumanCase) && !ReverseNavigationUniquePropNameClashes.Contains(tableNameHumanCase)) { ReverseNavigationUniquePropNameClashes.Add(tableNameHumanCase); // Name clash } // Attempt 1 var fkName = (Settings.UsePascalCase ? Inflector.ToTitleCase(foreignKey.FkColumn) : foreignKey.FkColumn).Replace(" ", string.Empty).Replace("$", string.Empty); var name = Settings.ForeignKeyName(tableNameHumanCase, foreignKey, fkName, relationship, 1); string col; if (!ReverseNavigationUniquePropName.Contains(name) && !ReverseNavigationUniquePropNameClashes.Contains(name)) { if (addReverseNavigationUniquePropName || !checkForFkNameClashes) { ReverseNavigationUniquePropName.Add(name); foreignKey.UniqueName = name; } return name; } if (_table.DbName == foreignKey.FkTableName) { // Attempt 2 if (fkName.Length > 2 && fkName.ToLowerInvariant().EndsWith("id")) { col = Settings.ForeignKeyName(tableNameHumanCase, foreignKey, fkName, relationship, 2); if (checkForFkNameClashes && ReverseNavigationUniquePropName.Contains(col) && !ReverseNavigationUniquePropNameClashes.Contains(col)) { ReverseNavigationUniquePropNameClashes.Add(col); // Name clash } if (!ReverseNavigationUniquePropName.Contains(col) && !ReverseNavigationUniquePropNameClashes.Contains(col)) { if (addReverseNavigationUniquePropName || !checkForFkNameClashes) { ReverseNavigationUniquePropName.Add(col); } return col; } } // Attempt 3 col = Settings.ForeignKeyName(tableNameHumanCase, foreignKey, fkName, relationship, 3); if (checkForFkNameClashes && ReverseNavigationUniquePropName.Contains(col) && !ReverseNavigationUniquePropNameClashes.Contains(col)) { ReverseNavigationUniquePropNameClashes.Add(col); // Name clash } if (!ReverseNavigationUniquePropName.Contains(col) && !ReverseNavigationUniquePropNameClashes.Contains(col)) { if (addReverseNavigationUniquePropName || !checkForFkNameClashes) { ReverseNavigationUniquePropName.Add(col); } return col; } } // Attempt 4 col = Settings.ForeignKeyName(tableNameHumanCase, foreignKey, fkName, relationship, 4); if (checkForFkNameClashes && ReverseNavigationUniquePropName.Contains(col) && !ReverseNavigationUniquePropNameClashes.Contains(col)) { ReverseNavigationUniquePropNameClashes.Add(col); // Name clash } if (!ReverseNavigationUniquePropName.Contains(col) && !ReverseNavigationUniquePropNameClashes.Contains(col)) { if (addReverseNavigationUniquePropName || !checkForFkNameClashes) { ReverseNavigationUniquePropName.Add(col); } return col; } // Attempt 5 for (var n = 1; n < 99; ++n) { col = Settings.ForeignKeyName(tableNameHumanCase, foreignKey, fkName, relationship, 5) + n; if (ReverseNavigationUniquePropName.Contains(col)) continue; if (addReverseNavigationUniquePropName || !checkForFkNameClashes) { ReverseNavigationUniquePropName.Add(col); } return col; } // Give up return Settings.ForeignKeyName(tableNameHumanCase, foreignKey, fkName, relationship, 6); } public void ResetNavigationProperties() { ReverseNavigationUniquePropName = new List(); } } public class CodeGenerator { private readonly Generator _generator; private readonly IDbContextFilter _filter; private readonly List _tables; private readonly List _storedProcs; private readonly List _globalUsings; private readonly Template _template; private readonly List _tableValuedFunctions; private readonly List _scalarValuedFunctions; private readonly List _tableValuedFunctionComplexTypes; private readonly bool _hasTables, _hasStoredProcs, _hasTableValuedFunctions, _hasScalarValuedFunctions, _hasTableValuedFunctionComplexTypes, _hasEnums; public CodeGenerator(Generator generator, IDbContextFilter filter) { #pragma warning disable IDE0016 // Use 'throw' expression if (generator == null) throw new ArgumentNullException(nameof(generator)); if (filter == null) throw new ArgumentNullException(nameof(filter)); #pragma warning restore IDE0016 // Use 'throw' expression var isEfCore = Settings.GeneratorType == GeneratorType.EfCore; var isEfCore3Plus = Settings.IsEfCore3Plus(); _generator = generator; _filter = filter; _tables = filter.Tables .Where(t => !t.IsMapping && (t.HasPrimaryKey || (t.IsView && isEfCore3Plus))) .OrderBy(x => x.NameHumanCase) .Select(tbl => new TableTemplateData(tbl)) .ToList(); if (filter.IncludeStoredProcedures) { _storedProcs = filter.StoredProcs .Where(s => s.IsStoredProcedure) .OrderBy(x => x.NameHumanCase) .Select(sp => new StoredProcTemplateData( sp.ReturnModels.Count == 0, sp.ReturnModels.Count > 0, sp.ReturnModels.Count == 1, sp.ReturnModels.Count > 1, sp.WriteStoredProcReturnType(_filter), sp.WriteStoredProcReturnModelName(filter), sp.WriteStoredProcFunctionName(filter), sp.WriteStoredProcFunctionParams(false, false, false), sp.WriteStoredProcFunctionParams(false, true, false), sp.WriteStoredProcFunctionParams(true, false, false), sp.WriteStoredProcFunctionParams(true, true, false), sp.WriteStoredProcFunctionParams(false, false, true), sp.WriteStoredProcFunctionParams(false, true, true), sp.WriteStoredProcFunctionParams(true, false, true), sp.WriteStoredProcFunctionParams(true, true, true), !sp.StoredProcCanExecuteAsync(), sp.WriteStoredProcFunctionOverloadCall(), sp.WriteStoredProcFunctionSetSqlParameters(false), sp.WriteStoredProcFunctionSetSqlParameters(true), sp.ReturnModels.Count == 1 ? // exec string.Format("EXEC @procResult = [{0}].[{1}] {2}", sp.Schema.DbName, sp.DbName, sp.WriteStoredProcFunctionSqlAtParams()).Trim() : string.Format("[{0}].[{1}]", sp.Schema.DbName, sp.DbName), sp.ReturnModels.Count == 0 ? // Async exec string.Format("EXEC @procResult = [{0}].[{1}] {2}", sp.Schema.DbName, sp.DbName, sp.WriteStoredProcFunctionSqlAtParams()).Trim() : sp.ReturnModels.Count == 1 ? string.Format("EXEC [{0}].[{1}] {2}", sp.Schema.DbName, sp.DbName, sp.WriteStoredProcFunctionSqlAtParams()).Trim() : string.Format("[{0}].[{1}]", sp.Schema.DbName, sp.DbName), sp.WriteStoredProcReturnModelName(_filter), sp.WriteStoredProcFunctionSqlParameterAnonymousArray(true, true, false), sp.WriteStoredProcFunctionSqlParameterAnonymousArray(false, true, false), sp.WriteStoredProcFunctionSqlParameterAnonymousArray(true, true, true, isEfCore3Plus), sp.WriteStoredProcFunctionSqlParameterAnonymousArray(false, true, true, isEfCore3Plus), sp.WriteStoredProcFunctionDeclareSqlParameter(true), sp.WriteStoredProcFunctionDeclareSqlParameter(false), sp.Parameters.OrderBy(x => x.Ordinal).Select(sp.WriteStoredProcSqlParameterName).ToList(), sp.ReturnModels.Count, string.Format("EXEC @procResult = [{0}].[{1}] {2}", sp.Schema.DbName, sp.DbName, sp.WriteStoredProcFunctionSqlAtParams()) )) .ToList(); } else _storedProcs = new List(); if (filter.IncludeTableValuedFunctions) { _tableValuedFunctions = filter.StoredProcs .Where(s => s.IsTableValuedFunction) .OrderBy(x => x.NameHumanCase) .Select(tvf => new TableValuedFunctionsTemplateData( tvf.ReturnModels.Count == 1 && tvf.ReturnModels[0].Count == 1, tvf.ReturnModels.Count == 1 && tvf.ReturnModels[0].Count == 1 ? tvf.ReturnModels[0][0].ColumnName : null, tvf.WriteStoredProcFunctionName(_filter), tvf.WriteStoredProcReturnModelName(_filter), tvf.WriteStoredProcFunctionParams(false, true), tvf.WriteStoredProcFunctionParams(false, false), tvf.DbName, tvf.Schema.DbName, isEfCore ? tvf.WriteStoredProcFunctionDeclareSqlParameter(false) : tvf.WriteTableValuedFunctionDeclareSqlParameter(), isEfCore ? tvf.WriteStoredProcFunctionSqlParameterAnonymousArray(false, false) : tvf.WriteTableValuedFunctionSqlParameterAnonymousArray(), isEfCore ? tvf.WriteNetCoreTableValuedFunctionsSqlAtParams() : tvf.WriteStoredProcFunctionSqlAtParams(), isEfCore3Plus ? "FromSqlRaw" : "FromSql", isEfCore3Plus ? "Set" : "Query", isEfCore3Plus ? "Entity" : "Query", isEfCore3Plus ? ".HasNoKey()" : string.Empty, !Settings.StoredProcedureReturnTypes.ContainsKey(tvf.NameHumanCase) && !Settings.StoredProcedureReturnTypes.ContainsKey(tvf.DbName) )) .ToList(); _tableValuedFunctionComplexTypes = filter.StoredProcs .Where(s => s.IsTableValuedFunction && !Settings.StoredProcedureReturnTypes.ContainsKey(s.NameHumanCase) && !Settings.StoredProcedureReturnTypes.ContainsKey(s.DbName)) .OrderBy(x => x.NameHumanCase) .Select(x => x.WriteStoredProcReturnModelName(_filter)) .ToList(); } else { _tableValuedFunctions = new List(); _tableValuedFunctionComplexTypes = new List(); } if (filter.IncludeScalarValuedFunctions) { _scalarValuedFunctions = filter.StoredProcs .Where(s => s.IsScalarValuedFunction && s.Parameters.Any(x => x.Mode == StoredProcedureParameterMode.Out)) .OrderBy(x => x.NameHumanCase) .Select(svf => new ScalarValuedFunctionsTemplateData( svf.WriteStoredProcFunctionName(_filter), svf.Parameters.Where(x => x.Mode == StoredProcedureParameterMode.Out).OrderBy(x => x.Ordinal).FirstOrDefault()?.PropertyType, svf.WriteStoredProcFunctionParams(false, true), svf.WriteStoredProcFunctionParams(false, false), svf.DbName, svf.Schema.DbName )) .ToList(); } else _scalarValuedFunctions = new List(); var returnModelsUsed = new List(); foreach (var sp in _storedProcs) { if (returnModelsUsed.Contains(sp.ReturnModelName)) sp.CreateDbSetForReturnModel = false; else returnModelsUsed.Add(sp.ReturnModelName); } _hasTables = _tables.Any(); _hasStoredProcs = _storedProcs.Any(); _hasTableValuedFunctions = _tableValuedFunctions.Any(); _hasScalarValuedFunctions = _scalarValuedFunctions.Any(); _hasTableValuedFunctionComplexTypes = _tableValuedFunctionComplexTypes.Any(); _hasEnums = filter.Enums.Any(); _globalUsings = new List(); _template = TemplateFactory.Create(); CalcGlobalUsings(); } private void CalcGlobalUsings() { _globalUsings.AddRange(Settings.AdditionalNamespaces.Where(x => !string.IsNullOrEmpty(x)).Distinct()); if ((Settings.ElementsToGenerate.HasFlag(Elements.PocoConfiguration) || Settings.ElementsToGenerate.HasFlag(Elements.Context) || Settings.ElementsToGenerate.HasFlag(Elements.Interface)) && (!Settings.ElementsToGenerate.HasFlag(Elements.Poco) && !string.IsNullOrWhiteSpace(Settings.PocoNamespace))) _globalUsings.Add(Settings.PocoNamespace); if (Settings.ElementsToGenerate.HasFlag(Elements.PocoConfiguration) && (!Settings.ElementsToGenerate.HasFlag(Elements.Context) && !string.IsNullOrWhiteSpace(Settings.ContextNamespace))) _globalUsings.Add(Settings.ContextNamespace); if (Settings.ElementsToGenerate.HasFlag(Elements.Context) && (!Settings.ElementsToGenerate.HasFlag(Elements.Interface) && !string.IsNullOrWhiteSpace(Settings.InterfaceNamespace))) _globalUsings.Add(Settings.InterfaceNamespace); if (Settings.ElementsToGenerate.HasFlag(Elements.Context) && (!Settings.ElementsToGenerate.HasFlag(Elements.PocoConfiguration) && !string.IsNullOrWhiteSpace(Settings.PocoConfigurationNamespace))) _globalUsings.Add(Settings.PocoConfigurationNamespace); } private bool CanWriteInterface() { return Settings.ElementsToGenerate.HasFlag(Elements.Interface) && !string.IsNullOrWhiteSpace(Settings.DbContextInterfaceName) && (_hasTables || _hasStoredProcs || _hasTableValuedFunctions || _hasScalarValuedFunctions); } private bool CanWriteFactory() { return Settings.ElementsToGenerate.HasFlag(Elements.Context) && Settings.AddIDbContextFactory && (_hasTables || _hasStoredProcs || _hasTableValuedFunctions || _hasScalarValuedFunctions); } private bool CanWriteContext() { return Settings.ElementsToGenerate.HasFlag(Elements.Context) && (_hasTables || _hasStoredProcs || _hasTableValuedFunctions || _hasScalarValuedFunctions); } private bool CanWriteFakeContext() { return Settings.AddUnitTestingDbContext && Settings.ElementsToGenerate.HasFlag(Elements.Context) && (_hasTables || _hasStoredProcs || _hasTableValuedFunctions || _hasScalarValuedFunctions); } private bool CanWritePoco() { return Settings.ElementsToGenerate.HasFlag(Elements.Poco) && _hasTables; } private bool CanWritePocoConfiguration() { return Settings.ElementsToGenerate.HasFlag(Elements.PocoConfiguration) && _hasTables; } private bool CanWriteStoredProcReturnModel() { return Settings.ElementsToGenerate.HasFlag(Elements.Poco) && (_hasStoredProcs || _hasTableValuedFunctions); } private bool CanWriteEnums() { return Settings.ElementsToGenerate.HasFlag(Elements.Enum) && _hasEnums; } public string GenerateUsings(List usings) { return !usings.Any() ? null : Template.Transform(_template.Usings(), usings).Trim(); } public CodeOutput GenerateInterface() { var filename = Settings.DbContextInterfaceName + Settings.FileExtension; if (!CanWriteInterface()) { FileManagementService.DeleteFile(filename); return null; } var data = new InterfaceModel { interfaceModifier = Settings.DbContextInterfaceModifiers ?? "public partial", DbContextInterfaceName = Settings.DbContextInterfaceName, DbContextInterfaceBaseClasses = Settings.DbContextInterfaceBaseClasses, DbContextName = Settings.DbContextName, tables = _tables.Where(x => x.DbSetModifier == "public").ToList(), AdditionalContextInterfaceItems = Settings.AdditionalContextInterfaceItems.Where(x => !string.IsNullOrEmpty(x)).Distinct().ToList(), addSaveChanges = !Settings.UseInheritedBaseInterfaceFunctions, storedProcs = _storedProcs, hasStoredProcs = _hasStoredProcs, tableValuedFunctions = _tableValuedFunctions, scalarValuedFunctions = _scalarValuedFunctions, hasTableValuedFunctions = _hasTableValuedFunctions && _filter.IncludeTableValuedFunctions, hasScalarValuedFunctions = _hasScalarValuedFunctions && _filter.IncludeScalarValuedFunctions, }; var co = new CodeOutput(string.Empty, filename, "Database context interface", Settings.InterfaceFolder, _globalUsings); co.AddUsings(_template.DatabaseContextInterfaceUsings(data)); co.AddCode(Template.Transform(_template.DatabaseContextInterface(), data)); return co; } public CodeOutput GenerateContext() { var filename = Settings.DbContextName + Settings.FileExtension; if (!CanWriteContext()) { FileManagementService.DeleteFile(filename); return null; } var indexes = new List(); var hasSpatialTypes = false; var hasHierarchyIdType = false; foreach (var table in _tables) { var columns = table.Table.Columns .Where(x => !x.Hidden && !string.IsNullOrEmpty(x.Config)) .OrderBy(x => x.Ordinal) .ToList(); if (!Settings.DisableGeographyTypes && !hasSpatialTypes) hasSpatialTypes = columns.Any(x => x.IsSpatial); if (!hasHierarchyIdType && columns.Any(x => x.SqlPropertyType.Equals("hierarchyid", StringComparison.InvariantCultureIgnoreCase))) hasHierarchyIdType = true; indexes.AddRange(columns .Select(_generator.IndexModelBuilder) .Where(x => !string.IsNullOrWhiteSpace(x))); } var isEfCore3Plus = Settings.IsEfCore3Plus(); var data = new ContextModel { DbContextClassModifiers = Settings.DbContextClassModifiers, DbContextName = Settings.DbContextName, DbContextBaseClass = Settings.DbContextBaseClass, AddParameterlessConstructorToDbContext = Settings.AddParameterlessConstructorToDbContext, HasDefaultConstructorArgument = !string.IsNullOrEmpty(Settings.DefaultConstructorArgument), DefaultConstructorArgument = Settings.DefaultConstructorArgument, ConfigurationClassName = Settings.ConfigurationClassName, ConnectionString = Settings.ConnectionString, ConnectionStringName = Settings.ConnectionStringName, ConnectionStringActions = GetConnectionStringActions(hasSpatialTypes, hasHierarchyIdType), contextInterface = string.IsNullOrWhiteSpace(Settings.DbContextInterfaceName) ? "" : ", " + Settings.DbContextInterfaceName, setInitializer = string.Format("<{0}>(null);", Settings.DbContextName), DbContextClassIsPartial = Settings.DbContextClassIsPartial(), SqlCe = Settings.DatabaseType == DatabaseType.SqlCe, tables = _tables, hasTables = _hasTables, indexes = indexes, storedProcs = _storedProcs, hasStoredProcs = _hasStoredProcs, tableValuedFunctionComplexTypes = _tableValuedFunctionComplexTypes, hasTableValuedFunctionComplexTypes = _hasTableValuedFunctionComplexTypes, AdditionalContextInterfaceItems = Settings.AdditionalContextInterfaceItems.Where(x => !string.IsNullOrEmpty(x)).Distinct().ToList(), addSaveChanges = !Settings.UseInheritedBaseInterfaceFunctions, tableValuedFunctions = _tableValuedFunctions, scalarValuedFunctions = _scalarValuedFunctions, Sequences = _filter.Sequences, hasTableValuedFunctions = _hasTableValuedFunctions && _filter.IncludeTableValuedFunctions, hasScalarValuedFunctions = _hasScalarValuedFunctions && _filter.IncludeScalarValuedFunctions, IncludeObjectContextConstructor = !Settings.DbContextBaseClass.Contains("IdentityDbContext"), QueryString = isEfCore3Plus ? "Set" : "Query", FromSql = isEfCore3Plus ? "FromSqlRaw" : "FromSql", ExecuteSqlCommand = isEfCore3Plus ? "ExecuteSqlRaw" : "ExecuteSqlCommand", StoredProcModelBuilderCommand = isEfCore3Plus ? "Entity" : "Query", StoredProcModelBuilderPostCommand = isEfCore3Plus ? ".HasNoKey()" : string.Empty, OnConfigurationUsesConfiguration = Settings.OnConfiguration == OnConfiguration.Configuration, OnConfigurationUsesConnectionString = Settings.OnConfiguration == OnConfiguration.ConnectionString, DefaultSchema = Settings.DefaultSchema, UseDatabaseProvider = Settings.DatabaseProvider(), UseLazyLoadingProxies = Settings.UseLazyLoading && Settings.IsEfCore3Plus(), SqlParameter = Settings.SqlParameter(), SqlParameterValue = Settings.SqlParameterValue(), Triggers = _tables.Where(x => !string.IsNullOrEmpty(x.Table.TriggerName) || x.Table.Columns.Any(c => c.IsComputed)) .Select(x => new Trigger { TableName = x.Table.NameHumanCase, TriggerName = x.Table.TriggerName ?? "HasComputedColumn" }).ToList(), MemoryOptimisedTables = _tables.Where(x => x.Table.IsMemoryOptimised).Select(x => x.Table.NameHumanCase).ToList() }; data.hasIndexes = data.indexes.Any(); data.hasTriggers = data.Triggers.Any(); data.hasSequences = data.Sequences.Any(); data.hasMemoryOptimisedTables = data.MemoryOptimisedTables.Any(); var co = new CodeOutput(string.Empty, filename, "Database context", Settings.ContextFolder, _globalUsings); co.AddUsings(_template.DatabaseContextUsings(data)); co.AddCode(Template.Transform(_template.DatabaseContext(), data)); return co; } private static string GetConnectionStringActions(bool hasSpatialTypes, bool hasHierarchyIdType) { switch (Settings.TemplateType) { case TemplateType.Ef6: return string.Empty; case TemplateType.EfCore3: hasHierarchyIdType = false; break; } if (!hasSpatialTypes && !hasHierarchyIdType) return string.Empty; if (hasSpatialTypes && hasHierarchyIdType) return ", x => x.UseNetTopologySuite().UseHierarchyId()"; return hasSpatialTypes ? ", x => x.UseNetTopologySuite()" : ", x => x.UseHierarchyId()"; } public CodeOutput GenerateFakeContext() { var filename = "Fake" + Settings.DbContextName + Settings.FileExtension; if (!CanWriteFakeContext()) { FileManagementService.DeleteFile(filename); return null; } var data = new FakeContextModel { DbContextClassModifiers = Settings.DbContextClassModifiers, DbContextName = Settings.DbContextName, DbContextBaseClass = Settings.DbContextBaseClass, contextInterface = string.IsNullOrWhiteSpace(Settings.DbContextInterfaceName) ? "" : " : " + Settings.DbContextInterfaceName, DbContextClassIsPartial = Settings.DbContextClassIsPartial(), tables = _tables, storedProcs = _storedProcs, hasStoredProcs = _hasStoredProcs, tableValuedFunctions = _tableValuedFunctions, scalarValuedFunctions = _scalarValuedFunctions, hasTableValuedFunctions = _hasTableValuedFunctions && _filter.IncludeTableValuedFunctions, hasScalarValuedFunctions = _hasScalarValuedFunctions && _filter.IncludeScalarValuedFunctions, }; var co = new CodeOutput(string.Empty, filename, "Fake Database context", Settings.ContextFolder, _globalUsings); co.AddUsings(_template.FakeDatabaseContextUsings(data, _filter)); co.AddCode(Template.Transform(_template.FakeDatabaseContext(), data)); return co; } public CodeOutput GenerateFakeDbSet() { var filename = "FakeDbSet" + Settings.FileExtension; if (!CanWriteFakeContext()) { FileManagementService.DeleteFile(filename); return null; } var data = new FakeDbSetModel { DbContextClassModifiers = Settings.DbContextClassModifiers, DbContextClassIsPartial = Settings.DbContextClassIsPartial(), }; var co = new CodeOutput(string.Empty, filename, "Fake DbSet", Settings.ContextFolder, _globalUsings); co.AddUsings(_template.FakeDbSetUsings(data)); co.AddCode(Template.Transform(_template.FakeDbSet(), data)); return co; } public CodeOutput GenerateFactory() { var filename = Settings.DbContextName + "Factory" + Settings.FileExtension; if (!CanWriteFactory()) { FileManagementService.DeleteFile(filename); return null; } var data = new FactoryModel { classModifier = Settings.DbContextClassModifiers, contextName = Settings.DbContextName }; var co = new CodeOutput(string.Empty, filename, "Database context factory", Settings.ContextFolder, _globalUsings); co.AddUsings(_template.DatabaseContextFactoryUsings(data)); co.AddCode(Template.Transform(_template.DatabaseContextFactory(), data)); return co; } public CodeOutput GeneratePoco(Table table) { var filename = table.NameHumanCaseWithSuffix() + Settings.FileExtension; if (!CanWritePoco()) { FileManagementService.DeleteFile(filename); return null; } var isEfCore3Plus = Settings.IsEfCore3Plus(); var data = new PocoModel { UseHasNoKey = isEfCore3Plus && table.IsView && !table.HasPrimaryKey, HasNoPrimaryKey = !table.HasPrimaryKey, Name = table.DbName, NameHumanCaseWithSuffix = table.NameHumanCaseWithSuffix(), ClassModifier = Settings.EntityClassesModifiers, ClassComment = table.WriteComments(), ExtendedComments = table.WriteExtendedComments(), ClassAttributes = table.WriteClassAttributes(), BaseClasses = table.BaseClasses, InsideClassBody = Settings.WriteInsideClassBody(table), HasHierarchyId = table.Columns.Any(x => x.PropertyType.EndsWith("hierarchyid", StringComparison.InvariantCultureIgnoreCase)), Columns = table.Columns .Where(x => !x.Hidden && !x.ExistsInBaseClass) .OrderBy(x => x.Ordinal) .Select((col, index) => new PocoColumnModel { AddNewLineBefore = index > 0 && (((Settings.IncludeExtendedPropertyComments == CommentsStyle.InSummaryBlock || Settings.IncludeComments == CommentsStyle.InSummaryBlock) && !string.IsNullOrEmpty(col.SummaryComments)) || (col.Attributes != null && col.Attributes.Any())), HasSummaryComments = (Settings.IncludeExtendedPropertyComments == CommentsStyle.InSummaryBlock || Settings.IncludeComments == CommentsStyle.InSummaryBlock) && !string.IsNullOrEmpty(col.SummaryComments), SummaryComments = !string.IsNullOrEmpty(col.SummaryComments) ? SecurityElement.Escape(col.SummaryComments) : null, Attributes = col.Attributes, OverrideModifier = col.OverrideModifier, IncludeFieldNameConstants = Settings.IncludeFieldNameConstants, WrapIfNullable = col.WrapIfNullable(), NameHumanCase = col.NameHumanCase, PrivateSetterForComputedColumns = Settings.UsePrivateSetterForComputedColumns && col.IsComputed ? "private " : string.Empty, PropertyInitialisers = Settings.UsePropertyInitialisers ? (string.IsNullOrWhiteSpace(col.Default) ? string.Empty : string.Format(" = {0};", col.Default)) : string.Empty, InlineComments = col.InlineComments }) .ToList(), HasReverseNavigation = table.ReverseNavigationProperty.Count > 0, ReverseNavigationProperty = table.ReverseNavigationProperty .OrderBy(x => x.Definition) .Select(x => new PocoReverseNavigationPropertyModel { ReverseNavHasComment = Settings.IncludeComments != CommentsStyle.None && !string.IsNullOrEmpty(x.Comments), ReverseNavComment = Settings.IncludeComments != CommentsStyle.None ? x.Comments : string.Empty, AdditionalReverseNavigationsDataAnnotations = Settings.AdditionalReverseNavigationsDataAnnotations, AdditionalDataAnnotations = x.AdditionalDataAnnotations, Definition = x.Definition }) .ToList(), HasForeignKey = table.HasForeignKey, ForeignKeyTitleComment = Settings.IncludeComments != CommentsStyle.None && table.Columns.SelectMany(x => x.EntityFk).Any() ? " // Foreign keys" + Environment.NewLine : string.Empty, ForeignKeys = table.Columns .SelectMany(x => x.EntityFk) .OrderBy(o => o.Definition) .Select(x => new PocoForeignKeyModel { HasFkComment = Settings.IncludeComments != CommentsStyle.None && !string.IsNullOrEmpty(x.Comments), FkComment = x.Comments, AdditionalForeignKeysDataAnnotations = Settings.AdditionalForeignKeysDataAnnotations, AdditionalDataAnnotations = x.AdditionalDataAnnotations, Definition = x.Definition }) .ToList(), CreateConstructor = !Settings.UsePropertyInitialisers && ( table.Columns.Any(c => c.Default != string.Empty && !c.Hidden) || table.ReverseNavigationCtor.Any() || Settings.EntityClassesArePartial() ), ColumnsWithDefaults = table.Columns .Where(c => c.Default != string.Empty && !c.Hidden && Settings.IncludeColumnsWithDefaults) .OrderBy(x => x.Ordinal) .Select(x => new PocoColumnsWithDefaultsModel { NameHumanCase = x.NameHumanCase, Default = x.Default }) .ToList(), ReverseNavigationCtor = table.ReverseNavigationCtor, EntityClassesArePartial = Settings.EntityClassesArePartial(), HasSpatial = table.Columns.Any(x => x.IsSpatial) }; var co = new CodeOutput(table.DbName, filename, null, Settings.PocoFolder, _globalUsings); co.AddUsings(_template.PocoUsings(data)); co.AddCode(Template.Transform(_template.Poco(), data)); return co; } public CodeOutput GeneratePocoConfiguration(Table table) { var filename = table.NameHumanCaseWithSuffix() + Settings.ConfigurationClassName + Settings.FileExtension; if (!CanWritePocoConfiguration()) { FileManagementService.DeleteFile(filename); return null; } var columns = table.Columns .Where(x => !x.Hidden && !string.IsNullOrEmpty(x.Config)) .OrderBy(x => x.Ordinal) .ToList(); var isEfCore3Plus = Settings.IsEfCore3Plus(); var foreignKeys = columns.SelectMany(x => x.ConfigFk).OrderBy(o => o).ToList(); var primaryKey = _generator.PrimaryKeyModelBuilder(table); var indexes = _generator.IndexModelBuilder(table); var hasIndexes = indexes != null && indexes.Any(); var data = new PocoConfigurationModel { UseHasNoKey = isEfCore3Plus && table.IsView && !table.HasPrimaryKey, Name = table.DbName, ToTableOrView = (isEfCore3Plus && table.IsView && !table.HasPrimaryKey) ? "ToView" : "ToTable", ConfigurationClassName = table.NameHumanCaseWithSuffix() + Settings.ConfigurationClassName, NameHumanCaseWithSuffix = table.NameHumanCaseWithSuffix(), Schema = table.Schema.DbName, PrimaryKeyNameHumanCase = primaryKey ?? table.PrimaryKeyNameHumanCase(), NotUsingDataAnnotations = !Settings.UseDataAnnotations, HasSchema = !string.IsNullOrEmpty(table.Schema.DbName), ClassModifier = Settings.ConfigurationClassesModifiers, ClassComment = table.WriteComments(), Columns = columns.Select(x => x.Config).ToList(), HasReverseNavigation = table.ReverseNavigationProperty.Count > 0, UsesDictionary = table.UsesDictionary, HasSpatial = table.Columns.Any(x => x.IsSpatial), ReverseNavigationProperty = table.ReverseNavigationProperty .OrderBy(x => x.Definition) .Select(x => new PocoReverseNavigationPropertyModel { ReverseNavHasComment = Settings.IncludeComments != CommentsStyle.None && !string.IsNullOrEmpty(x.Comments), ReverseNavComment = Settings.IncludeComments != CommentsStyle.None ? x.Comments : string.Empty, AdditionalReverseNavigationsDataAnnotations = Settings.AdditionalReverseNavigationsDataAnnotations, AdditionalDataAnnotations = x.AdditionalDataAnnotations, Definition = x.Definition }) .ToList(), HasForeignKey = foreignKeys.Any(), ForeignKeys = foreignKeys, MappingConfiguration = table.MappingConfiguration, ConfigurationClassesArePartial = Settings.ConfigurationClassesArePartial(), Indexes = indexes, HasIndexes = hasIndexes }; var co = new CodeOutput(table.DbName, filename, null, Settings.PocoConfigurationFolder, _globalUsings); co.AddUsings(_template.PocoConfigurationUsings(data)); co.AddCode(Template.Transform(_template.PocoConfiguration(), data)); return co; } public CodeOutput GenerateStoredProcReturnModel(StoredProcedure sp) { var filename = sp.WriteStoredProcReturnModelName(_filter) + Settings.FileExtension; if (!CanWriteStoredProcReturnModel()) { FileManagementService.DeleteFile(filename); return null; } var multipleModelReturnColumns = new List(); var model = 0; foreach (var returnModel in sp.ReturnModels) { multipleModelReturnColumns.Add(new MultipleModelReturnColumns(++model, returnModel.Select(sp.WriteStoredProcReturnColumn).ToList())); } var data = new StoredProcReturnModel { ResultClassModifiers = Settings.ResultClassModifiers, WriteStoredProcReturnModelName = sp.WriteStoredProcReturnModelName(_filter), PropertyGetSet = Settings.UsePropertiesForStoredProcResultSets ? " { get; set; }" : ";", SingleModel = sp.ReturnModels.Count == 1, SingleModelReturnColumns = sp.ReturnModels .First() .Select(sp.WriteStoredProcReturnColumn) .ToList(), MultipleModelReturnColumns = multipleModelReturnColumns }; var co = new CodeOutput(sp.DbName, filename, null, Settings.PocoFolder, _globalUsings); co.AddUsings(_template.StoredProcReturnModelUsings()); co.AddCode(Template.Transform(_template.StoredProcReturnModels(), data)); return co; } public CodeOutput GenerateEnum(Enumeration enumeration) { var filename = enumeration.EnumName + Settings.FileExtension; if (!CanWriteEnums()) { FileManagementService.DeleteFile(filename); return null; } var co = new CodeOutput(enumeration.EnumName, filename, null, Settings.PocoFolder, null); co.AddUsings(_template.EnumUsings()); co.AddCode(Template.Transform(_template.Enums(), enumeration)); return co; } } public class CodeOutput { public string DbName { get; private set; } public string Filename { get; private set; } public string Region { get; private set; } public List Usings { get; private set; } public List Code { get; private set; } public CodeOutput(string dbName, string filename, string region, string folder, List usings) { DbName = dbName; Filename = filename; Region = region; Usings = new List(); Code = new List(); if (!string.IsNullOrWhiteSpace(folder)) Filename = Path.Combine(folder, filename); AddUsings(usings); } public void AddCode(string code) { if (code != null) Code.AddRange(code.Split(new[] { Environment.NewLine }, StringSplitOptions.None)); } public void AddUsings(List usings) { if (usings == null || !usings.Any()) return; Usings.AddRange(usings); Usings = Usings.Where(x => x != null).Distinct().ToList(); } public List GetUsings() { return Usings .Distinct() .OrderBy(x => x) .ToList(); } } public class CodeOutputList { public readonly Dictionary Files; // List of code files public CodeOutputList() { Files = new Dictionary(); } public void Add(string key, CodeOutput code) { if (code != null) { if (Files.ContainsKey(key)) { var error = string.Format("{0} already exists in the code output list. {1} and {2} both resolve to the same C# name. Filter one of them out.", key, Files[key].DbName, code.DbName); throw new Exception(error); } Files.Add(key, code); } } public List GetUsings() { var usings = new List(); foreach (var codeOutput in Files) { usings.AddRange(codeOutput.Value.Usings); } return usings .Distinct() .OrderBy(x => x) .ToList(); } } public class ColumnAndForeignKey { public ForeignKey ForeignKey; public Column Column; } public class FileHeaderFooter { public readonly string Header; public readonly string Namespace; public readonly string Footer; public FileHeaderFooter(string subNamespace) { var header = new StringBuilder(1024); header.AppendLine("// "); if (Settings.UseResharper) header.AppendLine("// ReSharper disable All"); if (Settings.AllowNullStrings) header.AppendLine("#nullable enable"); if (Settings.UsePragma) header.AppendLine("#pragma warning disable 1591 // Ignore \"Missing XML Comment\" warning"); foreach (var additionalHeader in Settings.AdditionalFileHeaderText) { header.AppendLine(additionalHeader); } Header = header.ToString(); header = new StringBuilder(500); if (Settings.UseNamespace) { var name = Settings.Namespace + subNamespace; header.AppendLine("namespace " + name.Trim().Replace(' ', '_')); header.Append("{"); } Namespace = header.ToString(); var footer = new StringBuilder(30); if (Settings.UseNamespace) footer.AppendLine("}"); foreach (var additionalHeader in Settings.AdditionalFileFooterText) { footer.AppendLine(additionalHeader); } footer.Append("// "); Footer = footer.ToString(); } } // ReSharper disable UseStringInterpolation public abstract class Generator { public bool InitialisationOk { get; private set; } protected DatabaseReader DatabaseReader; public readonly IDbContextFilterList FilterList; protected abstract bool AllowFkToNonPrimaryKey(); protected abstract bool FkMustHaveSameNumberOfColumnsAsPrimaryKey(); protected abstract void SetupEntity(Column c); protected abstract void SetupConfig(Column c); public abstract string PrimaryKeyModelBuilder(Table table); public abstract List IndexModelBuilder(Table t); public abstract string IndexModelBuilder(Column c); protected abstract string GetHasMethod(Relationship relationship, IList fkCols, IList pkCols, bool isNotEnforced, bool fkHasUniqueConstraint); protected abstract string GetWithMethod(Relationship relationship, IList fkCols, string fkPropName, string manyToManyMapping, string mapKey, bool includeReverseNavigation, string hasMethod, string pkTableNameHumanCase, string fkTableNameHumanCase, string primaryKeyColumns, bool fkHasUniqueConstraint); protected abstract string GetCascadeOnDelete(bool cascadeOnDelete); protected abstract string GetForeignKeyConstraintName(string foreignKeyConstraintName); private bool _hasAcademicLicence; private bool _hasTrialLicence; private FileHeaderFooter _fileHeaderFooter; private readonly StringBuilder _preHeaderInfo; private readonly string _codeGeneratedAttribute; private readonly FileManagementService _fileManagementService; private readonly Type _fileManagerType; private const int Indent = 4; protected Generator(FileManagementService fileManagementService, Type fileManagerType) { _fileManagementService = fileManagementService; _fileManagerType = fileManagerType; InitialisationOk = false; DatabaseReader = null; _fileHeaderFooter = null; _preHeaderInfo = new StringBuilder(1024); _codeGeneratedAttribute = string.Format("[GeneratedCode(\"EF.Reverse.POCO.Generator\", \"{0}\")]", EfrpgVersion.Version()); FilterList = new DbContextFilterList(); } public void Init(DatabaseReader databaseReader, string singleDbContextSubNamespace) { if (Settings.ConnectionString.Contains("**TODO**")) { _fileManagementService.Error("// Please update your .tt file's `Settings.ConnectionString` string to the database you want to reverse engineer and save your .tt file."); return; } var licence = ReadAndValidateLicence(); if(licence == null) return; BuildPreHeaderInfo(licence); DatabaseReader = databaseReader; if (DatabaseReader == null) { _fileManagementService.Error("// Cannot create a database reader due to unknown database type."); return; } DatabaseReader.Init(); if (Settings.IncludeConnectionSettingComments) _preHeaderInfo.Append(DatabaseDetails()); if (Settings.UseDataAnnotations) { Settings.AdditionalNamespaces.Add("System.ComponentModel.DataAnnotations"); Settings.AdditionalNamespaces.Add("System.ComponentModel.DataAnnotations.Schema"); } _hasAcademicLicence = licence.LicenceType == LicenceType.Academic; _hasTrialLicence = licence.LicenceType == LicenceType.Trial; InitialisationOk = FilterList.ReadDbContextSettings(DatabaseReader, singleDbContextSubNamespace); _fileManagementService.Init(FilterList.GetFilters(), _fileManagerType); } public string GetPreHeaderInfo() { return _preHeaderInfo.ToString(); } private Licence ReadAndValidateLicence() { var path = Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments); var file = Path.Combine(path, "ReversePOCO.txt"); const string obtainAt = "// Please obtain your licence file at www.ReversePOCO.co.uk, and place it in your documents folder shown above."; if (!File.Exists(file)) { _fileManagementService.Error(string.Format("// Licence file {0} not found.", file)); _fileManagementService.Error(obtainAt); return TrialLicenceFallback(); } var validator = new LicenceValidator(); if(!validator.Validate(File.ReadAllText(file))) { _fileManagementService.Error(validator.Expired ? string.Format("// Your licence file {0} has expired.", file) : string.Format("// Your licence file {0} is not valid.", file)); _fileManagementService.Error(obtainAt); return TrialLicenceFallback(); } return validator.Licence; // Thank you for having a valid licence and supporting this product :-) } private Licence TrialLicenceFallback() { _fileManagementService.Error("// Defaulting to Trial version."); return new Licence(string.Empty, string.Empty, LicenceType.Trial, "1", DateTime.MaxValue); } public string DatabaseDetails() { return DatabaseReader.GetDatabaseDetails(); } public void LoadEnums() { if (DatabaseReader == null || !Settings.ElementsToGenerate.HasFlag(Elements.Enum)) return; try { foreach (var filterKeyValuePair in FilterList.GetFilters()) { var filter = filterKeyValuePair.Value; foreach (var table in filter.Tables) { filter.AddEnum(table); } } if (Settings.GenerateSingleDbContext) { // Single-context if (Settings.Enumerations == null) return; // No enums required var enumerations = DatabaseReader.ReadEnums(Settings.Enumerations); if (enumerations.Count <= 0) return; // No enums in database foreach (var filterKeyValuePair in FilterList.GetFilters()) { filterKeyValuePair.Value.Enums.AddRange(enumerations); } } else { // Multi-context foreach (var filterKeyValuePair in FilterList.GetFilters()) { var multiContextSetting = ((MultiContextFilter) filterKeyValuePair.Value).GetSettings(); if (multiContextSetting?.Enumerations == null || multiContextSetting.Enumerations.Count == 0) continue; var enumerations = DatabaseReader.ReadEnums(multiContextSetting.Enumerations); if (enumerations.Count > 0) filterKeyValuePair.Value.Enums.AddRange(enumerations); } } foreach (var filterKeyValuePair in FilterList.GetFilters()) { var filter = filterKeyValuePair.Value; foreach (var enumeration in filter.Enums) { filter.UpdateEnum(enumeration); foreach (var enumerationMember in enumeration.Items) { filter.UpdateEnumMember(enumerationMember); } } } // Remove tables marked as RemoveTable // This means it was only required to generate an enum and can now be removed foreach (var filter in FilterList.GetFilters().Select(filterKeyValuePair => filterKeyValuePair.Value)) { filter.Tables.RemoveAll(x => x.RemoveTable); } } catch (Exception x) { var error = FormatError(x); _fileManagementService.Error(string.Empty); _fileManagementService.Error("// -----------------------------------------------------------------------------------------"); _fileManagementService.Error(string.Format("// Failed to read enumeration tables in LoadEnums() - {0}", error)); _fileManagementService.Error("/*" + x.StackTrace + "*/"); _fileManagementService.Error("// -----------------------------------------------------------------------------------------"); _fileManagementService.Error(string.Empty); } } public void LoadSequences() { if (DatabaseReader == null || !Settings.ElementsToGenerate.HasFlag(Elements.Context)) return; try { var sequences = DatabaseReader.ReadSequences(); if (sequences.Count <= 0) return; // No sequences in database foreach (var filterKeyValuePair in FilterList.GetFilters()) { // Only add sequences where the table is used by this filter foreach (var seq in sequences .Where(seq => seq.TableMapping .Any(tableMapping => filterKeyValuePair.Value.Tables .Any(x => x.Schema.DbName.Equals(tableMapping.TableSchema, StringComparison.InvariantCultureIgnoreCase) && x.DbName.Equals(tableMapping.TableName, StringComparison.InvariantCultureIgnoreCase))))) { filterKeyValuePair.Value.Sequences.Add(seq); } } } catch (Exception x) { var error = FormatError(x); _fileManagementService.Error(string.Empty); _fileManagementService.Error("// -----------------------------------------------------------------------------------------"); _fileManagementService.Error(string.Format("// Failed to read sequences in LoadSequences() - {0}", error)); _fileManagementService.Error("/*" + x.StackTrace + "*/"); _fileManagementService.Error("// -----------------------------------------------------------------------------------------"); _fileManagementService.Error(string.Empty); } } public void ReadDatabase() { LoadTables(); LoadStoredProcs(); LoadEnums(); LoadSequences(); } public void LoadTables() { if (DatabaseReader == null || !(Settings.ElementsToGenerate.HasFlag(Elements.Poco) || Settings.ElementsToGenerate.HasFlag(Elements.Context) || Settings.ElementsToGenerate.HasFlag(Elements.Interface) || Settings.ElementsToGenerate.HasFlag(Elements.PocoConfiguration))) return; try { var includeSynonyms = FilterList.IncludeSynonyms(); var rawTables = DatabaseReader.ReadTables(includeSynonyms); var rawIndexes = DatabaseReader.ReadIndexes(); var rawForeignKeys = DatabaseReader.ReadForeignKeys(includeSynonyms); // For unit testing //foreach (var ri in rawIndexes.OrderBy(x => x.TableName).ThenBy(x => x.IndexName)) Console.WriteLine(ri.Dump()); //foreach (var rfk in rawForeignKeys) Console.WriteLine(rfk.Dump()); AddTablesToFilters(rawTables); IdentifyUniqueForeignKeys(rawIndexes, rawForeignKeys); AddIndexesToFilters(rawIndexes); SetPrimaryKeys(); AddForeignKeysToFilters(rawForeignKeys); if (Settings.IsEfCore6Plus()) { var rawMemoryOptimisedTables = DatabaseReader.ReadMemoryOptimisedTables(); AddMemoryOptimisedTablesToFilters(rawMemoryOptimisedTables); } if (Settings.IsEfCore7Plus()) { var rawTriggers = DatabaseReader.ReadTriggers(); AddTriggersToFilters(rawTriggers); } if (Settings.IncludeExtendedPropertyComments != CommentsStyle.None) AddExtendedPropertiesToFilters(DatabaseReader.ReadExtendedProperties()); SetupEntityAndConfig(); // Must be done last } catch (Exception x) { var error = FormatError(x); _fileManagementService.Error(string.Empty); _fileManagementService.Error("// -----------------------------------------------------------------------------------------"); _fileManagementService.Error(string.Format("// Failed to read database schema in LoadTables() - {0}", error)); _fileManagementService.Error("/*" + x.StackTrace + "*/"); _fileManagementService.Error("// -----------------------------------------------------------------------------------------"); _fileManagementService.Error(string.Empty); } } public static void IdentifyUniqueForeignKeys(List rawIndexes, List rawForeignKeys) { if (rawIndexes == null || rawForeignKeys == null || !rawIndexes.Any() || !rawForeignKeys.Any()) return; var uniqueForeignKeys = from i in rawIndexes.Where(x => x.IsUniqueConstraint) join fk1 in rawForeignKeys on new { X1 = i.Schema, X2 = i.TableName } equals new { X1 = fk1.PkSchema, X2 = fk1.PkTableName } select fk1; foreach (var fk in uniqueForeignKeys) fk.HasUniqueConstraint = true; } // Create tables from raw data for each of the DbContextFilters private void AddTablesToFilters(List rawTables) { if (rawTables == null || !rawTables.Any()) return; var tablesNames = rawTables .Select(x => new { x.SchemaName, x.TableName, x.IsView }) .Distinct() .OrderBy(x => x.SchemaName) .ThenBy(x => x.TableName) .ToList(); #pragma warning disable CS0618 // Type or member is obsolete var deleteFilteredOutFiles = (Settings.FileManagerType == FileManagerType.Custom || Settings.FileManagerType == FileManagerType.EfCore) && Settings.GenerateSeparateFiles; #pragma warning restore CS0618 // Type or member is obsolete foreach (var filterKeyValuePair in FilterList.GetFilters()) { var filter = filterKeyValuePair.Value; foreach (var tn in tablesNames) { var exclude = tn.IsView && !filter.IncludeViews; if(exclude && !deleteFilteredOutFiles) continue; // Check if schema is excluded var schema = new Schema(tn.SchemaName); if (filter.IsExcluded(schema)) { exclude = true; if (!deleteFilteredOutFiles) continue; } // Check if table is excluded var table = new Table(filter, schema, tn.TableName, tn.IsView); if (filter.IsExcluded(table)) { exclude = true; if (!deleteFilteredOutFiles) continue; } // Handle table names with underscores - singularise just the last word var tableName = DatabaseReader.CleanUp(filter.TableRename(tn.TableName, tn.SchemaName, tn.IsView)); var singularCleanTableName = Inflector.MakeSingular(tableName); table.NameHumanCase = (Settings.UsePascalCase ? Inflector.ToTitleCase(singularCleanTableName) : singularCleanTableName).Replace(" ", "").Replace("$", "").Replace(".", ""); if (Settings.PrependSchemaName && string.Compare(table.Schema.DbName, Settings.DefaultSchema, StringComparison.OrdinalIgnoreCase) != 0) table.NameHumanCase = table.Schema.DbName + "_" + table.NameHumanCase; if (filter.IsExcluded(table)) // Retest exclusion after table rename { exclude = true; if (!deleteFilteredOutFiles) continue; } if(exclude) { FileManagementService.DeleteFile(table.NameHumanCaseWithSuffix() + Settings.FileExtension); // Poco FileManagementService.DeleteFile(table.NameHumanCaseWithSuffix() + Settings.ConfigurationClassName + Settings.FileExtension); // Poco config continue; } // Check for table or C# name clashes if (DatabaseReader.ReservedKeywords.Contains(table.NameHumanCase) || (Settings.UsePascalCase && filter.Tables.Find(x => x.NameHumanCase == table.NameHumanCase) != null)) { table.NameHumanCase += "1"; } // Create columns for table foreach (var rawTable in rawTables .Where(x => x.SchemaName == tn.SchemaName && x.TableName == tn.TableName) .OrderBy(x => x.Ordinal)) { table.IsSynonym = table.IsSynonym || rawTable.IsSynonym; var column = DatabaseReader.CreateColumn(rawTable, table, filter); if (column != null) table.Columns.Add(column); } // Check for property name clashes in columns foreach (var c in table.Columns.Where(c => table.Columns.FindAll(x => x.NameHumanCase == c.NameHumanCase).Count > 1)) { var n = 1; var original = c.NameHumanCase; c.NameHumanCase = original + n++; // Check if the above resolved the name clash, if not, use next value while (c.ParentTable.Columns.Count(c2 => c2.NameHumanCase == c.NameHumanCase) > 1) c.NameHumanCase = original + n++; } filter.Tables.Add(table); } foreach (var table in filter.Tables) { if (table.IsView) filter.ViewProcessing(table); filter.UpdateTable(table); foreach (var column in table.Columns) filter.UpdateColumn(column, table); table.Suffix = Settings.TableSuffix; } } } private void AddIndexesToFilters(List rawIndexes) { if (rawIndexes == null || !rawIndexes.Any()) return; var indexTables = rawIndexes .Select(x => new { x.Schema, x.TableName }) .Distinct() .OrderBy(x => x.Schema) .ThenBy(x => x.TableName) .ToList(); foreach (var filterKeyValuePair in FilterList.GetFilters()) { var filter = filterKeyValuePair.Value; Table t = null; foreach (var indexTable in indexTables) { // Lookup table if (t == null || t.DbName != indexTable.TableName || t.Schema.DbName != indexTable.Schema) t = filter.Tables.GetTable(indexTable.TableName, indexTable.Schema); if (t == null) continue; // Find indexes for table t.Indexes = rawIndexes.Where(x => x.Schema == indexTable.Schema && x.TableName == indexTable.TableName) .OrderBy(o => o.ColumnCount) .ThenBy(o => o.KeyOrdinal) .ToList(); // Set index on column foreach (var index in t.Indexes) { var col = t.Columns.Find(x => x.DbName == index.ColumnName); if (col == null) continue; col.Indexes.Add(index); col.IsPrimaryKey = col.IsPrimaryKey || index.IsPrimaryKey; col.IsUniqueConstraint = col.IsUniqueConstraint || (index.IsUniqueConstraint && index.ColumnCount == 1); col.IsUnique = col.IsUnique || (index.IsUnique && index.ColumnCount == 1); } // Check if table has any primary keys if (t.PrimaryKeys.Any()) continue; // Already has a primary key, ignore this unique index / constraint // Find unique indexes for table var uniqueIndexKeys = t.Indexes .Where(x => x.IsUnique || x.IsPrimaryKey || x.IsUniqueConstraint) .OrderBy(o => o.ColumnCount) .ThenBy(o => o.KeyOrdinal); // Process only the first index with the lowest unique column count string indexName = null; foreach (var key in uniqueIndexKeys) { if (indexName == null) indexName = key.IndexName; if (indexName != key.IndexName) break; // First unique index with lowest column count has been processed, exit. var col = t.Columns.Find(x => x.DbName == key.ColumnName); if (col != null && !col.IsNullable && !col.Hidden && !col.IsPrimaryKey) { col.IsPrimaryKey = true; col.IsUniqueConstraint = true; col.IsUnique = true; col.UniqueIndexName = indexName; } } } } } private void AddForeignKeysToFilters(List rawForeignKeys) { if (Settings.GenerateSingleDbContext && (rawForeignKeys == null || !rawForeignKeys.Any())) return; if (rawForeignKeys == null) rawForeignKeys = new List(); //else //SortForeignKeys(rawForeignKeys); foreach (var filterKeyValuePair in FilterList.GetFilters()) { var filter = filterKeyValuePair.Value; var fks = new List(); fks.AddRange(rawForeignKeys/*.OrderBy(x => x.SortOrder).ThenBy(x => x.FkTableName).ThenBy(x => x.PkTableName)*/); if (!Settings.GenerateSingleDbContext) { var multiContextSetting = ((MultiContextFilter) filter).GetSettings(); if (multiContextSetting?.ForeignKeys != null) { fks.AddRange(multiContextSetting.ForeignKeys.Select(x => new RawForeignKey(x.ConstraintName, x.ParentName, x.ChildName, x.PkColumn, x.FkColumn, x.PkSchema, x.PkTableName, x.FkSchema, x.FkTableName, x.Ordinal, x.CascadeOnDelete, x.IsNotEnforced, x.HasUniqueConstraint))); } } if (!fks.Any()) continue; var foreignKeys = new List(); foreach (var rawForeignKey in fks) { var fkTableNameFiltered = filter.TableRename(rawForeignKey.FkTableName, rawForeignKey.FkSchema, false); var pkTableNameFiltered = filter.TableRename(rawForeignKey.PkTableName, rawForeignKey.PkSchema, false); var fk = new ForeignKey(rawForeignKey, fkTableNameFiltered, pkTableNameFiltered); var filteredFk = filter.ForeignKeyFilter(fk); if (filteredFk != null) { if (Settings.ForeignKeyFilterFunc != null) filteredFk = Settings.ForeignKeyFilterFunc(filteredFk); if (filteredFk != null) foreignKeys.Add(filteredFk); } } IdentifyForeignKeys(foreignKeys, filter.Tables); Settings.AddExtraForeignKeys?.Invoke(filter, this, foreignKeys, filter.Tables); // Work out if there are any foreign key relationship naming clashes ProcessForeignKeys(foreignKeys, true, filter); // Mappings tables can only be true for Ef6 and EFCore 5 onwards if (Settings.UseMappingTables && !(Settings.IsEf6() || Settings.IsEfCore6Plus())) Settings.UseMappingTables = false; if (Settings.UseMappingTables) filter.Tables.IdentifyMappingTables(foreignKeys, true, DatabaseReader.IncludeSchema); // Now we know our foreign key relationships and have worked out if there are any name clashes, // re-map again with intelligently named relationships. filter.Tables.ResetNavigationProperties(); ProcessForeignKeys(foreignKeys, false, filter); if (Settings.UseMappingTables) filter.Tables.IdentifyMappingTables(foreignKeys, false, DatabaseReader.IncludeSchema); } } /*private void SortForeignKeys(List rawForeignKeys) { foreach (var fk in rawForeignKeys) { fk.SortOrder = 10; var fkColumn = fk.FkColumn.ToLowerInvariant(); var pkTable = fk.PkTableName.ToLowerInvariant(); // Matches exactly if (fkColumn == pkTable) { fk.SortOrder = 1; continue; } // Matches without 'id' if(fkColumn.EndsWith("id") && fkColumn.Remove(fkColumn.Length - 2, 2) == pkTable) { fk.SortOrder = 2; continue; } // Matches if trimmed if(fkColumn.Length > pkTable.Length && fkColumn.Substring(0, pkTable.Length) == pkTable) { fk.SortOrder = 3; continue; } } }*/ private void AddTriggersToFilters(List triggers) { if (triggers == null || !triggers.Any()) return; foreach (var filterKeyValuePair in FilterList.GetFilters()) { var filter = filterKeyValuePair.Value; Table t = null; foreach (var trigger in triggers) { // Lookup table if (t == null || t.DbName != trigger.TableName || t.Schema.DbName != trigger.SchemaName) t = filter.Tables.GetTable(trigger.TableName, trigger.SchemaName); if (t == null) continue; // Only store the one trigger name as EFCore 7 does not care what its name is. It only cares that there is one present. t.TriggerName = trigger.TriggerName; } } } private void AddMemoryOptimisedTablesToFilters(List memoryOptimisedTables) { if (memoryOptimisedTables == null || !memoryOptimisedTables.Any()) return; foreach (var filterKeyValuePair in FilterList.GetFilters()) { var filter = filterKeyValuePair.Value; Table t = null; foreach (var trigger in memoryOptimisedTables) { // Lookup table if (t == null || t.DbName != trigger.TableName || t.Schema.DbName != trigger.SchemaName) t = filter.Tables.GetTable(trigger.TableName, trigger.SchemaName); if (t == null) continue; t.IsMemoryOptimised = true; } } } private void AddExtendedPropertiesToFilters(List extendedProperties) { if (extendedProperties == null || !extendedProperties.Any()) return; var commentsInSummaryBlock = Settings.IncludeExtendedPropertyComments == CommentsStyle.InSummaryBlock; var multiLine = new Regex("[\r\n]+", RegexOptions.Compiled); var whiteSpace = new Regex("\\s+", RegexOptions.Compiled); foreach (var filterKeyValuePair in FilterList.GetFilters()) { var filter = filterKeyValuePair.Value; Table t = null; foreach (var extendedProperty in extendedProperties) { // Lookup table if (t == null || t.DbName != extendedProperty.TableName || t.Schema.DbName != extendedProperty.SchemaName) t = filter.Tables.GetTable(extendedProperty.TableName, extendedProperty.SchemaName); if (t == null) continue; if (extendedProperty.TableLevelExtendedComment) { // Table level extended comment t.ExtendedProperty.Add(multiLine.Replace(extendedProperty.ExtendedProperty, "\r\n /// ")); continue; } // Column level extended comment var col = t.Columns.Find(x => x.DbName == extendedProperty.ColumnName); if (col == null) continue; if (commentsInSummaryBlock) col.ExtendedProperty = multiLine.Replace(extendedProperty.ExtendedProperty, "\r\n /// "); else col.ExtendedProperty = whiteSpace.Replace(multiLine.Replace(extendedProperty.ExtendedProperty, " "), " "); } } } private void SetPrimaryKeys() { foreach (var filterKeyValuePair in FilterList.GetFilters()) { var filter = filterKeyValuePair.Value; foreach (var table in filter.Tables) { table.SetPrimaryKeys(); } if (_hasTrialLicence) filter.Tables.TrimForTrialLicence(); } } private void SetupEntityAndConfig() { foreach (var filterKeyValuePair in FilterList.GetFilters()) { var filter = filterKeyValuePair.Value; foreach (var table in filter.Tables) { table.Columns.ForEach(SetupEntityAndConfig); } } } public void LoadStoredProcs() { if (DatabaseReader == null || !DatabaseReader.CanReadStoredProcedures()) return; try { #pragma warning disable CS0618 // Type or member is obsolete var deleteFilteredOutFiles = (Settings.FileManagerType == FileManagerType.Custom || Settings.FileManagerType == FileManagerType.EfCore) && Settings.GenerateSeparateFiles; #pragma warning restore CS0618 // Type or member is obsolete var spFilters = FilterList .GetFilters() .Where(x => x.Value.IncludeStoredProcedures || x.Value.IncludeTableValuedFunctions || x.Value.IncludeScalarValuedFunctions) .ToList(); if (!spFilters.Any()) return; var includeSynonyms = FilterList.IncludeSynonyms(); var rawStoredProcs = DatabaseReader.ReadStoredProcs(includeSynonyms); // Only call stored procedures to obtain the return models that are not filtered out // We don't want to do this for every db context we are generating as that is inefficient var procs = rawStoredProcs .Select(sp => new { sp.Schema, sp.Name, sp.IsTableValuedFunction, sp.IsScalarValuedFunction, sp.IsStoredProcedure }) .Distinct() .OrderBy(x => x.Schema) .ThenBy(x => x.Name); var storedProcs = new List(); foreach (var proc in procs) { var sp = new StoredProcedure { DbName = proc.Name, NameHumanCase = (Settings.UsePascalCase ? Inflector.ToTitleCase(proc.Name) : proc.Name).Replace(" ", "").Replace("$", ""), Schema = new Schema(proc.Schema), IsTableValuedFunction = proc.IsTableValuedFunction, IsScalarValuedFunction = proc.IsScalarValuedFunction, IsStoredProcedure = proc.IsStoredProcedure }; sp.NameHumanCase = DatabaseReader.CleanUp(sp.NameHumanCase); if (Settings.PrependSchemaName && (string.Compare(proc.Schema, Settings.DefaultSchema, StringComparison.OrdinalIgnoreCase) != 0)) sp.NameHumanCase = proc.Schema + "_" + sp.NameHumanCase; sp.Parameters.AddRange(rawStoredProcs .Where(x => x.Parameter != null && x.Schema == proc.Schema && x.Name == proc.Name) .Select(x => x.Parameter)); sp.HasSpatialParameter = sp.Parameters.Any(x => x.IsSpatial); if (Settings.DisableGeographyTypes && sp.HasSpatialParameter) continue; // Ignore stored procedure due to spatial parameter // Check to see if this stored proc is to be kept by any of the filters if (spFilters.All(x => x.Value.IsExcluded(sp))) { if(deleteFilteredOutFiles) FileManagementService.DeleteFile(sp.WriteStoredProcReturnModelName(spFilters[0].Value) + Settings.FileExtension); continue; // All Db Context exclude this stored proc, ignore it as nobody wants it } storedProcs.Add(sp); } if (!storedProcs.Any()) return; // No stored procs to read the return model for, so exit // Read in the return objects for the wanted stored proc DatabaseReader.ReadStoredProcReturnObjects(storedProcs); // Check if any of the stored proc return models have spatial types /*foreach (var sp in storedProcs) { if(sp.ReturnModels.Any()) { // todo } }*/ // Force generation of Async stored procs /*foreach (var sp in storedProcs.Where(x => !x.IsTableValuedFunction && !x.ReturnModels.Any())) { sp.ReturnModels.Add(new List { new DataColumn("result", typeof(int)) }); }*/ // Remove stored procs where the return model type contains spaces and cannot be mapped // Also need to remove any TVF functions with parameters that are non scalar types, such as DataTable var validStoredProcs = new List(); foreach (var sp in storedProcs) { if (!sp.ReturnModels.Any()) { validStoredProcs.Add(sp); continue; } if (sp.ReturnModels.Any(returnColumns => returnColumns.Any(c => c.ColumnName.Contains(" ")))) continue; // Invalid, ignore stored procedure if (sp.IsTableValuedFunction && sp.Parameters.Any(c => c.PropertyType == "DataTable")) continue; // Invalid, ignore validStoredProcs.Add(sp); // Valid, keep this stored proc } // Update the list of stored procs for each of the db context filters that want them foreach (var filterKeyValuePair in spFilters) { var filter = filterKeyValuePair.Value; foreach (var sp in validStoredProcs) { if (!filter.IsExcluded(sp)) { if (_hasTrialLicence) { const int n = 1 + 2 + 3 + 4; if (filter.StoredProcs.Count < n) filter.StoredProcs.Add(sp); } else filter.StoredProcs.Add(sp); } else { if (deleteFilteredOutFiles) FileManagementService.DeleteFile(sp.WriteStoredProcReturnModelName(filter) + Settings.FileExtension); } } } } catch (Exception x) { var error = FormatError(x); _fileManagementService.Error(string.Empty); _fileManagementService.Error("// -----------------------------------------------------------------------------------------"); _fileManagementService.Error(string.Format("// Failed to read database schema for stored procedures - {0}", error)); _fileManagementService.Error("/*" + x.StackTrace + "*/"); _fileManagementService.Error("// -----------------------------------------------------------------------------------------"); _fileManagementService.Error(string.Empty); } } ///

AddRelationship overload for single-column foreign-keys.

public void AddRelationship(IDbContextFilter filter, List fkList, Tables tablesAndViews, string name, string pkSchema, string pkTable, string pkColumn, string fkSchema, string fkTable, string fkColumn, string parentName, string childName, bool isUnique) { AddRelationship(filter, fkList, tablesAndViews, name, pkSchema, pkTable, new[] { pkColumn }, fkSchema, fkTable, new[] { fkColumn }, parentName, childName, isUnique); } public void AddRelationship(IDbContextFilter filter, List fkList, Tables tablesAndViews, string relationshipName, string pkSchema, string pkTableName, string[] pkColumns, string fkSchema, string fkTableName, string[] fkColumns, string parentName, string childName, bool isUnique) { // Argument validation: if (filter == null) throw new ArgumentNullException(nameof(filter)); if (fkList == null) throw new ArgumentNullException(nameof(fkList)); if (tablesAndViews == null) throw new ArgumentNullException(nameof(tablesAndViews)); if (string.IsNullOrEmpty(relationshipName)) throw new ArgumentNullException(nameof(relationshipName)); if (string.IsNullOrEmpty(pkSchema)) throw new ArgumentNullException(nameof(pkSchema)); if (string.IsNullOrEmpty(pkTableName)) throw new ArgumentNullException(nameof(pkTableName)); if (pkColumns == null) throw new ArgumentNullException(nameof(pkColumns)); if (pkColumns.Length == 0 || pkColumns.Any(string.IsNullOrEmpty)) throw new ArgumentException("Invalid primary-key columns: No primary-key column names are specified, or at least one primary-key column name is empty.", nameof(pkColumns)); if (string.IsNullOrEmpty(fkSchema)) throw new ArgumentNullException(nameof(fkSchema)); if (string.IsNullOrEmpty(fkTableName)) throw new ArgumentNullException(nameof(fkTableName)); if (fkColumns == null) throw new ArgumentNullException(nameof(fkColumns)); if (fkColumns.Length != pkColumns.Length || fkColumns.Any(string.IsNullOrEmpty)) throw new ArgumentException("Invalid foreign-key columns:Foreign-key column list has a different number of columns than the primary-key column list, or at least one foreign-key column name is empty.", nameof(pkColumns)); ////////////////// var pkTable = tablesAndViews.GetTable(pkTableName, pkSchema); if (pkTable == null) throw new ArgumentException("Couldn't find table " + pkSchema + "." + pkTableName); var fkTable = tablesAndViews.GetTable(fkTableName, fkSchema); if (fkTable == null) throw new ArgumentException("Couldn't find table " + fkSchema + "." + fkTableName); // Ensure all columns exist: foreach (var pkCol in pkColumns) { if (pkTable.Columns.SingleOrDefault(c => c.DbName == pkCol) == null) throw new ArgumentException("The relationship primary-key column \"" + pkCol + "\" does not exist in table or view " + pkSchema + "." + pkTableName); } foreach (var fkCol in fkColumns) { if (fkTable.Columns.SingleOrDefault(c => c.DbName == fkCol) == null) throw new ArgumentException("The relationship foreign-key column \"" + fkCol + "\" does not exist in table or view " + fkSchema + "." + fkTableName); } for (var i = 0; i < pkColumns.Length; i++) { var pkc = pkColumns[i]; var fkc = fkColumns[i]; var fkTableNameFiltered = filter.TableRename(fkTableName, fkSchema, fkTable.IsView); var pkTableNameFiltered = filter.TableRename(pkTableName, pkSchema, pkTable.IsView); var fk = new ForeignKey( fkTable.DbName, fkSchema, pkTable.DbName, pkSchema, fkc, pkc, "AddRelationship: " + relationshipName, fkTableNameFiltered, pkTableNameFiltered, int.MaxValue, false, false, parentName, childName, isUnique ) { IncludeReverseNavigation = true }; fkList.Add(fk); fkTable.HasForeignKey = true; } } private void ProcessForeignKeys(List fkList, bool checkForFkNameClashes, IDbContextFilter filter) { var constraints = fkList.Select(x => x.FkSchema + "." + x.ConstraintName).Distinct(); foreach (var constraint in constraints) { var foreignKeys = fkList .Where(x => string.Format("{0}.{1}", x.FkSchema, x.ConstraintName).Equals(constraint, StringComparison.InvariantCultureIgnoreCase)) .ToList(); var foreignKey = foreignKeys.First(); var fkTable = filter.Tables.GetTable(foreignKey.FkTableName, foreignKey.FkSchema); if (fkTable == null || fkTable.IsMapping || !fkTable.HasForeignKey) continue; var pkTable = filter.Tables.GetTable(foreignKey.PkTableName, foreignKey.PkSchema); if (pkTable == null || pkTable.IsMapping) continue; var fkCols = foreignKeys.Select(x => new ColumnAndForeignKey { ForeignKey = x, Column = fkTable.Columns.Find(n => string.Equals(n.DbName, x.FkColumn, StringComparison.InvariantCultureIgnoreCase)) }) .Where(x => x.Column != null) .OrderBy(o => o.ForeignKey.Ordinal) .ToList(); if (!fkCols.Any()) continue; if (FkMustHaveSameNumberOfColumnsAsPrimaryKey() || AllowFkToNonPrimaryKey()) { // Check FK has same number of columns as the primary key it points to var pks = pkTable.PrimaryKeys .OrderBy(x => x.PropertyType).ThenBy(y => y.DbName).ToArray(); var cols = fkCols.Select(x => x.Column).OrderBy(x => x.PropertyType).ThenBy(y => y.DbName).ToArray(); if (FkMustHaveSameNumberOfColumnsAsPrimaryKey() && pks.Length != cols.Length) { // Also check unique constraints if (!AllowFkToNonPrimaryKey()) continue; if(!fkCols.All(x => x.ForeignKey.HasUniqueConstraint)) continue; } if (!AllowFkToNonPrimaryKey() && pks.Where((pk, n) => pk.PropertyType != cols[n].PropertyType).Any()) continue; } var pkCols = foreignKeys.Select(x => new ColumnAndForeignKey { ForeignKey = x, Column = pkTable.Columns.Find(n => string.Equals(n.DbName, x.PkColumn, StringComparison.InvariantCultureIgnoreCase)) }) .Where(x => x.Column != null) .OrderBy(o => o.ForeignKey.Ordinal) .ToList(); if (!pkCols.Any()) continue; var allPkColsArePrimaryKeys = pkCols.All(c => c.Column.IsPrimaryKey); if (!AllowFkToNonPrimaryKey() && !allPkColsArePrimaryKeys) continue; // Cannot have a FK to a non-primary key var relationship = CalcRelationship(pkTable, fkTable, fkCols, pkCols); if (relationship == Relationship.DoNotUse) continue; var pkTableHumanCaseWithSuffix = foreignKey.PkTableHumanCase(pkTable.Suffix); var pkTableHumanCase = foreignKey.PkTableHumanCase(null); var fkHasUniqueConstraint = pkCols.All(x => x.ForeignKey.HasUniqueConstraint) && relationship == Relationship.OneToOne; if (fkHasUniqueConstraint && pkCols.Any(x => x.Column.IsNullable)) continue; // This would force the column to be not null var flipRelationship = FlipRelationship(relationship); var fkMakePropNameSingular = relationship == Relationship.OneToOne; var pkPropName = fkTable.GetUniqueForeignKeyName(true, pkTableHumanCase, foreignKey, checkForFkNameClashes, true, relationship); var fkPropName = pkTable.GetUniqueForeignKeyName(false, fkTable.NameHumanCase, foreignKey, checkForFkNameClashes, fkMakePropNameSingular, flipRelationship); var fkd = new PropertyAndComments { AdditionalDataAnnotations = filter.ForeignKeyAnnotationsProcessing(fkTable, pkTable, pkPropName, fkPropName), PropertyName = pkPropName, Definition = string.Format("public {0}{1} {2} {3}{4}", Table.GetLazyLoadingMarker(), pkTableHumanCaseWithSuffix, pkPropName, "{ get; set; }", Settings.IncludeComments != CommentsStyle.None ? " // " + foreignKey.ConstraintName : string.Empty), Comments = string.Format("Parent {0} pointed by [{1}].({2}) ({3})", pkTableHumanCase, fkTable.DbName, string.Join(", ", fkCols.Select(x => "[" + x.Column.NameHumanCase + "]").Distinct().ToArray()), foreignKey.ConstraintName) }; var firstFkCol = fkCols.First(); firstFkCol.Column.EntityFk.Add(fkd); string manyToManyMapping, mapKey; if (foreignKeys.Count > 1) { manyToManyMapping = string.Format("c => new {{ {0} }}", string.Join(", ", fkCols.Select(x => "c." + x.Column.NameHumanCase).Distinct().ToArray())); mapKey = string.Format("{0}", string.Join(",", fkCols.Select(x => "\"" + x.Column.DbName + "\"").Distinct().ToArray())); } else { manyToManyMapping = string.Format("c => c.{0}", firstFkCol.Column.NameHumanCase); mapKey = string.Format("\"{0}\"", firstFkCol.Column.DbName); } var primaryKeyColumns = string.Empty; if (!allPkColsArePrimaryKeys) { if (pkCols.Count > 1) primaryKeyColumns = string.Format("p => new {{ {0} }}", string.Join(", ", pkCols.Select(x => "p." + x.Column.NameHumanCase).Distinct().ToArray())); else primaryKeyColumns = string.Format("p => p.{0}", pkCols.First().Column.NameHumanCase); } var fkCols2 = fkCols.Select(c => c.Column).ToList(); var pkCols2 = pkCols.Select(c => c.Column).ToList(); var rel = GetRelationship(relationship, fkCols2, pkCols2, pkPropName, fkPropName, manyToManyMapping, mapKey, foreignKey.CascadeOnDelete, foreignKey.IncludeReverseNavigation, foreignKey.IsNotEnforced, foreignKey.ConstraintName, pkTableHumanCase, fkTable.NameHumanCaseWithSuffix(), primaryKeyColumns, fkHasUniqueConstraint); var com = Settings.IncludeComments != CommentsStyle.None && string.IsNullOrEmpty(GetForeignKeyConstraintName("x")) ? " // " + foreignKey.ConstraintName : string.Empty; firstFkCol.Column.ConfigFk.Add(string.Format("{0};{1}", rel, com)); if (foreignKey.IncludeReverseNavigation) pkTable.AddReverseNavigation(relationship, fkTable, fkPropName, string.Format("{0}.{1}", fkTable.DbName, foreignKey.ConstraintName), foreignKeys); } } private void IdentifyForeignKeys(List fkList, Tables tables) { foreach (var foreignKey in fkList) { var fkTable = tables.GetTable(foreignKey.FkTableName, foreignKey.FkSchema); if (fkTable == null) continue; // Could be filtered out var pkTable = tables.GetTable(foreignKey.PkTableName, foreignKey.PkSchema); if (pkTable == null) continue; // Could be filtered out var fkCol = fkTable.Columns.Find(n => string.Equals(n.DbName, foreignKey.FkColumn, StringComparison.InvariantCultureIgnoreCase)); if (fkCol == null) continue; // Could not find fk column var pkCol = pkTable.Columns.Find(n => string.Equals(n.DbName, foreignKey.PkColumn, StringComparison.InvariantCultureIgnoreCase)); if (pkCol == null) continue; // Could not find pk column fkTable.HasForeignKey = true; } } private string GetRelationship(Relationship relationship, IList fkCols, IList pkCols, string pkPropName, string fkPropName, string manyToManyMapping, string mapKey, bool cascadeOnDelete, bool includeReverseNavigation, bool isNotEnforced, string foreignKeyConstraintName, string pkTableNameHumanCase, string fkTableNameHumanCase, string primaryKeyColumns, bool fkHasUniqueConstraint) { var hasMethod = GetHasMethod(relationship, fkCols, pkCols, isNotEnforced, fkHasUniqueConstraint); if (hasMethod == null) return string.Empty; // Relationship not supported var withMethod = GetWithMethod(relationship, fkCols, fkPropName, manyToManyMapping, mapKey, includeReverseNavigation, hasMethod, pkTableNameHumanCase, fkTableNameHumanCase, primaryKeyColumns, fkHasUniqueConstraint); return string.Format("{0}(a => a.{1}){2}{3}{4}", hasMethod, pkPropName, withMethod, GetCascadeOnDelete(cascadeOnDelete), GetForeignKeyConstraintName(foreignKeyConstraintName)); } // Calculates the relationship between a child table and it's parent table. public static Relationship CalcRelationship(Table parentTable, Table childTable, List fkCols, List pkCols) { var childTableCols = fkCols.Select(c => c.Column).ToList(); var parentTableCols = pkCols.Select(c => c.Column).ToList(); if (childTableCols.Count == 1 && parentTableCols.Count == 1) return CalcRelationshipSingle(parentTable, childTable, childTableCols.First(), parentTableCols.First()); // This relationship has multiple composite keys // childTable FK columns are exactly the primary key (they are part of primary key, and no other columns are primary keys) // TODO: we could also check if they are a unique index var childTableColumnsAllPrimaryKeys = (childTableCols.Count == childTableCols.Count(x => x.IsPrimaryKey)) && (childTableCols.Count == childTable.PrimaryKeys.Count()); // parentTable columns are exactly the primary key (they are part of primary key, and no other columns are primary keys) // TODO: we could also check if they are a unique index var parentTableColumnsAllPrimaryKeys = (parentTableCols.Count == parentTableCols.Count(x => x.IsPrimaryKey)) && (parentTableCols.Count == parentTable.PrimaryKeys.Count()); // childTable FK columns are not only FK but also the whole PK (not only part of PK); parentTable columns are the whole PK (not only part of PK) - so it's 1:1 if (childTableColumnsAllPrimaryKeys && parentTableColumnsAllPrimaryKeys) return Relationship.OneToOne; // Check if covered by a unique constraint if(fkCols.All(x => x.ForeignKey.HasUniqueConstraint)) return Relationship.OneToOne; // Check if covered by a unique index on PK table if (parentTableCols.All(x => x.IsUnique)) return Relationship.OneToOne; return Relationship.ManyToOne; } // Calculates the relationship between a child table and it's parent table. public static Relationship CalcRelationshipSingle(Table parentTable, Table childTable, Column childTableCol, Column parentTableCol) { if (!childTableCol.IsPrimaryKey && !childTableCol.IsUniqueConstraint) return Relationship.ManyToOne; if (!parentTableCol.IsPrimaryKey && !parentTableCol.IsUniqueConstraint) return Relationship.ManyToOne; if (childTable.PrimaryKeys.Count() != 1) return Relationship.ManyToOne; if (parentTable.PrimaryKeys.Count() != 1) return Relationship.ManyToOne; return Relationship.OneToOne; } public static Relationship FlipRelationship(Relationship relationship) { switch (relationship) { case Relationship.OneToOne: return Relationship.OneToOne; case Relationship.OneToMany: return Relationship.ManyToOne; case Relationship.ManyToOne: return Relationship.OneToMany; case Relationship.ManyToMany: return Relationship.ManyToMany; case Relationship.DoNotUse: return Relationship.DoNotUse; default: throw new ArgumentOutOfRangeException(nameof(relationship), relationship, null); } } public void SetupEntityAndConfig(Column c) { SetupEntity(c); SetupConfig(c); } public void GenerateCode() { try { CreateOutputFolders(); var fallback = Settings.TemplateFolder; foreach (var filter in FilterList.GetFilters()) { _fileManagementService.UseFileManager(filter.Key); if (!Settings.GenerateSingleDbContext) { // Multi-context Settings.DbContextInterfaceName = null; Settings.DbContextName = ((MultiContextFilter) filter.Value).GetSettings().Name ?? filter.Key; if (Settings.TemplateType == TemplateType.FileBasedCore3 || Settings.TemplateType == TemplateType.FileBasedCore6) { // Use file based templates, set the path var multiContextSetting = ((MultiContextFilter) filter.Value).GetSettings(); if (multiContextSetting != null && !string.IsNullOrEmpty(multiContextSetting.TemplatePath)) Settings.TemplateFolder = multiContextSetting.TemplatePath; } } GenerateCode(filter.Value); Settings.TemplateFolder = fallback; // Reset back } } catch (Exception x) { var error = FormatError(x); _fileManagementService.Error(string.Empty); _fileManagementService.Error("// -----------------------------------------------------------------------------------------"); _fileManagementService.Error(string.Format("// Failed to generate the code in GenerateCode() - {0}", error)); _fileManagementService.Error("/*" + x.StackTrace + "*/"); _fileManagementService.Error("// -----------------------------------------------------------------------------------------"); _fileManagementService.Error(string.Empty); } } private void CreateOutputFolders() { if (Settings.FileManagerType != FileManagerType.EfCore || Settings.GenerateSeparateFiles != true) return; CreateOutputFolder(Settings.ContextFolder); CreateOutputFolder(Settings.InterfaceFolder); CreateOutputFolder(Settings.PocoFolder); CreateOutputFolder(Settings.PocoConfigurationFolder); } private void CreateOutputFolder(string folder) { if (string.IsNullOrEmpty(folder)) return; var fullPath = Path.Combine(Settings.Root, folder); try { Directory.CreateDirectory(fullPath); } catch (Exception x) { var error = FormatError(x); _fileManagementService.Error(string.Empty); _fileManagementService.Error(string.Format("// Unable to create folder: {0} Error: {1}", fullPath, error)); _fileManagementService.Error("/*" + x.StackTrace + "*/"); _fileManagementService.Error(string.Empty); } } private void GenerateCode(IDbContextFilter filter) { var codeGenerator = new CodeGenerator(this, filter); const string contextInterface = "contextInterface:"; const string contextFactory = "contextFactory:"; const string contextClass = "contextClass:"; const string contextFakeClass = "contextFakeClass:"; const string contextFakeDbSet = "contextFakeDbSet:"; const string pocoClass = "pocoClass:"; const string pocoConfiguration= "pocoConfiguration:"; const string spReturnModels = "spReturnModel:"; const string enumType = "enumType:"; var codeOutputList = new CodeOutputList(); codeOutputList.Add(contextInterface, codeGenerator.GenerateInterface()); codeOutputList.Add(contextFactory, codeGenerator.GenerateFactory()); codeOutputList.Add(contextClass, codeGenerator.GenerateContext()); codeOutputList.Add(contextFakeClass, codeGenerator.GenerateFakeContext()); codeOutputList.Add(contextFakeDbSet, codeGenerator.GenerateFakeDbSet()); var isEfCore3Plus = Settings.IsEfCore3Plus(); foreach (var table in filter.Tables .Where(t => !t.IsMapping) .OrderBy(x => x.NameHumanCase)) { // Write poco class, even if it has no primary key, for completeness. codeOutputList.Add(pocoClass + table.NameHumanCase, codeGenerator.GeneratePoco(table)); // Only write the config if it has a primary key if (table.HasPrimaryKey || (table.IsView && isEfCore3Plus)) codeOutputList.Add(pocoConfiguration + table.NameHumanCase, codeGenerator.GeneratePocoConfiguration(table)); } foreach (var sp in filter.StoredProcs .Where(x => x.ReturnModels.Count > 0 && x.ReturnModels.Any(returnColumns => returnColumns.Any()) && !Settings.StoredProcedureReturnTypes.ContainsKey(x.NameHumanCase) && !Settings.StoredProcedureReturnTypes.ContainsKey(x.DbName)) .OrderBy(x => x.NameHumanCase)) { var key = spReturnModels + sp.WriteStoredProcReturnModelName(filter); codeOutputList.Add(key, codeGenerator.GenerateStoredProcReturnModel(sp)); } foreach (var enumeration in filter.Enums) { codeOutputList.Add(enumType + enumeration.EnumName, codeGenerator.GenerateEnum(enumeration)); } _fileHeaderFooter = new FileHeaderFooter(filter.SubNamespace); if (!Settings.GenerateSeparateFiles) { var preHeader = _preHeaderInfo.ToString(); if(!string.IsNullOrWhiteSpace(preHeader)) _fileManagementService.WriteLine(preHeader.Trim()); var header = _fileHeaderFooter.Header; if (!string.IsNullOrWhiteSpace(header)) _fileManagementService.WriteLine(header.Trim()); var usings = codeGenerator.GenerateUsings(codeOutputList.GetUsings()); if (!string.IsNullOrWhiteSpace(usings)) { _fileManagementService.WriteLine(""); _fileManagementService.WriteLine(usings.Trim()); } var ns = _fileHeaderFooter.Namespace; if (!string.IsNullOrWhiteSpace(ns)) { _fileManagementService.WriteLine(""); _fileManagementService.WriteLine(ns.Trim()); } } // Write the pre header info with the database context and it's interface if(codeOutputList.Files.ContainsKey(contextInterface)) WriteCodeOutput(codeGenerator, codeOutputList.Files[contextInterface], true, firstInGroup: true); if(codeOutputList.Files.ContainsKey(contextClass)) WriteCodeOutput(codeGenerator, codeOutputList.Files[contextClass], true, firstInGroup: true); if(codeOutputList.Files.ContainsKey(contextFactory)) WriteCodeOutput(codeGenerator, codeOutputList.Files[contextFactory], true); if(codeOutputList.Files.ContainsKey(contextFakeClass)) WriteCodeOutput(codeGenerator, codeOutputList.Files[contextFakeClass], true, firstInGroup: true); if(codeOutputList.Files.ContainsKey(contextFakeDbSet)) WriteCodeOutput(codeGenerator, codeOutputList.Files[contextFakeDbSet], true); WriteCodeOutputForGroup(codeGenerator, "POCO classes", true, codeOutputList.Files .Where(x => x.Key.StartsWith(pocoClass)) .OrderBy(x => x.Key) .Select(x => x.Value) .ToList()); WriteCodeOutputForGroup(codeGenerator, "POCO Configuration", true, codeOutputList.Files .Where(x => x.Key.StartsWith(pocoConfiguration)) .OrderBy(x => x.Key) .Select(x => x.Value) .ToList()); WriteCodeOutputForGroup(codeGenerator, "Enumerations", true, codeOutputList.Files .Where(x => x.Key.StartsWith(enumType)) .OrderBy(x => x.Key) .Select(x => x.Value) .ToList()); WriteCodeOutputForGroup(codeGenerator, "Stored procedure return models", true, codeOutputList.Files .Where(x => x.Key.StartsWith(spReturnModels)) .OrderBy(x => x.Key) .Select(x => x.Value) .ToList()); if (!Settings.GenerateSeparateFiles) _fileManagementService.WriteLine(_fileHeaderFooter.Footer); } private void WriteCodeOutputForGroup(CodeGenerator codeGenerator, string regionNameForGroup, bool writePreHeaderInfo, List list) { var count = 0; var max = list.Count; foreach (var co in list) { ++count; WriteCodeOutput(codeGenerator, co, writePreHeaderInfo, regionNameForGroup, count == 1, count == max); } } private void WriteCodeOutput(CodeGenerator codeGenerator, CodeOutput code, bool writePreHeaderInfo, string regionNameForGroup = null, bool firstInGroup = false, bool lastInGroup = false) { if (Settings.GenerateSeparateFiles) { _fileManagementService.EndBlock(); _fileManagementService.StartNewFile(code.Filename); // If generating separate files, check if the db context is the same name as the tt filename. // If it is the same, force writing to outer. if (Path.GetFileNameWithoutExtension(code.Filename).Equals(Settings.TemplateFile, StringComparison.CurrentCultureIgnoreCase)) _fileManagementService.ForceWriteToOuter = true; if (writePreHeaderInfo) { var preHeader = _preHeaderInfo.ToString(); if (!string.IsNullOrWhiteSpace(preHeader)) _fileManagementService.WriteLine(preHeader.Trim()); } var header = _fileHeaderFooter.Header; if (!string.IsNullOrWhiteSpace(header)) _fileManagementService.WriteLine(header.Trim()); var usings = codeGenerator.GenerateUsings(code.GetUsings()); if (!string.IsNullOrWhiteSpace(usings)) { _fileManagementService.WriteLine(""); _fileManagementService.WriteLine(usings.Trim()); } var ns = _fileHeaderFooter.Namespace; if (!string.IsNullOrWhiteSpace(ns)) { _fileManagementService.WriteLine(""); _fileManagementService.WriteLine(ns.Trim()); } } WriteLines(IndentCode(code, regionNameForGroup, firstInGroup, lastInGroup)); if (Settings.GenerateSeparateFiles) _fileManagementService.WriteLine(_fileHeaderFooter.Footer); _fileManagementService.ForceWriteToOuter = false; } private List IndentCode(CodeOutput output, string regionNameForGroup, bool firstInGroup, bool lastInGroup) { if (output == null) return null; var indentNum = Settings.UseNamespace ? 1 : 0; var useRegion = !Settings.GenerateSeparateFiles && !string.IsNullOrEmpty(output.Region); var lines = new List(); if (Settings.UseRegions && useRegion) { lines.Add(IndentedStringBuilder(indentNum, "#region " + output.Region)); lines.Add(null); // Add blank line after the region } else { if (Settings.UseRegions && !Settings.GenerateSeparateFiles && firstInGroup && !string.IsNullOrEmpty(regionNameForGroup)) { lines.Add(IndentedStringBuilder(indentNum, "#region " + regionNameForGroup)); lines.Add(null); // Add blank line after the region group } } if (firstInGroup && (_hasAcademicLicence || _hasTrialLicence)) { lines.Add(IndentedStringBuilder(indentNum, "// ****************************************************************************************************")); lines.Add(IndentedStringBuilder(indentNum, "// This is not a commercial licence, therefore only a few tables/views/stored procedures are generated.")); lines.Add(IndentedStringBuilder(indentNum, "// ****************************************************************************************************")); lines.Add(null); } if (Settings.IncludeCodeGeneratedAttribute) lines.Add(IndentedStringBuilder(indentNum, _codeGeneratedAttribute)); lines.AddRange(IndentedStringBuilder(indentNum, output.Code)); if (useRegion || (!Settings.GenerateSeparateFiles && lastInGroup && !string.IsNullOrEmpty(regionNameForGroup))) { if (Settings.UseRegions) { lines.Add(null); // Include blank line after #endregion lines.Add(IndentedStringBuilder(indentNum, "#endregion")); lines.Add(null); // Include blank line after #endregion } else { lines.Add(null); // Include blank line } } return lines; } protected string IndentedStringBuilder(int indentNum, string line) { var indent = new string(' ', indentNum * Indent); return string.IsNullOrWhiteSpace(line) ? string.Empty : string.Format("{0}{1}", indent, line); } protected IEnumerable IndentedStringBuilder(int indentNum, List lines) { var indent = new string(' ', indentNum * Indent); return ( from line in lines select string.IsNullOrWhiteSpace(line) ? string.Empty : string.Format("{0}{1}", indent, line) ); } private void WriteLines(List lines) { foreach (var line in lines) _fileManagementService.WriteLine(line); } private void BuildPreHeaderInfo(Licence licence) { if (Settings.ShowLicenseInfo) { _preHeaderInfo.Append("// This code was generated by EntityFramework Reverse POCO Generator"); if (Settings.IncludeGeneratorVersionInCode) { _preHeaderInfo.Append(" "); _preHeaderInfo.Append(EfrpgVersion.Version()); } _preHeaderInfo.AppendLine(" (http://www.reversepoco.co.uk/)."); _preHeaderInfo.AppendLine("// Created by Simon Hughes (https://about.me/simon.hughes)."); _preHeaderInfo.AppendLine("//"); _preHeaderInfo.AppendLine(string.Format("// {0}{1}", LicenceConstants.RegisteredTo, licence.RegisteredTo)); _preHeaderInfo.AppendLine(string.Format("// {0}{1}", LicenceConstants.Company, licence.Company)); _preHeaderInfo.AppendLine(string.Format("// {0}{1}", LicenceConstants.LicenceType, licence.GetLicenceType())); _preHeaderInfo.AppendLine(string.Format("// {0}{1}", LicenceConstants.NumLicences, licence.NumLicences)); _preHeaderInfo.AppendLine(string.Format("// {0}{1}", LicenceConstants.ValidUntil, licence.ValidUntil.ToString(LicenceConstants.ExpiryFormat).ToUpperInvariant())); _preHeaderInfo.AppendLine("//"); } if (Settings.IncludeConnectionSettingComments) { _preHeaderInfo.AppendLine("// The following connection settings were used to generate this file:"); if (!string.IsNullOrEmpty(Settings.ConnectionStringName)) _preHeaderInfo.AppendLine(string.Format("// Connection String Name: \"{0}\"", Settings.ConnectionStringName)); _preHeaderInfo.AppendLine(string.Format("// Connection String: \"{0}\"", ZapPassword(Settings.ConnectionString))); if (!Settings.GenerateSingleDbContext) { var conn = string.IsNullOrWhiteSpace(Settings.MultiContextSettingsConnectionString) ? Settings.ConnectionString : Settings.MultiContextSettingsConnectionString; _preHeaderInfo.AppendLine(string.Format("// Multi-context settings: \"{0}\"", ZapPassword(conn))); } _preHeaderInfo.AppendLine("//"); } } private string ZapPassword(string conn) { var rx = new Regex("password=[^\";]*", RegexOptions.Singleline | RegexOptions.Multiline | RegexOptions.IgnoreCase); return rx.Replace(conn, "password=**zapped**;"); } private string FormatError(Exception ex) { return ex.Message.Replace("\r\n", "\n").Replace("\n", " "); } } // Fill in the following functions with your own code if not using EF6 / EfCore // Take a look at GeneratorEf6 and GeneratorEfCore to see what's been done for those. public class GeneratorCustom : Generator { public GeneratorCustom(FileManagementService fileManagementService, Type fileManagerType) : base(fileManagementService, fileManagerType) { } protected override bool AllowFkToNonPrimaryKey() { return false; } protected override bool FkMustHaveSameNumberOfColumnsAsPrimaryKey() { return true; } protected override void SetupEntity(Column c) { } protected override void SetupConfig(Column c) { c.Config = string.Empty; } public override string PrimaryKeyModelBuilder(Table table) { return null; } public override List IndexModelBuilder(Table t) { return null; } public override string IndexModelBuilder(Column c) { return null; } protected override string GetHasMethod(Relationship relationship, IList fkCols, IList pkCols, bool isNotEnforced, bool fkHasUniqueConstraint) { return null; } protected override string GetWithMethod(Relationship relationship, IList fkCols, string fkPropName, string manyToManyMapping, string mapKey, bool includeReverseNavigation, string hasMethod, string pkTableNameHumanCase, string fkTableNameHumanCase, string primaryKeyColumns, bool fkHasUniqueConstraint) { return string.Empty; } protected override string GetCascadeOnDelete(bool cascadeOnDelete) { return string.Empty; } protected override string GetForeignKeyConstraintName(string foreignKeyConstraintName) { return string.Empty; } } public class GeneratorEf6 : Generator { public GeneratorEf6(FileManagementService fileManagementService, Type fileManagerType) : base(fileManagementService, fileManagerType) { } protected override bool AllowFkToNonPrimaryKey() { return false; // Cannot have a FK to a non-primary key } protected override bool FkMustHaveSameNumberOfColumnsAsPrimaryKey() { return true; } protected override void SetupEntity(Column c) { if (c.PropertyType == "Hierarchy.HierarchyId") c.PropertyType = "System.Data.Entity.Hierarchy.HierarchyId"; var comments = string.Empty; if (Settings.IncludeComments != CommentsStyle.None) { comments = c.DbName; if (c.IsPrimaryKey) { if (c.IsUniqueConstraint) comments += " (Primary key via unique index " + c.UniqueIndexName + ")"; else comments += " (Primary key)"; } if (c.MaxLength > 0) comments += string.Format(" (length: {0})", c.MaxLength); } c.InlineComments = Settings.IncludeComments == CommentsStyle.AtEndOfField ? " // " + comments : string.Empty; c.SummaryComments = string.Empty; if (Settings.IncludeComments == CommentsStyle.InSummaryBlock && !string.IsNullOrEmpty(comments)) { c.SummaryComments = comments; } if (Settings.IncludeExtendedPropertyComments == CommentsStyle.InSummaryBlock && !string.IsNullOrEmpty(c.ExtendedProperty)) { if (string.IsNullOrEmpty(c.SummaryComments)) c.SummaryComments = c.ExtendedProperty; else c.SummaryComments += ". " + c.ExtendedProperty; } if (Settings.IncludeExtendedPropertyComments == CommentsStyle.AtEndOfField && !string.IsNullOrEmpty(c.ExtendedProperty)) { if (string.IsNullOrEmpty(c.InlineComments)) c.InlineComments = " // " + c.ExtendedProperty; else c.InlineComments += ". " + c.ExtendedProperty; } } protected override void SetupConfig(Column c) { string databaseGeneratedOption = null; var isNewSequentialId = !string.IsNullOrEmpty(c.Default) && c.Default.ToLower().Contains("newsequentialid"); var isTemporalColumn = c.GeneratedAlwaysType != ColumnGeneratedAlwaysType.NotApplicable; // Identity, instead of Computed, seems the best for Temporal `GENERATED ALWAYS` columns: https://stackoverflow.com/questions/40742142/entity-framework-not-working-with-temporal-table if (c.IsIdentity || isNewSequentialId || isTemporalColumn) { databaseGeneratedOption = ".HasDatabaseGeneratedOption(DatabaseGeneratedOption.Identity)"; } else if (c.IsComputed) { databaseGeneratedOption = ".HasDatabaseGeneratedOption(DatabaseGeneratedOption.Computed)"; } else if (c.IsPrimaryKey) { databaseGeneratedOption = ".HasDatabaseGeneratedOption(DatabaseGeneratedOption.None)"; } var sb = new StringBuilder(255); sb.AppendFormat(".HasColumnName(@\"{0}\")", c.DbName); var excludedHasColumnType = string.Empty; if (!Settings.UseDataAnnotations && !string.IsNullOrEmpty(c.SqlPropertyType)) { if(Column.ExcludedHasColumnType.Contains(c.SqlPropertyType)) excludedHasColumnType = string.Format(" // .HasColumnType(\"{0}\") was excluded", c.SqlPropertyType); else sb.AppendFormat(".HasColumnType(\"{0}\")", c.SqlPropertyType); } sb.Append(c.IsNullable ? ".IsOptional()" : ".IsRequired()"); if (c.IsFixedLength || c.IsRowVersion) sb.Append(".IsFixedLength()"); if (!c.IsUnicode) sb.Append(".IsUnicode(false)"); if (!c.IsMaxLength && c.MaxLength > 0) { var doNotSpecifySize = (DatabaseReader.DoNotSpecifySizeForMaxLength && c.MaxLength > 4000); // Issue #179 if (doNotSpecifySize) sb.Append(".HasMaxLength(null)"); else sb.AppendFormat(".HasMaxLength({0})", c.MaxLength); } if (c.IsMaxLength) sb.Append(".IsMaxLength()"); if ((c.Precision > 0 || c.Scale > 0) && DatabaseReader.IsPrecisionAndScaleType(c.SqlPropertyType)) sb.AppendFormat(".HasPrecision({0},{1})", c.Precision, c.Scale); else if (c.Precision > 0 && DatabaseReader.IsPrecisionType(c.SqlPropertyType) && c.SqlPropertyType != "float") sb.AppendFormat(".HasPrecision({0})", c.Precision); if (c.IsRowVersion) { sb.Append(".IsRowVersion()"); c.IsConcurrencyToken = true; } if (c.IsConcurrencyToken) sb.Append(".IsConcurrencyToken()"); if (databaseGeneratedOption != null) sb.Append(databaseGeneratedOption); var config = sb.ToString(); if (!string.IsNullOrEmpty(config)) c.Config = string.Format("Property(x => x.{0}){1};{2}", c.NameHumanCase, config, excludedHasColumnType); } public override string PrimaryKeyModelBuilder(Table table) { return null; } public override List IndexModelBuilder(Table t) { return null; } public override string IndexModelBuilder(Column c) { var sb = new StringBuilder(1024); var indexes = c.Indexes.Where(x => !x.IsPrimaryKey).OrderBy(x => x.IndexName).ThenBy(x => x.KeyOrdinal).ToList(); var count = indexes.Count; var first = true; var cannotUseAdded = false; var closeBrackets = false; var n = count; foreach (var index in indexes) { --n; if (first) { sb.AppendLine($"modelBuilder.Entity<{c.ParentTable.NameHumanCaseWithSuffix()}>()"); sb.AppendLine($" .Property(e => e.{c.NameHumanCase})"); sb.AppendLine(" .HasColumnAnnotation("); sb.AppendLine(" IndexAnnotation.AnnotationName,"); } if (count == 1) sb.AppendLine($" new IndexAnnotation({AddIndexAttribute(index)})"); else { if (first) { sb.AppendLine(" new IndexAnnotation(new[]"); sb.AppendLine(" {"); closeBrackets = true; } sb.Append(" "); sb.Append(AddIndexAttribute(index)); if (n > 0) sb.Append(","); sb.AppendLine(); } first = false; if (n == 0) { sb.AppendLine(closeBrackets ? " }));" : " );"); } } if (cannotUseAdded) sb.Append(" */"); return sb.ToString(); } private string AddIndexAttribute(RawIndex rawIndex) { var sb = new StringBuilder(255); var properties = new List(); sb.Append($"new IndexAttribute(\"{rawIndex.IndexName}\", {rawIndex.KeyOrdinal})"); if (rawIndex.IsUnique) properties.Add("IsUnique = true"); if (rawIndex.IsClustered) properties.Add("IsClustered = true"); if (properties.Any()) { sb.Append(" { "); sb.Append($"{string.Join(", ", properties)}"); sb.Append(" }"); } return sb.ToString(); } // HasOptional // HasRequired // HasMany protected override string GetHasMethod(Relationship relationship, IList fkCols, IList pkCols, bool isNotEnforced, bool fkHasUniqueConstraint) { var withMany = relationship == Relationship.ManyToOne || relationship == Relationship.ManyToMany; var fkIsNullable = fkCols.Any(c => c.IsNullable); var pkIsUnique = pkCols.Any(c => c.IsUnique || c.IsUniqueConstraint || c.IsPrimaryKey); if (withMany || pkIsUnique || fkHasUniqueConstraint) { if (fkIsNullable || isNotEnforced) return "HasOptional"; return "HasRequired"; } return "HasMany"; } // WithOptional // WithRequired // WithMany // WithRequiredPrincipal // WithRequiredDependent protected override string GetWithMethod(Relationship relationship, IList fkCols, string fkPropName, string manyToManyMapping, string mapKey, bool includeReverseNavigation, string hasMethod, string pkTableNameHumanCase, string fkTableNameHumanCase, string primaryKeyColumns, bool fkHasUniqueConstraint) { var withParam = includeReverseNavigation ? string.Format("b => b.{0}", fkPropName) : string.Empty; switch (relationship) { case Relationship.OneToOne: if (hasMethod == "HasOptional") return string.Format(".WithOptionalPrincipal({0})", withParam); return string.Format(".WithOptional({0})", withParam); case Relationship.OneToMany: return string.Format(".WithRequiredDependent({0})", withParam); case Relationship.ManyToOne: if (!fkCols.Any(c => c.Hidden)) return string.Format(".WithMany({0}).HasForeignKey({1})", withParam, manyToManyMapping); // Foreign Key Association return string.Format(".WithMany({0}).Map(c => c.MapKey({1}))", withParam, mapKey); // Independent Association case Relationship.ManyToMany: return string.Format(".WithMany({0}).HasForeignKey({1})", withParam, manyToManyMapping); default: throw new ArgumentOutOfRangeException(nameof(relationship)); } } protected override string GetCascadeOnDelete(bool cascadeOnDelete) { return cascadeOnDelete ? string.Empty : ".WillCascadeOnDelete(false)"; } protected override string GetForeignKeyConstraintName(string foreignKeyConstraintName) { return string.Empty; } } public class GeneratorEfCore : Generator { public GeneratorEfCore(FileManagementService fileManagementService, Type fileManagerType) : base(fileManagementService, fileManagerType) { } protected override bool AllowFkToNonPrimaryKey() { return true; // It is allowed to have a FK to a non-primary key } protected override bool FkMustHaveSameNumberOfColumnsAsPrimaryKey() { return true; } protected override void SetupEntity(Column c) { if (c.PropertyType == "Hierarchy.HierarchyId") c.PropertyType = Settings.IsEfCore6Plus() ? "HierarchyId" : "Microsoft.SqlServer.Types.SqlHierarchyId"; var comments = string.Empty; if (Settings.IncludeComments != CommentsStyle.None) { comments = c.DbName; if (c.IsPrimaryKey) { if (c.IsUniqueConstraint) comments += " (Primary key via unique index " + c.UniqueIndexName + ")"; else comments += " (Primary key)"; } if (c.MaxLength > 0) comments += string.Format(" (length: {0})", c.MaxLength); } c.InlineComments = Settings.IncludeComments == CommentsStyle.AtEndOfField ? " // " + comments : string.Empty; c.SummaryComments = string.Empty; if (Settings.IncludeComments == CommentsStyle.InSummaryBlock && !string.IsNullOrEmpty(comments)) { c.SummaryComments = comments; } if (Settings.IncludeExtendedPropertyComments == CommentsStyle.InSummaryBlock && !string.IsNullOrEmpty(c.ExtendedProperty)) { if (string.IsNullOrEmpty(c.SummaryComments)) c.SummaryComments = c.ExtendedProperty; else c.SummaryComments += ". " + c.ExtendedProperty; } if (Settings.IncludeExtendedPropertyComments == CommentsStyle.AtEndOfField && !string.IsNullOrEmpty(c.ExtendedProperty)) { if (string.IsNullOrEmpty(c.InlineComments)) c.InlineComments = " // " + c.ExtendedProperty; else c.InlineComments += ". " + c.ExtendedProperty; } } protected override void SetupConfig(Column c) { string databaseGeneratedOption = null; var isNewSequentialId = !string.IsNullOrEmpty(c.Default) && c.Default.ToLower().Contains("newsequentialid"); var isTemporalColumn = c.GeneratedAlwaysType != ColumnGeneratedAlwaysType.NotApplicable; var hasDefaultValueSql = !string.IsNullOrEmpty(c.HasDefaultValueSql); // Identity, instead of Computed, seems the best for Temporal 'GENERATED ALWAYS' columns: https://stackoverflow.com/questions/40742142/entity-framework-not-working-with-temporal-table if (!hasDefaultValueSql) { if (c.IsIdentity || isNewSequentialId || isTemporalColumn) { databaseGeneratedOption = ".ValueGeneratedOnAdd()"; if (c.IsIdentity && DatabaseReader.HasIdentityColumnSupport() && Column.CanUseSqlServerIdentityColumn.Contains(c.PropertyType)) databaseGeneratedOption += Settings.ColumnIdentity(c); } else if (c.IsComputed) { databaseGeneratedOption = ".ValueGeneratedOnAddOrUpdate()"; } else if (c.IsPrimaryKey) { databaseGeneratedOption = ".ValueGeneratedNever()"; } } var sb = new StringBuilder(255); sb.AppendFormat(".HasColumnName(@\"{0}\")", c.DbName); var doNotSpecifySize = false; if (!c.IsMaxLength && c.MaxLength > 0) doNotSpecifySize = (DatabaseReader.DoNotSpecifySizeForMaxLength && c.MaxLength > 4000); // Issue #179 var excludedHasColumnType = string.Empty; if (!string.IsNullOrEmpty(c.SqlPropertyType)) { var columnTypeParameters = string.Empty; if ((c.Precision > 0 || c.Scale > 0) && (c.SqlPropertyType == "decimal" || c.SqlPropertyType == "numeric")) columnTypeParameters = $"({c.Precision},{c.Scale})"; else if (!c.IsMaxLength && c.MaxLength > 0 && !doNotSpecifySize) columnTypeParameters = $"({c.MaxLength})"; if (Column.ExcludedHasColumnType.Contains(c.SqlPropertyType)) excludedHasColumnType = string.Format(" // .HasColumnType(\"{0}{1}\") was excluded", c.SqlPropertyType, columnTypeParameters); else sb.AppendFormat(".HasColumnType(\"{0}{1}\")", c.SqlPropertyType, columnTypeParameters); if (Settings.IsEfCore6Plus()) { if ((c.Precision > 0 || c.Scale > 0) && DatabaseReader.IsPrecisionAndScaleType(c.SqlPropertyType)) sb.AppendFormat(".HasPrecision({0},{1})", c.Precision, c.Scale); else if (c.Precision > 0 && DatabaseReader.IsPrecisionType(c.SqlPropertyType)) sb.AppendFormat(".HasPrecision({0})", c.Precision); } if (Settings.TrimCharFields && c.MaxLength > 1 && c.SqlPropertyType == "char") { sb.Append(".HasConversion(new ValueConverter(v => v.TrimEnd(), v => v.TrimEnd()))"); } } sb.Append(c.IsNullable ? ".IsRequired(false)" : ".IsRequired()"); if (c.IsFixedLength || c.IsRowVersion) sb.Append(".IsFixedLength()"); if (!c.IsUnicode) sb.Append(".IsUnicode(false)"); if (!c.IsMaxLength && c.MaxLength > 0 && !doNotSpecifySize) sb.AppendFormat(".HasMaxLength({0})", c.MaxLength); //if (c.IsMaxLength) // sb.Append(".IsMaxLength()"); if (c.IsRowVersion) { sb.Append(".IsRowVersion()"); c.IsConcurrencyToken = true; } if (c.IsConcurrencyToken) sb.Append(".IsConcurrencyToken()"); if (databaseGeneratedOption != null) sb.Append(databaseGeneratedOption); if (hasDefaultValueSql) sb.AppendFormat(".HasDefaultValueSql(@\"{0}\")", c.HasDefaultValueSql); var config = sb.ToString(); if (!string.IsNullOrEmpty(config)) c.Config = string.Format("builder.Property(x => x.{0}){1};{2}", c.NameHumanCase, config, excludedHasColumnType); } public override string PrimaryKeyModelBuilder(Table t) { var isEfCore3Plus = Settings.IsEfCore3Plus(); if (isEfCore3Plus && t.IsView && !t.HasPrimaryKey) return "builder.HasNoKey();"; if (t.PrimaryKeys.All(k => k.Hidden)) return string.Empty; var defaultKey = $"builder.HasKey({t.PrimaryKeyNameHumanCase()})"; if (t.Indexes == null || !t.Indexes.Any()) return defaultKey + ";"; var indexName = t.Indexes.Where(x => x.IsPrimaryKey).Select(x => x.IndexName).Distinct().FirstOrDefault(); if(string.IsNullOrEmpty(indexName)) return defaultKey + ";"; var indexesForName = t.Indexes .Where(x => x.IndexName == indexName) .OrderBy(x => x.KeyOrdinal) .ThenBy(x => x.ColumnName) .ToList(); var sb = new StringBuilder(255); sb.Append(defaultKey); sb.Append(".HasName(\""); sb.Append(indexName); sb.Append("\")"); if (indexesForName.All(x => x.IsClustered)) sb.Append(isEfCore3Plus ? ".IsClustered()" : ".ForSqlServerIsClustered()"); sb.Append(";"); return sb.ToString(); } public override List IndexModelBuilder(Table t) { var indexes = new List(); if (t.Indexes == null || !t.Indexes.Any()) return indexes; var isEfCore3Plus = Settings.IsEfCore3Plus(); var isEfCore5Plus = Settings.IsEfCore6Plus(); var indexNames = t.Indexes.Where(x => !x.IsPrimaryKey).Select(x => x.IndexName).Distinct(); foreach (var indexName in indexNames.OrderBy(x => x)) { var indexesForName = t.Indexes .Where(x => x.IndexName == indexName) .OrderBy(x => x.KeyOrdinal) .ThenBy(x => x.ColumnName) .ToList(); var sb = new StringBuilder(255); var ok = true; var count = 0; sb.Append("builder.HasIndex(x => "); if (indexesForName.Count > 1) sb.Append("new { "); foreach (var index in indexesForName.OrderBy(x => x.KeyOrdinal).ThenBy(x => x.ColumnName)) { var col = t.Columns.Find(x => x.DbName == index.ColumnName); if (col == null || col.Hidden || string.IsNullOrEmpty(col.Config)) { ok = false; break; // Cannot use index, as one of the columns is invalid } if (count > 0) sb.Append(", "); sb.Append("x."); sb.Append(col.NameHumanCase); ++count; } if (!ok) continue; if (indexesForName.Count > 1) sb.Append(" }"); sb.Append(")"); // Close bracket for HasIndex() sb.Append(isEfCore5Plus ? ".HasDatabaseName(\"" : ".HasName(\""); sb.Append(indexName); sb.Append("\")"); if (indexesForName.All(x => x.IsUnique) || indexesForName.All(x => x.IsUniqueConstraint)) sb.Append(".IsUnique()"); if (indexesForName.All(x => x.IsClustered)) sb.Append(isEfCore3Plus ? ".IsClustered()" : ".ForSqlServerIsClustered()"); sb.Append(";"); indexes.Add(sb.ToString()); } return indexes; } public override string IndexModelBuilder(Column c) { return null; } // HasOne // HasMany protected override string GetHasMethod(Relationship relationship, IList fkCols, IList pkCols, bool isNotEnforced, bool fkHasUniqueConstraint) { if (relationship == Relationship.ManyToMany) return null; // Not yet supported in EF.Core var withMany = relationship == Relationship.ManyToOne || relationship == Relationship.ManyToMany; var pkIsUnique = pkCols.Any(c => c.IsUnique || c.IsUniqueConstraint || c.IsPrimaryKey); if (withMany || pkIsUnique || fkHasUniqueConstraint) return "builder.HasOne"; return "builder.HasMany"; } // WithOne // WithMany protected override string GetWithMethod(Relationship relationship, IList fkCols, string fkPropName, string manyToManyMapping, string mapKey, bool includeReverseNavigation, string hasMethod, string pkTableNameHumanCase, string fkTableNameHumanCase, string primaryKeyColumns, bool fkHasUniqueConstraint) { var withParam = includeReverseNavigation ? string.Format("b => b.{0}", fkPropName) : string.Empty; var principalEntityType = fkHasUniqueConstraint ? string.Format("<{0}>", pkTableNameHumanCase) : string.Empty; var hasPrincipleKey = !string.IsNullOrEmpty(primaryKeyColumns) ? string.Format(".HasPrincipalKey{0}({1})", principalEntityType, primaryKeyColumns) : string.Empty; switch (relationship) { case Relationship.OneToOne: return string.Format(".WithOne({0}){1}.HasForeignKey<{2}>({3})", withParam, hasPrincipleKey, fkTableNameHumanCase, manyToManyMapping); case Relationship.OneToMany: return string.Format(".WithMany({0})", withParam); case Relationship.ManyToOne: case Relationship.ManyToMany: return string.Format(".WithMany({0}){1}.HasForeignKey({2})", withParam, hasPrincipleKey, manyToManyMapping); default: throw new ArgumentOutOfRangeException(nameof(relationship)); } } protected override string GetCascadeOnDelete(bool cascadeOnDelete) { return cascadeOnDelete ? string.Empty : ".OnDelete(DeleteBehavior.ClientSetNull)"; } protected override string GetForeignKeyConstraintName(string foreignKeyConstraintName) { return string.Format(".HasConstraintName(\"{0}\")", foreignKeyConstraintName); } } public static class GeneratorFactory { public static Generator Create(FileManagementService fileManagementService, Type fileManagerType, string singleDbContextSubNamespace = null) { Generator generator; switch (Settings.GeneratorType) { case GeneratorType.Ef6: generator = new GeneratorEf6(fileManagementService, fileManagerType); break; case GeneratorType.EfCore: generator = new GeneratorEfCore(fileManagementService, fileManagerType); break; case GeneratorType.Custom: generator = new GeneratorCustom(fileManagementService, fileManagerType); break; default: throw new ArgumentOutOfRangeException(); } var providerName = "unknown"; try { providerName = DatabaseProvider.GetProvider(Settings.DatabaseType); var factory = DbProviderFactories.GetFactory(providerName); var databaseReader = DatabaseReaderFactory.Create(factory); generator.Init(databaseReader, singleDbContextSubNamespace); return generator; } catch (Exception x) { var error = x.Message.Replace("\r\n", "\n").Replace("\n", " "); Console.WriteLine(error); fileManagementService.Error(generator.GetPreHeaderInfo()); fileManagementService.Error(string.Empty); fileManagementService.Error("// ------------------------------------------------------------------------------------------------"); fileManagementService.Error(string.Format("// WARNING: Failed to load provider \"{0}\" - {1}", providerName, error)); fileManagementService.Error("// Allowed providers:"); foreach (DataRow fc in DbProviderFactories.GetFactoryClasses().Rows) { var s = string.Format("// \"{0}\"", fc[2]); fileManagementService.Error(s); } fileManagementService.Error(string.Empty); fileManagementService.Error("/*" + x.StackTrace + "*/"); fileManagementService.Error("// ------------------------------------------------------------------------------------------------"); fileManagementService.Error(string.Empty); } return null; } } public class MultipleModelReturnColumns { public int Model { get; } public List ReturnColumns { get; } public MultipleModelReturnColumns(int model, List returnColumns) { Model = model; ReturnColumns = returnColumns; } } public class ResultSetResultReaderCommand { public int Index { get; } public string ReaderCommand { get; } public bool NotLastRecord { get; } public string WriteStoredProcReturnModelName { get; } public ResultSetResultReaderCommand(int index, string readerCommand, bool notLastRecord, string writeStoredProcReturnModelName) { Index = index; ReaderCommand = readerCommand; NotLastRecord = notLastRecord; WriteStoredProcReturnModelName = writeStoredProcReturnModelName; } } public class ScalarValuedFunctionsTemplateData { public string ExecName { get; } public string ReturnType { get; } public string WriteStoredProcFunctionParamsFalseTrue { get; } public string WriteStoredProcFunctionParamsFalseFalse { get; } public string Name { get; } public string Schema { get; } public ScalarValuedFunctionsTemplateData( string execName, string returnType, string writeStoredProcFunctionParamsFalseTrue, string writeStoredProcFunctionParamsFalseFalse, string name, string schema) { ExecName = execName; ReturnType = returnType; WriteStoredProcFunctionParamsFalseTrue = writeStoredProcFunctionParamsFalseTrue; WriteStoredProcFunctionParamsFalseFalse = writeStoredProcFunctionParamsFalseFalse; Name = name; Schema = schema; } } public class StoredProcTemplateData { public bool HasNoReturnModels { get; set; } // sp.ReturnModels.Count == 0 public bool HasReturnModels { get; } // sp.ReturnModels.Count > 0 public bool SingleReturnModel { get; } // sp.ReturnModels.Count == 1 public bool MultipleReturnModels { get; } // sp.ReturnModels.Count > 1 public string ReturnType { get; } // sp.WriteStoredProcReturnType() public string ReturnModelName { get; } // sp.WriteStoredProcReturnModelName() public string FunctionName { get; } // sp.WriteStoredProcFunctionName() public string WriteStoredProcFunctionParamsFalseFalse { get; } // WriteStoredProcFunctionParams(false, false, false) public string WriteStoredProcFunctionParamsFalseTrue { get; } // WriteStoredProcFunctionParams(false, true, false) public string WriteStoredProcFunctionParamsTrueFalse { get; } // WriteStoredProcFunctionParams(true, false, false) public string WriteStoredProcFunctionParamsTrueTrue { get; } // WriteStoredProcFunctionParams(true, true, false) public string WriteStoredProcFunctionParamsFalseFalseToken { get; } // WriteStoredProcFunctionParams(false, false, true) public string WriteStoredProcFunctionParamsFalseTrueToken { get; } // WriteStoredProcFunctionParams(false, true, true) public string WriteStoredProcFunctionParamsTrueFalseToken { get; } // WriteStoredProcFunctionParams(true, false, true) public string WriteStoredProcFunctionParamsTrueTrueToken { get; } // WriteStoredProcFunctionParams(true, true, true) public bool AsyncFunctionCannotBeCreated { get; } // !sp.StoredProcCanExecuteAsync() public string WriteStoredProcFunctionOverloadCall { get; } // sp.WriteStoredProcFunctionOverloadCall() public string WriteStoredProcFunctionSetSqlParametersFalse { get; } // WriteStoredProcFunctionSetSqlParameters(false) public string WriteStoredProcFunctionSetSqlParametersTrue { get; } // WriteStoredProcFunctionSetSqlParameters(true) public string Exec { get; } public string AsyncExec { get; } public string WriteStoredProcReturnModelName { get; } // sp.WriteStoredProcReturnModelName() public string WriteStoredProcFunctionSqlParameterAnonymousArrayTrue { get; } // sp.WriteStoredProcFunctionSqlParameterAnonymousArray(true, true, false) public string WriteStoredProcFunctionSqlParameterAnonymousArrayFalse { get; } // sp.WriteStoredProcFunctionSqlParameterAnonymousArray(false, true, false) public string WriteStoredProcFunctionSqlParameterAnonymousArrayTrueToken { get; } // sp.WriteStoredProcFunctionSqlParameterAnonymousArray(true, true, true) public string WriteStoredProcFunctionSqlParameterAnonymousArrayFalseToken { get; } // sp.WriteStoredProcFunctionSqlParameterAnonymousArray(false, true, true) public string WriteStoredProcFunctionDeclareSqlParameterTrue { get; } // sp.WriteStoredProcFunctionDeclareSqlParameter(true) public string WriteStoredProcFunctionDeclareSqlParameterFalse { get; } // sp.WriteStoredProcFunctionDeclareSqlParameter(false) public List Parameters { get; } public int ReturnModelsCount { get; } public string ExecWithNoReturnModel { get; } public List ReturnModelResultSetReaderCommand { get; } public bool CreateDbSetForReturnModel { get; set; } public StoredProcTemplateData( bool hasNoReturnModels, bool hasReturnModels, bool singleReturnModel, bool multipleReturnModels, string returnType, string returnModelName, string functionName, string writeStoredProcFunctionParamsFalseFalse, string writeStoredProcFunctionParamsFalseTrue, string writeStoredProcFunctionParamsTrueFalse, string writeStoredProcFunctionParamsTrueTrue, string writeStoredProcFunctionParamsFalseFalseToken, string writeStoredProcFunctionParamsFalseTrueToken, string writeStoredProcFunctionParamsTrueFalseToken, string writeStoredProcFunctionParamsTrueTrueToken, bool asyncFunctionCannotBeCreated, string writeStoredProcFunctionOverloadCall, string writeStoredProcFunctionSetSqlParametersFalse, string writeStoredProcFunctionSetSqlParametersTrue, string exec, string asyncExec, string writeStoredProcReturnModelName, string writeStoredProcFunctionSqlParameterAnonymousArrayTrue, string writeStoredProcFunctionSqlParameterAnonymousArrayFalse, string writeStoredProcFunctionSqlParameterAnonymousArrayTrueToken, string writeStoredProcFunctionSqlParameterAnonymousArrayFalseToken, string writeStoredProcFunctionDeclareSqlParameterTrue, string writeStoredProcFunctionDeclareSqlParameterFalse, List parameters, int returnModelsCount, string execWithNoReturnModel) { HasNoReturnModels = hasNoReturnModels; HasReturnModels = hasReturnModels; SingleReturnModel = singleReturnModel; MultipleReturnModels = multipleReturnModels; ReturnType = returnType; ReturnModelName = returnModelName; FunctionName = functionName; WriteStoredProcFunctionParamsFalseFalse = writeStoredProcFunctionParamsFalseFalse; WriteStoredProcFunctionParamsFalseTrue = writeStoredProcFunctionParamsFalseTrue; WriteStoredProcFunctionParamsTrueFalse = writeStoredProcFunctionParamsTrueFalse; WriteStoredProcFunctionParamsTrueTrue = writeStoredProcFunctionParamsTrueTrue; WriteStoredProcFunctionParamsFalseFalseToken = writeStoredProcFunctionParamsFalseFalseToken; WriteStoredProcFunctionParamsFalseTrueToken = writeStoredProcFunctionParamsFalseTrueToken; WriteStoredProcFunctionParamsTrueFalseToken = writeStoredProcFunctionParamsTrueFalseToken; WriteStoredProcFunctionParamsTrueTrueToken = writeStoredProcFunctionParamsTrueTrueToken; AsyncFunctionCannotBeCreated = asyncFunctionCannotBeCreated; WriteStoredProcFunctionOverloadCall = writeStoredProcFunctionOverloadCall; WriteStoredProcFunctionSetSqlParametersFalse = writeStoredProcFunctionSetSqlParametersFalse; WriteStoredProcFunctionSetSqlParametersTrue = writeStoredProcFunctionSetSqlParametersTrue; Exec = exec; AsyncExec = asyncExec; WriteStoredProcReturnModelName = writeStoredProcReturnModelName; WriteStoredProcFunctionSqlParameterAnonymousArrayTrue = writeStoredProcFunctionSqlParameterAnonymousArrayTrue; WriteStoredProcFunctionSqlParameterAnonymousArrayFalse = writeStoredProcFunctionSqlParameterAnonymousArrayFalse; WriteStoredProcFunctionSqlParameterAnonymousArrayTrueToken = writeStoredProcFunctionSqlParameterAnonymousArrayTrueToken; WriteStoredProcFunctionSqlParameterAnonymousArrayFalseToken = writeStoredProcFunctionSqlParameterAnonymousArrayFalseToken; WriteStoredProcFunctionDeclareSqlParameterTrue = writeStoredProcFunctionDeclareSqlParameterTrue; WriteStoredProcFunctionDeclareSqlParameterFalse = writeStoredProcFunctionDeclareSqlParameterFalse; Parameters = parameters; ReturnModelsCount = returnModelsCount; ExecWithNoReturnModel = execWithNoReturnModel; CreateDbSetForReturnModel = true; ReturnModelResultSetReaderCommand = new List(returnModelsCount); for (var n = 1; n <= returnModelsCount; ++n) { var lastRecord = n == returnModelsCount; ReturnModelResultSetReaderCommand.Add(new ResultSetResultReaderCommand(n, lastRecord ? "Close" : "NextResult", !lastRecord, writeStoredProcReturnModelName)); } } } public class TableTemplateData { public string DbSetName { get; } public string DbSetConfigName { get; } public string PluralTableName { get; } public string DbSetModifier { get; } public string Comment { get; } public string DbSetPrimaryKeys { get; } public Table Table { get; } public TableTemplateData(Table table) { Table = table; DbSetName = table.NameHumanCaseWithSuffix(); DbSetConfigName = table.NameHumanCaseWithSuffix() + Settings.ConfigurationClassName; PluralTableName = !string.IsNullOrWhiteSpace(table.PluralNameOverride) ? table.PluralNameOverride : Inflector.MakePlural(table.NameHumanCase); DbSetModifier = table.DbSetModifier; Comment = Settings.IncludeComments == CommentsStyle.None ? string.Empty : " // " + table.DbName; DbSetPrimaryKeys = string.Join(", ", table.PrimaryKeys.Select(x => "\"" + x.NameHumanCase + "\"")); } } public class TableValuedFunctionsTemplateData { public bool SingleReturnModel { get; } public string SingleReturnColumnName { get; } public string ExecName { get; } public string ReturnClassName { get; } public string PluralReturnClassName { get; } public string WriteStoredProcFunctionParamsFalseTrue { get; } public string WriteStoredProcFunctionParamsFalseFalse { get; } public string Name { get; } public string Schema { get; } public string WriteTableValuedFunctionDeclareSqlParameter { get; } public string WriteTableValuedFunctionSqlParameterAnonymousArray { get; } public string WriteStoredProcFunctionSqlAtParams { get; } public string FromSql { get; } public string QueryString { get; } public string ModelBuilderCommand { get; } public string ModelBuilderPostCommand { get; } public bool IncludeModelBuilder { get; } public TableValuedFunctionsTemplateData(bool singleReturnModel, string singleReturnColumnName, string execName, string returnClassName, string writeStoredProcFunctionParamsFalseTrue, string writeStoredProcFunctionParamsFalseFalse, string name, string schema, string writeTableValuedFunctionDeclareSqlParameter, string writeTableValuedFunctionSqlParameterAnonymousArray, string writeStoredProcFunctionSqlAtParams, string fromSql, string queryString, string modelBuilderCommand, string modelBuilderPostCommand, bool includeModelBuilder) { SingleReturnModel = singleReturnModel && !string.IsNullOrEmpty(singleReturnColumnName); SingleReturnColumnName = singleReturnColumnName; ExecName = execName; ReturnClassName = returnClassName; PluralReturnClassName = Inflector.MakePlural(returnClassName); WriteStoredProcFunctionParamsFalseTrue = writeStoredProcFunctionParamsFalseTrue; WriteStoredProcFunctionParamsFalseFalse = writeStoredProcFunctionParamsFalseFalse; Name = name; Schema = schema; WriteTableValuedFunctionDeclareSqlParameter = writeTableValuedFunctionDeclareSqlParameter; WriteTableValuedFunctionSqlParameterAnonymousArray = writeTableValuedFunctionSqlParameterAnonymousArray; WriteStoredProcFunctionSqlAtParams = writeStoredProcFunctionSqlAtParams; FromSql = fromSql; QueryString = queryString; ModelBuilderCommand = modelBuilderCommand; ModelBuilderPostCommand = modelBuilderPostCommand; IncludeModelBuilder = includeModelBuilder; } } public class HiLoSequence { public string Schema; public string Table; public string SequenceName; public string SequenceSchema; } public static class Inflector { public static IPluralizationService PluralisationService = null; public static List IgnoreWordsThatEndWith = new List(); ///

/// Makes the plural. ///

/// The word. /// public static string MakePlural(string word) { try { if (string.IsNullOrEmpty(word)) return string.Empty; if (PluralisationService == null) return word; if (word.Contains('_')) return MakePluralHelper(word, '_'); if (word.Contains(' ')) return MakePluralHelper(word, ' '); if (word.Contains('-')) return MakePluralHelper(word, '-'); if (IgnoreWordsThatEndWith != null && IgnoreWordsThatEndWith.Any(endsWith => word.EndsWith(endsWith, StringComparison.InvariantCulture))) return word; return PluralisationService.Pluralize(word); } catch (Exception) { return word; } } private static string MakePluralHelper(string word, char split) { if (string.IsNullOrEmpty(word)) return string.Empty; var parts = word.Split(split); parts[parts.Length - 1] = PluralisationService.Pluralize(parts[parts.Length - 1]); // Pluralise just the last word return string.Join(split.ToString(), parts); } ///

/// Makes the singular. ///

/// The word. /// public static string MakeSingular(string word) { try { if (string.IsNullOrEmpty(word)) return string.Empty; if (PluralisationService == null) return word; if (word.Contains('_')) return MakeSingularHelper(word, '_'); if (word.Contains(' ')) return MakeSingularHelper(word, ' '); if (word.Contains('-')) return MakeSingularHelper(word, '-'); if (IgnoreWordsThatEndWith != null && IgnoreWordsThatEndWith.Any(endsWith => word.EndsWith(endsWith, StringComparison.InvariantCulture))) return word; return PluralisationService.Singularize(word); } catch (Exception) { return word; } } private static string MakeSingularHelper(string word, char split) { if (string.IsNullOrEmpty(word)) return string.Empty; var parts = word.Split(split); parts[parts.Length - 1] = PluralisationService.Singularize(parts[parts.Length - 1]); // Pluralise just the last word return string.Join(split.ToString(), parts); } ///

/// Converts the string to title case. ///

/// The word. /// public static string ToTitleCase(string word) { if (string.IsNullOrEmpty(word)) return string.Empty; var s = Regex.Replace(ToHumanCase(AddUnderscores(word)), @"\b([a-z])", match => match.Captures[0].Value.ToUpperInvariant()); var digit = false; var sb = new StringBuilder(word.Length + 1); foreach (var c in s) { if (char.IsDigit(c)) { digit = true; sb.Append(c); } else { if (digit && char.IsLower(c)) sb.Append(char.ToUpperInvariant(c)); else sb.Append(c); digit = false; } } return sb.ToString(); } ///

/// Converts the string to human case. ///

/// The lowercase and underscored word. /// public static string ToHumanCase(string lowercaseAndUnderscoredWord) { if (string.IsNullOrEmpty(lowercaseAndUnderscoredWord)) return string.Empty; return MakeInitialCaps(Regex.Replace(lowercaseAndUnderscoredWord, @"_", " ")); } ///

/// Adds the underscores. ///

/// The pascal cased word. /// public static string AddUnderscores(string pascalCasedWord) { if (string.IsNullOrEmpty(pascalCasedWord)) return string.Empty; return Regex.Replace( Regex.Replace( Regex.Replace(pascalCasedWord, @"([A-Z]+)([A-Z][a-z])", "$1_$2"), @"([a-z\d])([A-Z])","$1_$2"), @"[-\s]", "_") .ToLowerInvariant(); } ///

/// Makes the initial caps. ///

/// The word. /// public static string MakeInitialCaps(string word) { if (string.IsNullOrEmpty(word)) return string.Empty; return string.Concat(word.Substring(0, 1).ToUpperInvariant(), word.Substring(1).ToLowerInvariant()); } ///

/// Makes the initial character lowercase. ///

/// The word. /// public static string MakeInitialLower(string word) { if (string.IsNullOrEmpty(word)) return string.Empty; return string.Concat(word.Substring(0, 1).ToLowerInvariant(), word.Substring(1)); } public static string MakeLowerIfAllCaps(string word) { if (string.IsNullOrEmpty(word)) return string.Empty; return IsAllCaps(word) ? word.ToLowerInvariant() : word; } public static bool IsAllCaps(string word) { if (string.IsNullOrEmpty(word)) return false; return word.All(char.IsUpper); } } public static class DatabaseToPropertyTypeFactory { public static IDatabaseToPropertyType Create() { var factory = CreateDatabaseLanguageFactory(); return factory.Create(); } private static IDatabaseLanguageFactory CreateDatabaseLanguageFactory() { switch (Settings.DatabaseType) { case DatabaseType.SqlServer: case DatabaseType.SqlCe: return new SqlServerLanguageFactory(); case DatabaseType.SQLite: return new SQLiteLanguageFactory(); case DatabaseType.Plugin: return new PluginLanguageFactory(); case DatabaseType.MySql: return new MySqlLanguageFactory(); case DatabaseType.PostgreSQL: return new PostgresLanguageFactory(); case DatabaseType.Oracle: return new OracleLanguageFactory(); default: throw new ArgumentOutOfRangeException(); } } } public enum GenerationLanguage { CSharp, Javascript } public interface IDatabaseToPropertyType { Dictionary GetMapping(); // [Database type] = Language type ///

/// A list of the database types that are spatial. ///

List SpatialTypes(); ///

/// A list of the database types that contain precision. ///

List PrecisionTypes(); ///

/// A list of the database types that contain precision and scale. ///

List PrecisionAndScaleTypes(); } public interface IDatabaseLanguageFactory { IDatabaseToPropertyType Create(); } public class MySqlLanguageFactory : IDatabaseLanguageFactory { public IDatabaseToPropertyType Create() { switch (Settings.GenerationLanguage) { case GenerationLanguage.CSharp: return new MySqlToCSharp(); case GenerationLanguage.Javascript: // Not yet supported default: return new MySqlToCSharp(); } } } public class OracleLanguageFactory : IDatabaseLanguageFactory { public IDatabaseToPropertyType Create() { switch (Settings.GenerationLanguage) { case GenerationLanguage.CSharp: return new MySqlToCSharp(); case GenerationLanguage.Javascript: // Not yet supported default: return new MySqlToCSharp(); } } } public class PluginLanguageFactory : IDatabaseLanguageFactory { public IDatabaseToPropertyType Create() { return null; // Will ask plugin for it } } public class PostgresLanguageFactory : IDatabaseLanguageFactory { public IDatabaseToPropertyType Create() { switch (Settings.GenerationLanguage) { case GenerationLanguage.CSharp: return new PostgresToCSharp(); case GenerationLanguage.Javascript: // Not yet supported default: return new PostgresToCSharp(); } } } public class SQLiteLanguageFactory : IDatabaseLanguageFactory { public IDatabaseToPropertyType Create() { switch (Settings.GenerationLanguage) { case GenerationLanguage.CSharp: return new SqLiteToCSharp(); case GenerationLanguage.Javascript: // Not yet supported default: throw new ArgumentOutOfRangeException(); } } } public class SqlServerLanguageFactory : IDatabaseLanguageFactory { public IDatabaseToPropertyType Create() { switch (Settings.GenerationLanguage) { case GenerationLanguage.CSharp: return new SqlServerToCSharp(); case GenerationLanguage.Javascript: return new SqlServerToJavascript(); default: throw new ArgumentOutOfRangeException(); } } } public class MySqlToCSharp : IDatabaseToPropertyType { public Dictionary GetMapping() { var geographyType = Settings.TemplateType == TemplateType.Ef6 ? "DbGeography" : "NetTopologySuite.Geometries.Point"; var geometryType = Settings.TemplateType == TemplateType.Ef6 ? "DbGeometry" : "NetTopologySuite.Geometries.Geometry"; // [Database type] = Language type return new Dictionary { { string.Empty, "string" }, // default { "bigint unsigned", "decimal" }, { "bigint", "long" }, { "binary", "byte[]" }, { "bit", "long" }, { "bit(1)", "bool" }, { "blob", "byte[]" }, { "bool", "bool" }, { "boolean", "bool" }, { "char byte", "byte[]" }, { "char", "string" }, { "character varying", "string" }, { "date", "DateTime" }, { "datetime", "DateTime" }, { "datetimeoffset", "DateTimeOffset" }, { "dec", "decimal" }, { "decimal", "decimal" }, { "double unsigned", "decimal" }, { "double", "double" }, { "enum", "string" }, { "fixed", "decimal" }, { "float unsigned", "decimal" }, { "float", "double" }, { "geography", Settings.DisableGeographyTypes ? string.Empty : geographyType }, { "geometry", Settings.DisableGeographyTypes ? string.Empty : geometryType }, { "int unsigned", "long" }, { "int", "int" }, { "integer unsigned", "long" }, { "integer", "int" }, { "longblob", "byte[]" }, { "longtext", "string" }, { "mediumblob", "byte[]" }, { "mediumint", "int" }, { "mediumtext", "string" }, { "national char", "string" }, { "national varchar", "string" }, { "nchar", "string" }, { "numeric", "decimal" }, { "nvarchar", "string" }, { "real", "double" }, { "serial", "decimal" }, { "set", "string" }, { "smallint unsigned", "int" }, { "smallint", "short" }, { "text", "string" }, { "time", "TimeSpan" }, { "timestamp", "DateTime" }, { "tinyblob", "byte[]" }, { "tinyint unsigned", "byte" }, { "tinyint", "SByte" }, { "tinytext", "string" }, { "varbinary", "byte[]" }, { "varchar", "string" }, { "year", "short" } }; } public List SpatialTypes() { return new List { "geography", "geometry", "point", "linestring", "polygon", "multipoint", "multilinestring", "multipolygon", "geometrycollection" }; } public List PrecisionTypes() { return new List { "float", "datetime", "time", "timestamp", "year" }; } public List PrecisionAndScaleTypes() { return new List { "decimal", "numeric" }; } } public class OracleToCSharp : IDatabaseToPropertyType { // [Database type] = Language type public Dictionary GetMapping() { return new Dictionary { { string.Empty, "string" }, // default { "binary_double", "decimal" }, { "binary_float", "double" }, { "binary_integer", "long" }, { "blob", "byte[]" }, { "char", "string" }, { "clob", "string" }, { "date", "DateTime" }, { "float", "double" }, { "interval day to second", "decimal" }, { "interval year to month", "decimal" }, { "long raw", "byte[]" }, { "long", "long" }, { "nchar", "string" }, { "nclob", "string" }, { "number", "decimal" }, { "nvarchar2", "string" }, { "pls_integer", "long" }, { "raw", "byte[]" }, { "real", "float" }, { "rowid", "string" }, { "timestamp with local time zone", "DateTime" }, { "timestamp with time zone", "DateTime" }, { "timestamp", "DateTime" }, { "urowid", "string" }, { "varchar2", "string" }, { "xmltype", "string" } }; } public List SpatialTypes() { return new List { "sdo_geometry" }; } public List PrecisionTypes() { return new List { "float", "timestamp", "timestamp with time zone", "timestamp with local time zone" }; } public List PrecisionAndScaleTypes() { return new List { "number" }; } } public class PostgresToCSharp : IDatabaseToPropertyType { // [Database type] = Language type public Dictionary GetMapping() { return new Dictionary { { string.Empty, "string" }, // default { "bigint", "long" }, { "bigserial", "long" }, { "bit varying", "BitArray" }, { "bit", "BitArray" }, { "bool", "bool" }, { "boolean", "bool" }, { "box", "NpgsqlBox" }, { "bytea", "byte[]" }, { "char", "char" }, { "character varying", "string" }, { "character", "string" }, { "cid", "uint" }, { "cidr", "NpgsqlInet" }, { "circle", "NpgsqlCircle" }, { "citext", "string" }, { "date", "DateTime" }, { "decimal", "decimal" }, { "double precision", "double" }, { "float4", "float" }, { "float8", "double" }, { "geometry", Settings.DisableGeographyTypes ? string.Empty : "PostgisGeometry" }, { "hstore", "Dictionary" }, { "inet", "NpgsqlInet" }, { "int", "int" }, { "int2", "short" }, { "int4", "int" }, { "int8", "long" }, { "integer", "int" }, { "interval", "TimeSpan" }, { "json", "string" }, { "jsonb", "string" }, { "line", "NpgsqlLine" }, { "lseg", "NpgsqlLSeg" }, { "macaddr", "PhysicalAddress" }, { "money", "decimal" }, { "name", "string" }, { "numeric", "decimal" }, { "oid", "uint" }, { "oidvector", "uint[]" }, { "path", "NpgsqlPath" }, { "point", "NpgsqlPoint" }, { "polygon", "NpgsqlPolygon" }, { "real", "float" }, { "record", "object[]" }, { "serial", "int" }, { "serial4", "int" }, { "serial8", "long" }, { "smallint", "short" }, { "text", "string" }, { "time", "TimeSpan" }, { "time with time zone", "DateTimeOffset" }, { "time without time zone", "TimeSpan" }, { "timetz", "TimeSpan" }, { "timestamp", "DateTime" }, { "timestamp with time zone", "DateTime" }, { "timestamp without time zone", "DateTime" }, { "timestamptz", "DateTime" }, { "tsquery", "NpgsqlTsQuery" }, { "tsvector", "NpgsqlTsVector" }, { "uuid", "Guid" }, { "varbit", "BitArray" }, { "xid", "uint" }, { "xml", "string" } //{ "composite types", "T" }, //{ "range subtypes", "NpgsqlRange" }, //{ "enum types", "TEnum" }, //{ "array types", "Array (of element type)" }, }; } public List SpatialTypes() { return new List { "geometry", "point", "line", "lseg", "box", "path", "polygon", "circle" }; } public List PrecisionTypes() { return new List { "float" }; } public List PrecisionAndScaleTypes() { return new List { "decimal", "numeric" }; } } public class SqLiteToCSharp : IDatabaseToPropertyType { // [Database type] = Language type public Dictionary GetMapping() { return new Dictionary { { string.Empty, "string" }, // default { "bigint", "long" }, { "blob", "byte[]" }, { "boolean", "bool" }, { "character", "string" }, { "clob", "string" }, { "date", "DateTime" }, { "datetime", "DateTime" }, { "decimal", "double" }, { "double", "double" }, { "double precision", "double" }, { "float", "double" }, { "int", "long" }, { "int2", "long" }, { "int8", "long" }, { "integer", "long" }, { "mediumint", "long" }, { "native character", "string" }, { "nchar", "string" }, { "numeric", "decimal" }, { "nvarchar", "string" }, { "real", "double" }, { "smallint", "int" }, { "text", "string" }, { "unsigned big int", "long" }, { "varchar", "string" }, { "varying character", "string" } }; } public List SpatialTypes() { return new List(); } public List PrecisionTypes() { return new List(); } public List PrecisionAndScaleTypes() { return new List(); } } public class SqlServerToCSharp : IDatabaseToPropertyType { // [Database type] = Language type public Dictionary GetMapping() { var geographyType = Settings.TemplateType == TemplateType.Ef6 ? "DbGeography" : "NetTopologySuite.Geometries.Point"; var geometryType = Settings.TemplateType == TemplateType.Ef6 ? "DbGeometry" : "NetTopologySuite.Geometries.Geometry"; return new Dictionary { { string.Empty, "string" }, // default { "bigint", "long" }, { "binary", "byte[]" }, { "bit", "bool" }, { "date", "DateTime" }, { "datetime", "DateTime" }, { "datetime2", "DateTime" }, { "datetimeoffset", "DateTimeOffset" }, { "decimal", "decimal" }, { "float", "double" }, { "geography", Settings.DisableGeographyTypes ? string.Empty : geographyType }, { "geometry", Settings.DisableGeographyTypes ? string.Empty : geometryType }, { "hierarchyid", "Hierarchy.HierarchyId" }, { "image", "byte[]" }, { "int", "int" }, { "money", "decimal" }, { "numeric", "decimal" }, { "real", "float" }, { "smalldatetime", "DateTime" }, { "smallint", "short" }, { "smallmoney", "decimal" }, { "table type", "DataTable" }, { "time", "TimeSpan" }, { "timestamp", "byte[]" }, { "tinyint", "byte" }, { "uniqueidentifier", "Guid" }, { "varbinary", "byte[]" }, { "varbinary(max)", "byte[]" } }; } public List SpatialTypes() { return new List { "geography", "geometry" }; } public List PrecisionTypes() { return new List { "float", "datetime2", "datetimeoffset" }; } public List PrecisionAndScaleTypes() { return new List { "decimal", "numeric" }; } } public class SqlServerToJavascript : IDatabaseToPropertyType { // [Database type] = Language type public Dictionary GetMapping() { return new Dictionary { { string.Empty, "string" }, // default { "bigint", "Number" }, { "binary", "string" }, { "bit", "boolean" }, { "date", "string" }, { "datetime", "string" }, { "datetime2", "string" }, { "datetimeoffset", "string" }, { "decimal", "Number" }, { "float", "Number" }, { "geography", Settings.DisableGeographyTypes ? string.Empty : "string" }, { "geometry", Settings.DisableGeographyTypes ? string.Empty : "string" }, { "hierarchyid", "string" }, { "image", "string" }, { "int", "Number" }, { "money", "Number" }, { "numeric", "Number" }, { "real", "Number" }, { "smalldatetime", "string" }, { "smallint", "Number" }, { "smallmoney", "Number" }, { "table type", string.Empty }, { "time", "string" }, { "timestamp", "string" }, { "tinyint", "Number" }, { "uniqueidentifier", "string" }, { "varbinary", "string" }, { "varbinary(max)", "string" } }; } public List SpatialTypes() { return new List { "geography", "geometry" }; } public List PrecisionTypes() { return new List { "float", "datetime2", "datetimeoffset" }; } public List PrecisionAndScaleTypes() { return new List { "decimal", "numeric" }; } } public class DigitalSignaturePublic { private readonly RSAParameters _publicKey; public DigitalSignaturePublic() { _publicKey = new RSAParameters { Exponent = Hex.HexToByteArray("010001"), Modulus = Hex.HexToByteArray("B9C08035CECAA5CE4442D2A44B62EAEC0FF337972E6DD7A2135FA00863607C0E6C3B7B25520A562F180C1479E832945F7F82721DE2E1DA01D572F734B92CA1A8EB5FC419FA6B34A2E71DCB0B25818D2ACA5AD8A41647C9814315887324562B422C835DA270D8843F8E44C02BEE4EFCC524F40807148EDCB5D43362F9F05077EF816177BD0C680A6B8A7005251C77BA8F43C47881967341FC7D3AAD9055CADA320E3AB5890E64FCD68B1B0E2E3661EABBB5FC087FBC2E495FC90769F92DE0BB9CFBFC15E36927B52DDD43A3BA7B47C713BCAA532CBD5DEAE60D1D1E6F6D31A6E871452528F0EB96803EC725BB67B4CA123840EAF04D0F5E74EAFE3AF7F9970021") }; } public bool VerifySignature(string text, byte[] signature) { using (var rsa = new RSACryptoServiceProvider(2048)) { rsa.ImportParameters(_publicKey); var rsaDeformatter = new RSAPKCS1SignatureDeformatter(rsa); rsaDeformatter.SetHashAlgorithm("SHA256"); return rsaDeformatter.VerifySignature(HashText(text), signature); } } private byte[] HashText(string text) { var provider = new SHA256CryptoServiceProvider(); var hash = provider.ComputeHash(Encoding.Unicode.GetBytes(text)); return hash; } } public static class Hex { ///

/// Converts HEX string to byte array. /// Opposite of ByteArrayToHex. ///

public static byte[] HexToByteArray(string hexString) { if (hexString == null) return null; if ((hexString.Length % 2) != 0) throw new ApplicationException("Hex string must be multiple of 2 in length"); var byteCount = hexString.Length / 2; var byteValues = new byte[byteCount]; for (var i = 0; i < byteCount; i++) { byteValues[i] = Convert.ToByte(hexString.Substring(i * 2, 2), 16); } return byteValues; } ///

/// Convert bytes to 2 hex characters per byte, "-" separators are removed. /// Opposite of HexToByteArray ///

public static string ByteArrayToHex(byte[] data) { if (data == null) return string.Empty; return BitConverter.ToString(data).Replace("-", ""); } } public class Licence { public string RegisteredTo { get; private set; } public string Company { get; private set; } public LicenceType LicenceType { get; private set; } public string NumLicences { get; private set; } public DateTime ValidUntil { get; private set; } public Licence(string registeredTo, string company, LicenceType licenceType, string numLicences, DateTime validUntil) { RegisteredTo = registeredTo; Company = company; LicenceType = licenceType; NumLicences = numLicences; ValidUntil = validUntil; } public string GetLicenceType() { return GetLicenceType(LicenceType); } public static string GetLicenceType(LicenceType licenceType) { switch (licenceType) { case LicenceType.Academic: return "Academic license - for non-commercial use only"; case LicenceType.Commercial: return "Commercial"; case LicenceType.Trial: return "Trial - for non-commercial trial use only"; default: throw new ArgumentOutOfRangeException(); } } public static LicenceType ParseLicenceType(string licenceType) { licenceType = licenceType.Substring(0, 5); foreach (var type in Enum.GetValues(typeof(LicenceType)).Cast()) { if (GetLicenceType(type).Substring(0, 5) == licenceType) return type; } throw new ArgumentOutOfRangeException(); } public override string ToString() { return string.Format("{0}|{1}|{2}|{3}|{4}", RegisteredTo.ToUpperInvariant().Trim(), Company.ToUpperInvariant().Trim(), GetLicenceType(), NumLicences.ToUpperInvariant().Trim(), ValidUntil.ToString(LicenceConstants.ExpiryFormat, CultureInfo.InvariantCulture).ToUpperInvariant()); } } public static class LicenceConstants { public static string ExpiryFormat = "dd MMM yyyy"; public static string RegisteredTo = "Registered to: "; public static string Company = "Company : "; public static string LicenceType = "Licence Type : "; public static string NumLicences = "Licences : "; public static string ValidUntil = "Valid until : "; public static string Signature = "Signature:"; } public enum LicenceType { Academic, Commercial, Trial } public class LicenceValidator { private readonly DigitalSignaturePublic _ds; public Licence Licence; public bool Expired; public LicenceValidator() { _ds = new DigitalSignaturePublic(); } public bool Validate(string licenceInput) { try { var array = licenceInput.Replace("\n", "\r").Replace("\r\r", "\r").Trim().Split('\r'); var expiryText = ParseString(array, LicenceConstants.ValidUntil); var parsedExpiry = DateTime.ParseExact(expiryText, LicenceConstants.ExpiryFormat, CultureInfo.InvariantCulture, DateTimeStyles.AssumeLocal); var expiryEndOfDay = new DateTime(parsedExpiry.Year, parsedExpiry.Month, parsedExpiry.Day, 23, 59, 59, DateTimeKind.Local); Expired = expiryEndOfDay < DateTime.Now; if (Expired) return false; Licence = new Licence( ParseString(array, LicenceConstants.RegisteredTo), ParseString(array, LicenceConstants.Company), Licence.ParseLicenceType(ParseString(array, LicenceConstants.LicenceType)), ParseString(array, LicenceConstants.NumLicences), expiryEndOfDay); var foundSignature = false; var sigUpperCase = LicenceConstants.Signature; var signature = new StringBuilder(1024); foreach (var line in array) { if (foundSignature) signature.Append(line); else if (line.StartsWith(sigUpperCase)) foundSignature = true; } return _ds.VerifySignature(Licence.ToString(), Hex.HexToByteArray(signature.ToString().Trim())); } catch { return false; } } private string ParseString(string[] array, string find) { foreach (var line in array) { if (line.StartsWith(find)) return line.Substring(line.IndexOf(':') + 2).Trim(); } throw new ArgumentOutOfRangeException(); } } ///

/// Associates parameters to their argument values. ///

internal sealed class ArgumentCollection { private readonly Dictionary _argumentLookup; ///

/// Initializes a new instance of an ArgumentCollection. ///

public ArgumentCollection() { _argumentLookup = new Dictionary(); } ///

/// Associates the given parameter to the key placeholder. ///

/// The parameter to associate the key with. /// The argument. /// If the key is null, the default value of the parameter will be used. public void AddArgument(TagParameter parameter, IArgument argument) { _argumentLookup.Add(parameter, argument); } ///

/// Gets the key that will be used to find the substitute value. ///

/// The name of the parameter. public string GetKey(TagParameter parameter) { IArgument argument; if (_argumentLookup.TryGetValue(parameter, out argument) && argument != null) { return argument.GetKey(); } else { return null; } } ///

/// Substitutes the key placeholders with their respective values. ///

/// The key/value pairs in the current lexical scope. /// The key/value pairs in current context. /// A dictionary associating the parameter name to the associated value. public Dictionary GetArguments(Scope keyScope, Scope contextScope) { Dictionary arguments = new Dictionary(); foreach (KeyValuePair pair in _argumentLookup) { object value; if (pair.Value == null) { value = pair.Key.DefaultValue; } else { value = pair.Value.GetValue(keyScope, contextScope); } arguments.Add(pair.Key.Name, value); } return arguments; } public Dictionary GetArgumentKeyNames() { return _argumentLookup.ToDictionary(p => p.Key.Name, p => (object)GetKey(p.Key)); } } ///

/// Builds text by combining the output of other generators. ///

internal sealed class CompoundMustacheGenerator : IMustacheGenerator { private readonly TagDefinition _definition; private readonly ArgumentCollection _arguments; private readonly List _primaryGenerators; private IMustacheGenerator _subMustacheGenerator; ///

/// Initializes a new instance of a CompoundGenerator. ///

/// The tag that the text is being generated for. /// The arguments that were passed to the tag. public CompoundMustacheGenerator(TagDefinition definition, ArgumentCollection arguments) { _definition = definition; _arguments = arguments; _primaryGenerators = new List(); } ///

/// Adds the given generator. ///

/// The generator to add. public void AddGenerator(IMustacheGenerator mustacheGenerator) { addGenerator(mustacheGenerator, false); } ///

/// Adds the given generator, determining whether the generator should /// be part of the primary generators or added as an secondary generator. ///

/// The tag that the generator is generating text for. /// The generator to add. public void AddGenerator(TagDefinition definition, IMustacheGenerator mustacheGenerator) { bool isSubGenerator = _definition.ShouldCreateSecondaryGroup(definition); addGenerator(mustacheGenerator, isSubGenerator); } private void addGenerator(IMustacheGenerator mustacheGenerator, bool isSubGenerator) { if (isSubGenerator) { _subMustacheGenerator = mustacheGenerator; } else { _primaryGenerators.Add(mustacheGenerator); } } void IMustacheGenerator.GetText(TextWriter writer, Scope keyScope, Scope contextScope, Action postProcessor) { Dictionary arguments = _arguments.GetArguments(keyScope, contextScope); IEnumerable contexts = _definition.GetChildContext(writer, keyScope, arguments, contextScope); List generators; if (_definition.ShouldGeneratePrimaryGroup(arguments)) { generators = _primaryGenerators; } else { generators = new List(); if (_subMustacheGenerator != null) { generators.Add(_subMustacheGenerator); } } foreach (NestedContext context in contexts) { foreach (IMustacheGenerator generator in generators) { generator.GetText(context.Writer ?? writer, context.KeyScope ?? keyScope, context.ContextScope, postProcessor); } if (context.WriterNeedsConsidated) { writer.Write(_definition.ConsolidateWriter(context.Writer ?? writer, arguments)); } } } } ///

/// Defines a tag that conditionally prints its content. ///

internal abstract class ConditionTagDefinition : ContentTagDefinition { private const string ConditionParameter = "condition"; private static readonly TagParameter[] InnerParameters = { new TagParameter(ConditionParameter) { IsRequired = true } }; private static readonly TagParameter[] InnerChildContextParameters = { }; private static readonly string[] InnerChildTags = { "elif", "else" }; ///

/// Initializes a new instance of a ConditionTagDefinition. ///

/// The name of the tag. protected ConditionTagDefinition(string tagName) : base(tagName, true) { } ///

/// Gets the parameters that can be passed to the tag. ///

/// The parameters. protected override IEnumerable GetParameters() => InnerParameters; ///

/// Gets the tags that come into scope within the context of the current tag. ///

/// The child tag definitions. protected override IEnumerable GetChildTags() => InnerChildTags; ///

/// Gets whether the given tag's generator should be used for a secondary (or substitute) text block. ///

/// The tag to inspect. /// True if the tag's generator should be used as a secondary generator. public override bool ShouldCreateSecondaryGroup(TagDefinition definition) { return InnerChildTags.Contains(definition.Name); } ///

/// Gets whether the primary generator group should be used to render the tag. ///

/// The arguments passed to the tag. /// /// True if the primary generator group should be used to render the tag; /// otherwise, false to use the secondary group. /// public override bool ShouldGeneratePrimaryGroup(Dictionary arguments) { object condition = arguments[ConditionParameter]; return isConditionSatisfied(condition); } private bool isConditionSatisfied(object condition) { if (condition == null || condition == DBNull.Value) { return false; } IEnumerable enumerable = condition as IEnumerable; if (enumerable != null) { return enumerable.Cast { public Table GetTable(string tableName, string schema) { return this.SingleOrDefault(x => string.Compare(x.DbName, tableName, StringComparison.OrdinalIgnoreCase) == 0 && string.Compare(x.Schema.DbName, schema, StringComparison.OrdinalIgnoreCase) == 0); } public void IdentifyMappingTables(List fkList, bool checkForFkNameClashes, bool includeSchema) { foreach (var tbl in this.Where(x => x.HasForeignKey)) { tbl.IdentifyMappingTable(fkList, this, checkForFkNameClashes, includeSchema); } } public void ResetNavigationProperties() { foreach (var tbl in this) { tbl.ResetNavigationProperties(); } } public void TrimForTrialLicence() { // Mapping tables do not count const int n = 1 + 2 + 3 + 4; TrimForLicence(n); } private void TrimForLicence(int n) { if (this.Count(x => !x.IsMapping) <= n) return; RemoveAll(x => !x.HasPrimaryKey); while (this.Count(x => !x.IsMapping) > n) { try { var index = FindIndex(x => !x.IsMapping); RemoveAt(index); } catch { // Cannot remove anymore return; } } } } public class ContextModel { public string DbContextClassModifiers { get; set; } public string DbContextName { get; set; } public string DbContextBaseClass { get; set; } public bool AddParameterlessConstructorToDbContext { get; set; } public bool HasDefaultConstructorArgument { get; set; } public string DefaultConstructorArgument { get; set; } public string ConfigurationClassName { get; set; } public string contextInterface { get; set; } public string setInitializer { get; set; } public bool DbContextClassIsPartial { get; set; } public bool SqlCe { get; set; } public List tables { get; set; } public bool hasTables { get; set; } public List indexes { get; set; } public bool hasIndexes { get; set; } public List storedProcs { get; set; } public bool hasStoredProcs { get; set; } public List tableValuedFunctionComplexTypes { get; set; } public bool hasTableValuedFunctionComplexTypes { get; set; } public List AdditionalContextInterfaceItems { get; set; } public bool addSaveChanges { get; set; } public List tableValuedFunctions { get; set; } public List scalarValuedFunctions { get; set; } public List Sequences { get; set; } public bool hasSequences { get; set; } public bool hasTableValuedFunctions { get; set; } public bool hasScalarValuedFunctions { get; set; } public string ConnectionString { get; set; } public string ConnectionStringName { get; set; } public string ConnectionStringActions { get; set; } public bool IncludeObjectContextConstructor { get; set; } public string QueryString { get; set; } public string FromSql { get; set; } public string ExecuteSqlCommand { get; set; } public string StoredProcModelBuilderCommand { get; set; } public string StoredProcModelBuilderPostCommand { get; set; } public bool OnConfigurationUsesConfiguration { get; set; } public bool OnConfigurationUsesConnectionString { get; set; } public string DefaultSchema { get; set; } public string UseDatabaseProvider { get; set; } public string SqlParameter { get; set; } public string SqlParameterValue { get; set; } public bool UseLazyLoadingProxies { get; set; } public bool hasTriggers { get; set; } public List Triggers { get; set; } public bool hasMemoryOptimisedTables { get; set; } public List MemoryOptimisedTables { get; set; } } public class FactoryModel { public string classModifier { get; set; } public string contextName { get; set; } } public class FakeContextModel { public string DbContextClassModifiers { get; set; } public string DbContextName { get; set; } public string DbContextBaseClass { get; set; } public string contextInterface { get; set; } public bool DbContextClassIsPartial { get; set; } public List tables { get; set; } public List storedProcs { get; set; } public bool hasStoredProcs { get; set; } public List tableValuedFunctions { get; set; } public List scalarValuedFunctions { get; set; } public bool hasTableValuedFunctions { get; set; } public bool hasScalarValuedFunctions { get; set; } } public class FakeDbSetModel { public string DbContextClassModifiers { get; set; } public bool DbContextClassIsPartial { get; set; } } public class InterfaceModel { public string interfaceModifier { get; set; } public string DbContextInterfaceName { get; set; } public string DbContextInterfaceBaseClasses { get; set; } public string DbContextName { get; set; } public List tables { get; set; } public List AdditionalContextInterfaceItems { get; set; } public bool addSaveChanges { get; set; } public List storedProcs { get; set; } public bool hasStoredProcs { get; set; } public List tableValuedFunctions { get; set; } public List scalarValuedFunctions { get; set; } public bool hasTableValuedFunctions { get; set; } public bool hasScalarValuedFunctions { get; set; } } public class PocoConfigurationModel { public string Name { get; set; } public string ConfigurationClassName { get; set; } public string NameHumanCaseWithSuffix { get; set; } public string Schema { get; set; } public string PrimaryKeyNameHumanCase { get; set; } public bool HasSchema { get; set; } public bool NotUsingDataAnnotations { get; set; } public string ClassModifier { get; set; } public string ClassComment { get; set; } public List Columns { get; set; } public bool HasReverseNavigation { get; set; } public List ReverseNavigationProperty { get; set; } public bool HasForeignKey { get; set; } public List ForeignKeys { get; set; } public List MappingConfiguration { get; set; } public List Indexes { get; set; } public bool HasIndexes { get; set; } public bool ConfigurationClassesArePartial { get; set; } public bool UseHasNoKey { get; set; } public string ToTableOrView { get; set; } public bool UsesDictionary { get; set; } public bool HasSpatial { get; set; } } public class PocoModel { public bool UseHasNoKey { get; set; } public bool HasNoPrimaryKey { get; set; } public string Name { get; set; } public string NameHumanCaseWithSuffix { get; set; } public string ClassModifier { get; set; } public string ClassComment { get; set; } public string ExtendedComments { get; set; } public string ClassAttributes { get; set; } public string BaseClasses { get; set; } public string InsideClassBody { get; set; } public List Columns { get; set; } public bool HasReverseNavigation { get; set; } public List ReverseNavigationProperty { get; set; } public bool HasForeignKey { get; set; } public string ForeignKeyTitleComment { get; set; } public List ForeignKeys { get; set; } public bool CreateConstructor { get; set; } public List ColumnsWithDefaults { get; set; } public List ReverseNavigationCtor { get; set; } public bool EntityClassesArePartial { get; set; } public bool HasHierarchyId { get; set; } public bool HasSpatial { get; set; } } public class PocoColumnModel { public bool AddNewLineBefore { get; set; } public bool HasSummaryComments { get; set; } public string SummaryComments { get; set; } public List Attributes { get; set; } public bool OverrideModifier { get; set; } public bool IncludeFieldNameConstants { get; set; } public string WrapIfNullable { get; set; } public string NameHumanCase { get; set; } public string PrivateSetterForComputedColumns { get; set; } public string PropertyInitialisers { get; set; } public string InlineComments { get; set; } } public class PocoReverseNavigationPropertyModel { public bool ReverseNavHasComment { get; set; } public string ReverseNavComment { get; set; } public string[] AdditionalReverseNavigationsDataAnnotations { get; set; } public string[] AdditionalDataAnnotations { get; set; } public string Definition { get; set; } } public class PocoForeignKeyModel { public bool HasFkComment { get; set; } public string FkComment { get; set; } public string[] AdditionalForeignKeysDataAnnotations { get; set; } public string[] AdditionalDataAnnotations { get; set; } public string Definition { get; set; } } public class PocoColumnsWithDefaultsModel { public string NameHumanCase { get; set; } public string Default { get; set; } } public class StoredProcReturnModel { public string ResultClassModifiers { get; set; } public string WriteStoredProcReturnModelName { get; set; } public string PropertyGetSet { get; set; } public bool SingleModel { get; set; } public List SingleModelReturnColumns { get; set; } public List MultipleModelReturnColumns { get; set; } } public class Trigger { public string TableName { get; set; } public string TriggerName { get; set; } } public enum GeneratorType { Ef6, EfCore, Custom } ///

/// {{Mustache}} template documentation available at https://github.com/jehugaleahsa/mustache-sharp ///

public abstract class Template { public abstract string Usings(); public abstract List DatabaseContextInterfaceUsings(InterfaceModel data); public abstract string DatabaseContextInterface(); public abstract List DatabaseContextUsings(ContextModel data); public abstract string DatabaseContext(); public abstract List DatabaseContextFactoryUsings(FactoryModel data); public abstract string DatabaseContextFactory(); public abstract List FakeDatabaseContextUsings(FakeContextModel data, IDbContextFilter filter); public abstract string FakeDatabaseContext(); public abstract List FakeDbSetUsings(FakeDbSetModel data); public abstract string FakeDbSet(); public abstract List PocoUsings(PocoModel data); public abstract string Poco(); public abstract List PocoConfigurationUsings(PocoConfigurationModel data); public abstract string PocoConfiguration(); public abstract List StoredProcReturnModelUsings(); public abstract string StoredProcReturnModels(); public abstract List EnumUsings(); public abstract string Enums(); public static string Transform(string template, object data) { if (data == null || template == null) return template; // Thanks to the awesome work by Travis Parks and Keith Williams for the Mustache# for .NET Core library // which is available at https://github.com/SunBrandingSolutions/mustache-sharp var parser = new FormatCompiler(); var mustacheGenerator = parser.Compile(template.Replace("\n", string.Empty).Replace("\r", string.Empty)); return mustacheGenerator.Render(data); } } ///

/// {{Mustache}} template documentation available at https://github.com/jehugaleahsa/mustache-sharp ///

public class TemplateEf6 : Template { public override string Usings() { return @" {{#each this}} using {{this}};{{#newline}} {{/each}}"; } public override List DatabaseContextInterfaceUsings(InterfaceModel data) { var usings = new List { "System", "System.Data", "System.Threading.Tasks", "System.Threading" }; if (Settings.IncludeCodeGeneratedAttribute) usings.Add("System.CodeDom.Compiler"); if (data.tables.Any() || data.hasStoredProcs) { usings.Add("System.Data.Entity"); usings.Add("System.Data.Entity.Spatial"); usings.Add("System.Linq"); } if (data.hasStoredProcs) usings.Add("System.Collections.Generic"); if (!Settings.UseInheritedBaseInterfaceFunctions) { usings.Add("System.Data.Entity"); usings.Add("System.Data.Entity.Infrastructure"); usings.Add("System.Collections.Generic"); usings.Add("System.Data.Entity.Validation"); } return usings; } public override string DatabaseContextInterface() { return @" {{interfaceModifier}} interface {{DbContextInterfaceName}} : {{DbContextInterfaceBaseClasses}}{{#newline}} {{{#newline}} {{#each tables}} DbSet<{{DbSetName}}> {{PluralTableName}} { get; set; }{{Comment}}{{#newline}} {{/each}} {{#if AdditionalContextInterfaceItems}} {{#newline}} // Additional interface items{{#newline}} {{/if}} {{#each AdditionalContextInterfaceItems}} {{this}}{{#newline}} {{/each}} {{#if addSaveChanges}} {{#newline}} int SaveChanges();{{#newline}} Task SaveChangesAsync();{{#newline}} Task SaveChangesAsync(CancellationToken cancellationToken);{{#newline}} DbChangeTracker ChangeTracker { get; }{{#newline}} DbContextConfiguration Configuration { get; }{{#newline}} Database Database { get; }{{#newline}} DbEntityEntry Entry(TEntity entity) where TEntity : class;{{#newline}} DbEntityEntry Entry(object entity);{{#newline}} IEnumerable GetValidationErrors();{{#newline}} DbSet Set(Type entityType);{{#newline}} DbSet Set() where TEntity : class;{{#newline}} string ToString();{{#newline}} {{/if}} {{#if hasStoredProcs}} {{#newline}} // Stored Procedures{{#newline}} {{#each storedProcs}} {{ReturnType}} {{FunctionName}}({{WriteStoredProcFunctionParamsFalseTrue}});{{#newline}} {{#if SingleReturnModel}} {{ReturnType}} {{FunctionName}}({{WriteStoredProcFunctionParamsTrueTrue}});{{#newline}} {{/if}} {{#if AsyncFunctionCannotBeCreated}} // {{FunctionName}}Async() cannot be created due to having out parameters, or is relying on the procedure result ({{ReturnType}}){{#newline}} {{#else}} Task<{{ReturnType}}> {{FunctionName}}Async({{WriteStoredProcFunctionParamsFalseTrueToken}});{{#newline}} {{/if}} {{#newline}} {{/each}} {{/if}} {{#if hasTableValuedFunctions}} {{#newline}} // Table Valued Functions{{#newline}} {{#each tableValuedFunctions}} {{#newline}} [DbFunction(""{{DbContextName}}"", ""{{Name}}"")]{{#newline}} [CodeFirstStoreFunctions.DbFunctionDetails(DatabaseSchema = ""{{Schema}}""{{#if SingleReturnModel}}, ResultColumnName = ""{{SingleReturnColumnName}}""{{/if}})]{{#newline}} IQueryable<{{ReturnClassName}}> {{ExecName}}({{WriteStoredProcFunctionParamsFalseTrue}});{{#newline}} {{/each}} {{/if}} {{#if hasScalarValuedFunctions}} {{#newline}} // Scalar Valued Functions{{#newline}} {{#each scalarValuedFunctions}} {{ReturnType}} {{ExecName}}({{WriteStoredProcFunctionParamsFalseTrue}}); // {{Schema}}.{{Name}}{{#newline}} {{/each}} {{/if}} }"; } public override List DatabaseContextUsings(ContextModel data) { var usings = new List { "System", "System.Data", "System.Data.Common", "System.Data.Entity", "System.Data.Entity.Core.Objects", "System.Data.Entity.Infrastructure", "System.Data.Entity.Infrastructure.Interception", "System.Data.Entity.Infrastructure.Annotations", "System.ComponentModel.DataAnnotations.Schema", "System.Data.SqlClient", "System.Data.SqlTypes", "System.Threading.Tasks", "System.Threading" }; if (Settings.IncludeCodeGeneratedAttribute) usings.Add("System.CodeDom.Compiler"); if (data.tables.Any() || data.hasStoredProcs) { usings.Add("System.Data.Entity"); usings.Add("System.Data.Entity.Spatial"); usings.Add("System.Linq"); } if (data.hasStoredProcs) { usings.Add("System.Collections.Generic"); } if (!Settings.UseInheritedBaseInterfaceFunctions) { usings.Add("System.Data.Entity"); usings.Add("System.Data.Entity.Infrastructure"); usings.Add("System.Collections.Generic"); usings.Add("System.Data.Entity.Validation"); } if (Settings.DatabaseType == DatabaseType.SqlCe) { usings.Add("System.Data.SqlClient"); //usings.Add("System.DBNull"); usings.Add("System.Data.SqlTypes"); } if (Settings.DatabaseType == DatabaseType.PostgreSQL) { usings.Add("Npgsql"); usings.Add("NpgsqlTypes"); } return usings; } public override string DatabaseContext() { return @" {{DbContextClassModifiers}} class {{DbContextName}} : {{DbContextBaseClass}}{{contextInterface}}{{#newline}} {{{#newline}} {{#each tables}} {{DbSetModifier}} DbSet<{{DbSetName}}> {{PluralTableName}} { get; set; }{{Comment}}{{#newline}} {{/each}} {{#newline}} static {{DbContextName}}(){{#newline}} {{{#newline}} System.Data.Entity.Database.SetInitializer{{setInitializer}}{{#newline}} }{{#newline}}{{#newline}} {{#if AddParameterlessConstructorToDbContext}} /// {{#newline}} public {{DbContextName}}(){{#newline}} {{#if HasDefaultConstructorArgument}} : base({{DefaultConstructorArgument}}){{#newline}} {{/if}} {{{#newline}} {{#if DbContextClassIsPartial}} InitializePartial();{{#newline}} {{/if}} }{{#newline}}{{#newline}} {{/if}} /// {{#newline}} public {{DbContextName}}(string connectionString){{#newline}} : base(connectionString){{#newline}} {{{#newline}} {{#if DbContextClassIsPartial}} InitializePartial();{{#newline}} {{/if}} }{{#newline}}{{#newline}} /// {{#newline}} public {{DbContextName}}(string connectionString, DbCompiledModel model){{#newline}} : base(connectionString, model){{#newline}} {{{#newline}} {{#if DbContextClassIsPartial}} InitializePartial();{{#newline}} {{/if}} }{{#newline}}{{#newline}} /// {{#newline}} public {{DbContextName}}(DbConnection existingConnection, bool contextOwnsConnection){{#newline}} : base(existingConnection, contextOwnsConnection){{#newline}} {{{#newline}} {{#if DbContextClassIsPartial}} InitializePartial();{{#newline}} {{/if}} }{{#newline}}{{#newline}} /// {{#newline}} public {{DbContextName}}(DbConnection existingConnection, DbCompiledModel model, bool contextOwnsConnection){{#newline}} : base(existingConnection, model, contextOwnsConnection){{#newline}} {{{#newline}} {{#if DbContextClassIsPartial}} InitializePartial();{{#newline}} {{/if}} }{{#newline}}{{#newline}} {{#if IncludeObjectContextConstructor}} /// {{#newline}} public {{DbContextName}}(ObjectContext objectContext, bool dbContextOwnsObjectContext){{#newline}} : base(objectContext, dbContextOwnsObjectContext){{#newline}} {{{#newline}} {{#if DbContextClassIsPartial}} InitializePartial();{{#newline}} {{/if}} }{{#newline}}{{#newline}} {{/if}} protected override void Dispose(bool disposing){{#newline}} {{{#newline}} {{#if DbContextClassIsPartial}} DisposePartial(disposing);{{#newline}} {{/if}} base.Dispose(disposing);{{#newline}} }{{#newline}} {{#newline}} public bool IsSqlParameterNull({{SqlParameter}} param){{#newline}} {{{#newline}} var sqlValue = param.{{SqlParameterValue}};{{#newline}} var nullableValue = sqlValue as INullable;{{#newline}} if (nullableValue != null){{#newline}} return nullableValue.IsNull;{{#newline}} return (sqlValue == null || sqlValue == DBNull.Value);{{#newline}} }{{#newline}}{{#newline}} protected override void OnModelCreating(DbModelBuilder modelBuilder){{#newline}} {{{#newline}} base.OnModelCreating(modelBuilder);{{#newline}} {{#if hasTableValuedFunctions}} {{#newline}} modelBuilder.Conventions.Add(new CodeFirstStoreFunctions.FunctionsConvention<{{DbContextName}}>(""{{DefaultSchema}}""));{{#newline}} {{#if hasTableValuedFunctionComplexTypes}} {{#newline}} {{#each tableValuedFunctionComplexTypes}} modelBuilder.ComplexType<{{this}}>();{{#newline}} {{/each}} {{/if}} {{/if}} {{#if hasTables}} {{#newline}} {{#each tables}} modelBuilder.Configurations.Add(new {{DbSetConfigName}}());{{#newline}} {{/each}} {{/if}} {{#if hasIndexes}} {{#newline}} // Indexes{{#newline}} {{#each indexes}} {{this}}{{#newline}} {{/each}} {{/if}} {{#if DbContextClassIsPartial}} {{#newline}} OnModelCreatingPartial(modelBuilder);{{#newline}} {{/if}} }{{#newline}} {{#newline}} public static DbModelBuilder CreateModel(DbModelBuilder modelBuilder, string schema){{#newline}} {{{#newline}} {{#each tables}} modelBuilder.Configurations.Add(new {{DbSetConfigName}}(schema));{{#newline}} {{/each}} {{#newline}} {{#if DbContextClassIsPartial}} OnCreateModelPartial(modelBuilder, schema);{{#newline}} {{#newline}} {{/if}} return modelBuilder;{{#newline}} }{{#newline}} {{#if DbContextClassIsPartial}} {{#newline}} partial void InitializePartial();{{#newline}} partial void DisposePartial(bool disposing);{{#newline}} partial void OnModelCreatingPartial(DbModelBuilder modelBuilder);{{#newline}} static partial void OnCreateModelPartial(DbModelBuilder modelBuilder, string schema);{{#newline}} {{/if}} {{#if hasStoredProcs}} {{#newline}} // Stored Procedures{{#newline}} {{#each storedProcs}} {{#if HasReturnModels}} public {{ReturnType}} {{FunctionName}}({{WriteStoredProcFunctionParamsFalseFalse}}){{#newline}} {{#if SingleReturnModel}} {{{#newline}} int procResult;{{#newline}} return {{FunctionName}}({{WriteStoredProcFunctionOverloadCall}});{{#newline}} }{{#newline}} {{#newline}} public {{ReturnType}} {{FunctionName}}({{WriteStoredProcFunctionParamsTrueFalse}}){{#newline}} {{/if}} {{{#newline}} {{WriteStoredProcFunctionDeclareSqlParameterTrue}} {{#if SingleReturnModel}} var procResultData = Database.SqlQuery<{{WriteStoredProcReturnModelName}}>(""{{Exec}}""{{WriteStoredProcFunctionSqlParameterAnonymousArrayTrue}}).ToList();{{#newline}} {{WriteStoredProcFunctionSetSqlParametersFalse}} procResult = (int) procResultParam.Value;{{#newline}} {{#else}} var procResultData = new {{WriteStoredProcReturnModelName}}();{{#newline}} var cmd = Database.Connection.CreateCommand();{{#newline}} cmd.CommandTimeout = Database.CommandTimeout ?? cmd.CommandTimeout;{{#newline}} cmd.CommandType = CommandType.StoredProcedure;{{#newline}} cmd.CommandText = ""{{Exec}}"";{{#newline}} {{#each Parameters}} cmd.Parameters.Add({{this}});{{#newline}} {{/each}} {{#newline}} try{{#newline}} {{{#newline}} DbInterception.Dispatch.Connection.Open(Database.Connection, new DbInterceptionContext());{{#newline}} var reader = cmd.ExecuteReader();{{#newline}} var objectContext = ((IObjectContextAdapter) this).ObjectContext;{{#newline}} {{#each ReturnModelResultSetReaderCommand}} {{#newline}} procResultData.ResultSet{{Index}} = objectContext.Translate<{{WriteStoredProcReturnModelName}}.ResultSetModel{{Index}}>(reader).ToList();{{#newline}} reader.{{ReaderCommand}}();{{#newline}} {{/each}} }{{#newline}} finally{{#newline}} {{{#newline}} DbInterception.Dispatch.Connection.Close(Database.Connection, new DbInterceptionContext());{{#newline}} }{{#newline}} {{#newline}} {{WriteStoredProcFunctionSetSqlParametersFalse}} {{/if}} return procResultData;{{#newline}} }{{#newline}} {{#else}}{{#! if HasReturnModels }} public int {{FunctionName}}({{WriteStoredProcFunctionParamsTrueFalse}}){{#newline}} {{{#newline}} {{WriteStoredProcFunctionDeclareSqlParameterTrue}}{{#newline}} Database.ExecuteSqlCommand(TransactionalBehavior.DoNotEnsureTransaction, ""{{ExecWithNoReturnModel}}""{{WriteStoredProcFunctionSqlParameterAnonymousArrayTrue}});{{#newline}} {{#newline}} {{WriteStoredProcFunctionSetSqlParametersFalse}} return (int)procResultParam.Value;{{#newline}} }{{#newline}} {{/if}}{{#! if HasReturnModels }} {{#newline}} {{#if AsyncFunctionCannotBeCreated}} // {{FunctionName}}Async() cannot be created due to having out parameters, or is relying on the procedure result ({{ReturnType}}){{#newline}} {{#else}}{{#! if AsyncFunctionCannotBeCreated }} public async Task<{{ReturnType}}> {{FunctionName}}Async({{WriteStoredProcFunctionParamsFalseFalseToken}}){{#newline}} {{{#newline}} {{#if HasNoReturnModels}} {{WriteStoredProcFunctionDeclareSqlParameterTrue}} {{#newline}} await Database.ExecuteSqlCommandAsync(TransactionalBehavior.DoNotEnsureTransaction, ""{{AsyncExec}}""{{WriteStoredProcFunctionSqlParameterAnonymousArrayTrueToken}});{{#newline}} {{#newline}} return (int)procResultParam.Value;{{#newline}} {{#else}} {{WriteStoredProcFunctionDeclareSqlParameterFalse}} {{#if SingleReturnModel}} var procResultData = await Database.SqlQuery<{{WriteStoredProcReturnModelName}}>(""{{AsyncExec}}""{{WriteStoredProcFunctionSqlParameterAnonymousArrayFalse}}).ToListAsync(cancellationToken);{{#newline}} {{#else}} var procResultData = new {{WriteStoredProcReturnModelName}}();{{#newline}} var cmd = Database.Connection.CreateCommand();{{#newline}} cmd.CommandTimeout = Database.CommandTimeout ?? cmd.CommandTimeout;{{#newline}} cmd.CommandType = CommandType.StoredProcedure;{{#newline}} cmd.CommandText = ""{{Exec}}"";{{#newline}} {{#each Parameters}} cmd.Parameters.Add({{this}});{{#newline}} {{/each}} {{#newline}} try{{#newline}} {{{#newline}} await DbInterception.Dispatch.Connection.OpenAsync(Database.Connection, new DbInterceptionContext(), new CancellationToken()).ConfigureAwait(false);{{#newline}} var reader = await cmd.ExecuteReaderAsync().ConfigureAwait(false);{{#newline}} var objectContext = ((IObjectContextAdapter) this).ObjectContext;{{#newline}} {{#each ReturnModelResultSetReaderCommand}} {{#newline}} procResultData.ResultSet{{Index}} = objectContext.Translate<{{WriteStoredProcReturnModelName}}.ResultSetModel{{Index}}>(reader).ToList();{{#newline}} {{#if NotLastRecord}} await reader.NextResultAsync().ConfigureAwait(false);{{#newline}} {{/if}} {{/each}} }{{#newline}} finally{{#newline}} {{{#newline}} DbInterception.Dispatch.Connection.Close(Database.Connection, new DbInterceptionContext());{{#newline}} }{{#newline}} {{#newline}} {{WriteStoredProcFunctionSetSqlParametersFalse}} {{/if}}{{#! if AsyncFunctionCannotBeCreated }} return procResultData;{{#newline}} {{/if}} }{{#newline}} {{#newline}} {{/if}} {{/each}} {{/if}} {{#if hasTableValuedFunctions}} {{#newline}} // Table Valued Functions{{#newline}} {{#each tableValuedFunctions}} {{#newline}} [DbFunction(""{{DbContextName}}"", ""{{Name}}"")]{{#newline}} [CodeFirstStoreFunctions.DbFunctionDetails(DatabaseSchema = ""{{Schema}}""{{#if SingleReturnModel}}, ResultColumnName = ""{{SingleReturnColumnName}}""{{/if}})]{{#newline}} public IQueryable<{{ReturnClassName}}> {{ExecName}}({{WriteStoredProcFunctionParamsFalseFalse}}){{#newline}} {{{#newline}} {{WriteTableValuedFunctionDeclareSqlParameter}} {{#newline}} return ((IObjectContextAdapter)this).ObjectContext.CreateQuery<{{ReturnClassName}}>(""[{{DbContextName}}].[{{Name}}]({{WriteStoredProcFunctionSqlAtParams}})"", {{WriteTableValuedFunctionSqlParameterAnonymousArray}});{{#newline}} }{{#newline}} {{/each}} {{/if}} {{#if hasScalarValuedFunctions}} {{#newline}} // Scalar Valued Functions{{#newline}} {{#each scalarValuedFunctions}} {{#newline}} [DbFunction(""CodeFirstDatabaseSchema"", ""{{Name}}"")]{{#newline}} public {{ReturnType}} {{ExecName}}({{WriteStoredProcFunctionParamsFalseFalse}}){{#newline}} {{{#newline}} throw new Exception(""Don't call this directly. Use LINQ to call the scalar valued function as part of your query"");{{#newline}} }{{#newline}} {{/each}} {{/if}} }"; } public override List DatabaseContextFactoryUsings(FactoryModel data) { var usings = new List { "System", "System.Data.Entity.Infrastructure" }; if (Settings.IncludeCodeGeneratedAttribute) usings.Add("System.CodeDom.Compiler"); return usings; } public override string DatabaseContextFactory() { return @" {{classModifier}} class {{contextName}}Factory : IDbContextFactory<{{contextName}}>{{#newline}} {{{#newline}} public {{contextName}} Create(){{#newline}} {{{#newline}} return new {{contextName}}();{{#newline}} }{{#newline}} }"; } public override List FakeDatabaseContextUsings(FakeContextModel data, IDbContextFilter filter) { var usings = new List { "System", "System.Data", "System.Data.Common", "System.Data.Entity", "System.Data.Entity.Core.Objects", "System.Data.Entity.Infrastructure", "System.Data.Entity.Infrastructure.Interception", "System.Data.Entity.Infrastructure.Annotations", "System.Data.SqlClient", "System.Data.Entity.Spatial", "System.Data.SqlTypes", "System.Threading.Tasks", "System.Threading" }; if (Settings.IncludeCodeGeneratedAttribute) usings.Add("System.CodeDom.Compiler"); if (data.tables.Any() || data.hasStoredProcs) { usings.Add("System.Data.Entity"); usings.Add("System.Linq"); } if (data.hasStoredProcs) usings.Add("System.Collections.Generic"); if (!Settings.UseInheritedBaseInterfaceFunctions) { usings.Add("System.Data.Entity"); usings.Add("System.Data.Entity.Infrastructure"); usings.Add("System.Collections.Generic"); usings.Add("System.Data.Entity.Validation"); } if (Settings.DatabaseType == DatabaseType.SqlCe) { usings.Add("System.Data.SqlClient"); //usings.Add("System.DBNull"); usings.Add("System.Data.SqlTypes"); } if (Settings.DatabaseType == DatabaseType.PostgreSQL) { usings.Add("Npgsql"); usings.Add("NpgsqlTypes"); } return usings; } public override string FakeDatabaseContext() { return @" {{DbContextClassModifiers}} class Fake{{DbContextName}}{{contextInterface}}{{#newline}} {{{#newline}} {{#each tables}} {{DbSetModifier}} DbSet<{{DbSetName}}> {{PluralTableName}} { get; set; }{{Comment}}{{#newline}} {{/each}} {{#newline}} public Fake{{DbContextName}}(){{#newline}} {{{#newline}} _changeTracker = null;{{#newline}} _configuration = null;{{#newline}} _database = null;{{#newline}} {{#newline}} {{#each tables}} {{PluralTableName}} = new FakeDbSet<{{DbSetName}}>({{DbSetPrimaryKeys}});{{#newline}} {{/each}} {{#newline}} {{#if DbContextClassIsPartial}} InitializePartial();{{#newline}} {{/if}} }{{#newline}} {{#newline}} public int SaveChangesCount { get; private set; }{{#newline}} public int SaveChanges(){{#newline}} {{{#newline}} ++SaveChangesCount;{{#newline}} return 1;{{#newline}} }{{#newline}} {{#newline}} public Task SaveChangesAsync(){{#newline}} {{{#newline}} ++SaveChangesCount;{{#newline}} return Task.Factory.StartNew(() => 1);{{#newline}} }{{#newline}}{{#newline}} public Task SaveChangesAsync(CancellationToken cancellationToken){{#newline}} {{{#newline}} ++SaveChangesCount;{{#newline}} return Task.Factory.StartNew(() => 1, cancellationToken);{{#newline}} }{{#newline}} {{#newline}} {{#if DbContextClassIsPartial}} partial void InitializePartial();{{#newline}} {{#newline}} {{/if}} protected virtual void Dispose(bool disposing){{#newline}} {{{#newline}} }{{#newline}} {{#newline}} public void Dispose(){{#newline}} {{{#newline}} Dispose(true);{{#newline}} }{{#newline}} {{#newline}} private DbChangeTracker _changeTracker;{{#newline}} {{#newline}} public DbChangeTracker ChangeTracker { get { return _changeTracker; } }{{#newline}} {{#newline}} private DbContextConfiguration _configuration;{{#newline}} {{#newline}} public DbContextConfiguration Configuration { get { return _configuration; } }{{#newline}} {{#newline}} private Database _database;{{#newline}} {{#newline}} public Database Database { get { return _database; } }{{#newline}} {{#newline}} public DbEntityEntry Entry(TEntity entity) where TEntity : class{{#newline}} {{{#newline}} throw new NotImplementedException();{{#newline}} }{{#newline}} {{#newline}} public DbEntityEntry Entry(object entity){{#newline}} {{{#newline}} throw new NotImplementedException();{{#newline}} }{{#newline}} {{#newline}} public IEnumerable GetValidationErrors(){{#newline}} {{{#newline}} throw new NotImplementedException();{{#newline}} }{{#newline}} {{#newline}} public DbSet Set(Type entityType){{#newline}} {{{#newline}} throw new NotImplementedException();{{#newline}} }{{#newline}} {{#newline}} public DbSet Set() where TEntity : class{{#newline}} {{{#newline}} throw new NotImplementedException();{{#newline}} }{{#newline}} {{#newline}} public override string ToString(){{#newline}} {{{#newline}} throw new NotImplementedException();{{#newline}} }{{#newline}} {{#if hasStoredProcs}} {{#newline}} // Stored Procedures{{#newline}} {{#each storedProcs}} {{#if HasReturnModels}} {{#newline}} public {{ReturnType}} {{FunctionName}}({{WriteStoredProcFunctionParamsFalseFalse}}){{#newline}} {{{#newline}} int procResult;{{#newline}} return {{FunctionName}}({{WriteStoredProcFunctionOverloadCall}});{{#newline}} }{{#newline}}{{#newline}} public {{ReturnType}} {{FunctionName}}({{WriteStoredProcFunctionParamsTrueFalse}}){{#newline}} {{{#newline}} {{WriteStoredProcFunctionSetSqlParametersTrue}} procResult = 0;{{#newline}} return new {{ReturnType}}();{{#newline}} }{{#newline}} {{#newline}} {{#if AsyncFunctionCannotBeCreated}} // {{FunctionName}}Async() cannot be created due to having out parameters, or is relying on the procedure result ({{ReturnType}}){{#newline}} {{#else}} public Task<{{ReturnType}}> {{FunctionName}}Async({{WriteStoredProcFunctionParamsFalseFalseToken}}){{#newline}} {{{#newline}} int procResult;{{#newline}} return Task.FromResult({{FunctionName}}({{WriteStoredProcFunctionOverloadCall}}));{{#newline}} }{{#newline}} {{/if}} {{#else}} {{#newline}} public int {{FunctionName}}({{WriteStoredProcFunctionParamsTrueFalse}}){{#newline}} {{{#newline}} {{WriteStoredProcFunctionSetSqlParametersTrue}} return 0;{{#newline}} }{{#newline}} {{#newline}} {{#if AsyncFunctionCannotBeCreated}} // {{FunctionName}}Async() cannot be created due to having out parameters, or is relying on the procedure result ({{ReturnType}}){{#newline}} {{#else}} public Task {{FunctionName}}Async({{WriteStoredProcFunctionParamsFalseFalseToken}}){{#newline}} {{{#newline}} {{WriteStoredProcFunctionSetSqlParametersTrue}} return Task.FromResult(0);{{#newline}} }{{#newline}} {{/if}} {{/if}} {{/each}} {{/if}} {{#if hasTableValuedFunctions}} {{#newline}} // Table Valued Functions{{#newline}} {{#each tableValuedFunctions}} {{#newline}} [DbFunction(""{{DbContextName}}"", ""{{Name}}"")]{{#newline}} public IQueryable<{{ReturnClassName}}> {{ExecName}}({{WriteStoredProcFunctionParamsFalseFalse}}){{#newline}} {{{#newline}} return new List<{{ReturnClassName}}>().AsQueryable();{{#newline}} }{{#newline}} {{/each}} {{/if}} {{#if hasScalarValuedFunctions}} {{#newline}} // Scalar Valued Functions{{#newline}} {{#each scalarValuedFunctions}} {{#newline}} // {{Schema}}.{{Name}}{{#newline}} public {{ReturnType}} {{ExecName}}({{WriteStoredProcFunctionParamsFalseFalse}}){{#newline}} {{{#newline}} return default({{ReturnType}});{{#newline}} }{{#newline}} {{/each}} {{/if}} }"; } public override List FakeDbSetUsings(FakeDbSetModel data) { var usings = new List { "System", "System.Collections", "System.Linq", "System.Linq.Expressions", "System.Reflection", "System.Data.Entity", "System.Collections.ObjectModel", "System.Collections.Generic", "System.Data.Entity.Infrastructure", "System.Threading", "System.Threading.Tasks" }; if (Settings.IncludeCodeGeneratedAttribute) usings.Add("System.CodeDom.Compiler"); return usings; } public override string FakeDbSet() { return @" // ************************************************************************{{#newline}} // Fake DbSet{{#newline}} // Implementing Find:{{#newline}} // The Find method is difficult to implement in a generic fashion. If{{#newline}} // you need to test code that makes use of the Find method it is{{#newline}} // easiest to create a test DbSet for each of the entity types that{{#newline}} // need to support find. You can then write logic to find that{{#newline}} // particular type of entity, as shown below:{{#newline}} // public class FakeBlogDbSet : FakeDbSet{{#newline}} // {{{#newline}} // public override Blog Find(params object[] keyValues){{#newline}} // {{{#newline}} // var id = (int) keyValues.Single();{{#newline}} // return this.SingleOrDefault(b => b.BlogId == id);{{#newline}} // }{{#newline}} // }{{#newline}} // Read more about it here: https://msdn.microsoft.com/en-us/data/dn314431.aspx{{#newline}} {{DbContextClassModifiers}} class FakeDbSet : DbSet, IQueryable, IEnumerable, IDbAsyncEnumerable where TEntity : class {{#newline}} {{{#newline}} private readonly PropertyInfo[] _primaryKeys;{{#newline}} private readonly ObservableCollection _data;{{#newline}} private readonly IQueryable _query;{{#newline}}{{#newline}} public FakeDbSet(){{#newline}} {{{#newline}} _data = new ObservableCollection();{{#newline}} _query = _data.AsQueryable();{{#newline}} {{#if DbContextClassIsPartial}} InitializePartial();{{#newline}} {{/if}} }{{#newline}}{{#newline}} public FakeDbSet(params string[] primaryKeys){{#newline}} {{{#newline}} _primaryKeys = typeof(TEntity).GetProperties().Where(x => primaryKeys.Contains(x.Name)).ToArray();{{#newline}} _data = new ObservableCollection();{{#newline}} _query = _data.AsQueryable();{{#newline}} {{#if DbContextClassIsPartial}} InitializePartial();{{#newline}} {{/if}} }{{#newline}}{{#newline}} public override TEntity Find(params object[] keyValues){{#newline}} {{{#newline}} if (_primaryKeys == null){{#newline}} throw new ArgumentException(""No primary keys defined"");{{#newline}} if (keyValues.Length != _primaryKeys.Length){{#newline}} throw new ArgumentException(""Incorrect number of keys passed to Find method"");{{#newline}}{{#newline}} var keyQuery = this.AsQueryable();{{#newline}} keyQuery = keyValues{{#newline}} .Select((t, i) => i){{#newline}} .Aggregate(keyQuery,{{#newline}} (current, x) =>{{#newline}} current.Where(entity => _primaryKeys[x].GetValue(entity, null).Equals(keyValues[x])));{{#newline}}{{#newline}} return keyQuery.SingleOrDefault();{{#newline}} }{{#newline}}{{#newline}} public override Task FindAsync(CancellationToken cancellationToken, params object[] keyValues){{#newline}} {{{#newline}} return Task.Factory.StartNew(() => Find(keyValues), cancellationToken);{{#newline}} }{{#newline}}{{#newline}} public override Task FindAsync(params object[] keyValues){{#newline}} {{{#newline}} return Task.Factory.StartNew(() => Find(keyValues));{{#newline}} }{{#newline}}{{#newline}} public override IEnumerable AddRange(IEnumerable entities){{#newline}} {{{#newline}} if (entities == null) throw new ArgumentNullException(""entities"");{{#newline}} var items = entities.ToList();{{#newline}} foreach (var entity in items){{#newline}} {{{#newline}} _data.Add(entity);{{#newline}} }{{#newline}} return items;{{#newline}} }{{#newline}}{{#newline}} public override TEntity Add(TEntity item){{#newline}} {{{#newline}} if (item == null) throw new ArgumentNullException(""item"");{{#newline}} _data.Add(item);{{#newline}} return item;{{#newline}} }{{#newline}}{{#newline}} public override IEnumerable RemoveRange(IEnumerable entities){{#newline}} {{{#newline}} if (entities == null) throw new ArgumentNullException(""entities"");{{#newline}} var items = entities.ToList();{{#newline}} foreach (var entity in items){{#newline}} {{{#newline}} _data.Remove(entity);{{#newline}} }{{#newline}} return items;{{#newline}} }{{#newline}}{{#newline}} public override TEntity Remove(TEntity item){{#newline}} {{{#newline}} if (item == null) throw new ArgumentNullException(""item"");{{#newline}} _data.Remove(item);{{#newline}} return item;{{#newline}} }{{#newline}}{{#newline}} public override TEntity Attach(TEntity item){{#newline}} {{{#newline}} if (item == null) throw new ArgumentNullException(""item"");{{#newline}} _data.Add(item);{{#newline}} return item;{{#newline}} }{{#newline}}{{#newline}} public override TEntity Create(){{#newline}} {{{#newline}} return Activator.CreateInstance();{{#newline}} }{{#newline}}{{#newline}} public override TDerivedEntity Create(){{#newline}} {{{#newline}} return Activator.CreateInstance();{{#newline}} }{{#newline}}{{#newline}} public override ObservableCollection Local{{#newline}} {{{#newline}} get { return _data; }{{#newline}} }{{#newline}}{{#newline}} Type IQueryable.ElementType{{#newline}} {{{#newline}} get { return _query.ElementType; }{{#newline}} }{{#newline}}{{#newline}} Expression IQueryable.Expression{{#newline}} {{{#newline}} get { return _query.Expression; }{{#newline}} }{{#newline}}{{#newline}} IQueryProvider IQueryable.Provider{{#newline}} {{{#newline}} get { return new FakeDbAsyncQueryProvider(_query.Provider); }{{#newline}} }{{#newline}}{{#newline}} IEnumerator IEnumerable.GetEnumerator(){{#newline}} {{{#newline}} return _data.GetEnumerator();{{#newline}} }{{#newline}}{{#newline}} IEnumerator IEnumerable.GetEnumerator(){{#newline}} {{{#newline}} return _data.GetEnumerator();{{#newline}} }{{#newline}}{{#newline}} IDbAsyncEnumerator IDbAsyncEnumerable.GetAsyncEnumerator(){{#newline}} {{{#newline}} return new FakeDbAsyncEnumerator(_data.GetEnumerator());{{#newline}} }{{#newline}} {{#if DbContextClassIsPartial}} {{#newline}} partial void InitializePartial();{{#newline}} {{/if}} } {{#newline}}{{#newline}} {{DbContextClassModifiers}} class FakeDbAsyncQueryProvider : IDbAsyncQueryProvider{{#newline}} {{{#newline}} private readonly IQueryProvider _inner;{{#newline}}{{#newline}} public FakeDbAsyncQueryProvider(IQueryProvider inner){{#newline}} {{{#newline}} _inner = inner;{{#newline}} }{{#newline}}{{#newline}} public IQueryable CreateQuery(Expression expression){{#newline}} {{{#newline}} var m = expression as MethodCallExpression;{{#newline}} if (m != null){{#newline}} {{{#newline}} var resultType = m.Method.ReturnType; // it should be IQueryable{{#newline}} var tElement = resultType.GetGenericArguments()[0];{{#newline}} var queryType = typeof(FakeDbAsyncEnumerable<>).MakeGenericType(tElement);{{#newline}} return (IQueryable) Activator.CreateInstance(queryType, expression);{{#newline}} }{{#newline}} return new FakeDbAsyncEnumerable(expression);{{#newline}} }{{#newline}}{{#newline}} public IQueryable CreateQuery(Expression expression){{#newline}} {{{#newline}} var queryType = typeof(FakeDbAsyncEnumerable<>).MakeGenericType(typeof(TElement));{{#newline}} return (IQueryable) Activator.CreateInstance(queryType, expression);{{#newline}} }{{#newline}}{{#newline}} public object Execute(Expression expression){{#newline}} {{{#newline}} return _inner.Execute(expression);{{#newline}} }{{#newline}}{{#newline}} public TResult Execute(Expression expression){{#newline}} {{{#newline}} return _inner.Execute(expression);{{#newline}} }{{#newline}}{{#newline}} public Task