public void TestNaturalKey() { //arrange var schema = new DatabaseSchema(null, null); var diagrams = schema.AddTable("Diagrams") .AddColumn("diagram_id", DbType.Int32).AddPrimaryKey() .AddColumn <string>("name").AddLength(10).AddUniqueKey() .AddColumn <int>("principal_id") .Table; diagrams.UniqueKeys.Single().AddColumn(diagrams.FindColumn("principal_id")); DatabaseSchemaFixer.UpdateReferences(schema); var settings = new CodeWriterSettings { Namespace = "MyTest", CodeTarget = CodeTarget.PocoNHibernateHbm }; PrepareSchemaNames.Prepare(schema, settings.Namer); //act var target = new MappingWriter(diagrams, settings); var txt = target.Write(); //assert var errors = Validate(txt); Assert.IsFalse(errors); }
public void TestSimpleMapping() { //arrange var schema = new DatabaseSchema(null, null); schema.AddTable("Categories") .AddColumn("CategoryId", DbType.Int32).AddPrimaryKey() .AddColumn("CategoryName", DbType.String); var products = schema.AddTable("Products") .AddColumn("ProductId", DbType.Int32).AddPrimaryKey() .AddColumn("ProductName", DbType.String) .AddColumn("CategoryId", DbType.Int32).AddForeignKey("fk", "Categories") .Table; DatabaseSchemaFixer.UpdateReferences(schema); var settings = new CodeWriterSettings { Namespace = "MyTest", CodeTarget = CodeTarget.PocoNHibernateHbm }; PrepareSchemaNames.Prepare(schema, settings.Namer); //act var target = new MappingWriter(products, settings); var txt = target.Write(); //assert var errors = Validate(txt); Assert.IsFalse(errors); }
public void TestCompositeKey() { //arrange var schema = new DatabaseSchema(null, null); var orderDetail = schema.AddTable("OrderDetails") .AddColumn("OrderID", DbType.Int32).AddPrimaryKey() .AddColumn("ProductID", DbType.Int32) .AddColumn <int>("UnitPrice") .Table; orderDetail.PrimaryKey.AddColumn(orderDetail.FindColumn("ProductID")); DatabaseSchemaFixer.UpdateReferences(schema); var settings = new CodeWriterSettings { Namespace = "MyTest", CodeTarget = CodeTarget.PocoNHibernateHbm }; PrepareSchemaNames.Prepare(schema, settings.Namer); //act var target = new MappingWriter(orderDetail, settings); var txt = target.Write(); //assert var errors = Validate(txt); Assert.IsFalse(errors); }
public void JoinTableCreated() { //arrange var products = _schema.FindTableByName("CategoryProducts"); var codeWriterSettings = new CodeWriterSettings { CodeTarget = CodeTarget.PocoEfCore }; var target = new CodeFirstMappingWriter(products, codeWriterSettings, new MappingNamer()); //act var result = target.Write(); //assert // public static void Map(EntityTypeBuilder<CategoryProduct> b) // { // //table // b.ToTable("CategoryProducts"); // // Primary key (composite) // b.HasKey(x => new { x.CategoryId, x.ProductId }); // // Properties // b.HasOne(x => x.Category).WithOne(); // b.HasOne(x => x.Product).WithOne(); var hasKey = result.Contains("b.HasKey(x => new { x.CategoryId, x.ProductId });"); //we have to create a many to many table for this var hasCategory = result.Contains("b.HasOne(x => x.Category).WithOne("); var hasProduct = result.Contains("b.HasOne(x => x.Product).WithOne("); Assert.IsTrue(hasKey); Assert.IsTrue(hasCategory); Assert.IsTrue(hasProduct); }
public void ExecuteTest() { DatabaseSchema schema = PrepareModel(); var directory = CreateDirectory("MyTest"); const string @namespace = "MyTest"; var settings = new CodeWriterSettings { Namespace = @namespace, CodeTarget = CodeTarget.Poco }; var target = new CodeWriter(schema, settings); target.Execute(directory); var files = directory.GetFiles("*.cs"); var products = files.FirstOrDefault(f => f.Name == "Product.cs"); Assert.IsNotNull(products, "Should have written Product class to represent [Products] table"); var category = files.FirstOrDefault(f => f.Name == "Category.cs"); Assert.IsNotNull(category, "Should have written Category class to represent [Categories] table"); var cs = File.ReadAllText(category.FullName); var ok = cs.Contains("public virtual IList<Product> ProductCollection { get; private set; }"); Assert.IsTrue(ok, "Should contain the collection of products"); }
public void WriteTest() { //arrange var schema = new DatabaseSchema(null, null); var table = schema.AddTable("Categories") .AddColumn("CategoryId", "INT").AddPrimaryKey().AddIdentity() .AddColumn("CategoryName", "NVARCHAR").Table; //we need datatypes schema.DataTypes.Add(new DataType("INT", "System.Int32")); schema.DataTypes.Add(new DataType("NVARCHAR", "System.String")); DatabaseSchemaFixer.UpdateDataTypes(schema); //make sure .Net names are assigned PrepareSchemaNames.Prepare(schema, new Namer()); //inject the custom code inserter var codeWriterSettings = new CodeWriterSettings { CodeInserter = new CustomCodeInserter() }; var cw = new ClassWriter(table, codeWriterSettings); //act var txt = cw.Write(); //assert Assert.IsTrue(txt.Contains("using System.ComponentModel.DataAnnotations.Schema")); Assert.IsTrue(txt.Contains("[Table(\"Categories\")]")); Assert.IsTrue(txt.Contains("[Column(\"CategoryId\")]")); }
public void TestIndexNotNeededForPrimaryKey() { //arrange var settings = new CodeWriterSettings(); settings.CodeTarget = CodeTarget.PocoEntityCodeFirst; settings.WriteCodeFirstIndexAttribute = true; var classBuilder = new ClassBuilder(); var table = new DatabaseTable { Name = "Test" }; table.AddColumn <int>("Id").AddPrimaryKey().AddIndex("PK_TEST") .AddColumn <string>("Category").AddNullable() .AddColumn <string>("Name").AddNullable().AddIndex("IX_NAME") ; var idColumn = table.PrimaryKeyColumn; var target = new DataAnnotationWriter(true, settings); //act target.Write(classBuilder, idColumn); var result = classBuilder.ToString().Trim(); //ignore lines //assert Assert.IsTrue(result.IndexOf("[Index", StringComparison.OrdinalIgnoreCase) == -1, "Should be just[Key]"); }
public void TestCompositeKey() { //based on Github issue #21 //arrange //this schema model has a primary key which is also in 2 different foreign keys //AND one of the foreign keys is not in the model (exclusions) //this confused the code writer... var dept = Arrange(); var settings = new CodeWriterSettings { CodeTarget = CodeTarget.PocoEntityCodeFirst, Namer = new PluralizingNamer() }; var cw = new ClassWriter(dept, settings); //act var txt = cw.Write(); //assert //what should this return? Console.WriteLine(txt); Assert.IsTrue(txt.IndexOf("public int BusinessUnitId { get; set; }", StringComparison.Ordinal) > 0, "Should have xId scalar key"); Assert.IsTrue(txt.IndexOf("public virtual BusinessUnit BusinessUnit { get; set; }", StringComparison.Ordinal) > 0, "Should have x reference property"); }
public void NHibernateFluentTest() { var schema = PrepareModel(); var directory = TestHelper.CreateDirectory("MyTest"); const string @namespace = "MyTest"; var settings = new CodeWriterSettings { Namespace = @namespace, CodeTarget = CodeTarget.PocoNHibernateFluent }; var target = new CodeWriter(schema, settings); target.Execute(directory); var mapping = directory.GetDirectories("mapping").FirstOrDefault(); if (mapping == null) { Assert.Fail("Could not find Mapping subdirectory"); } var files = mapping.GetFiles("*.cs"); var products = files.FirstOrDefault(f => f.Name == "ProductMapping.cs"); Assert.IsNotNull(products, "Should have written Product class to map [Products] table"); var category = files.FirstOrDefault(f => f.Name == "CategoryMapping.cs"); Assert.IsNotNull(category, "Should have written Category class to map [Categories] table"); var cs = File.ReadAllText(category.FullName); var ok = cs.Contains("public class CategoryMapping : ClassMap<Category>"); Assert.IsTrue(ok, "Should contain the ClassMap<>"); }
public void IsMaxLengthTest() { //arrange var schema = new DatabaseSchema(null, null); var table = schema.AddTable("Products") .AddColumn("ProductId", DbType.Int32).AddPrimaryKey().AddIdentity() .AddColumn("ProductName", DbType.String).AddLength(-1) .Table; //we need datatypes schema.DataTypes.Add(new DataType("INT", "System.Int32")); schema.DataTypes.Add(new DataType("NVARCHAR", "System.String")); //make sure it's all tied up DatabaseSchemaFixer.UpdateReferences(schema); var codeWriterSettings = new CodeWriterSettings { CodeTarget = CodeTarget.PocoEntityCodeFirst }; var target = new CodeFirstMappingWriter(table, codeWriterSettings, new MappingNamer()); //act var result = target.Write(); //assert var hasMaxLength = result.Contains("Property(x => x.ProductName).IsMaxLength()"); Assert.IsTrue(hasMaxLength); }
public void MappingSharedPrimaryKeyTest() { //arrange var schema = new DatabaseSchema(null, null); schema .AddTable("vehicle") .AddColumn <string>("regnum").AddPrimaryKey().AddLength(25) .AddColumn <string>("model").AddLength(32) .AddTable("car") .AddColumn <string>("regnum").AddLength(25).AddPrimaryKey().AddForeignKey("fk", "vehicle") .AddColumn <int>("doors"); //make sure it's all tied up DatabaseSchemaFixer.UpdateReferences(schema); //make sure .Net names are assigned PrepareSchemaNames.Prepare(schema, new Namer()); var table = schema.FindTableByName("car"); var mappingNamer = new MappingNamer(); var codeWriterSettings = new CodeWriterSettings { CodeTarget = CodeTarget.PocoEntityCodeFirst }; var target = new CodeFirstMappingWriter(table, codeWriterSettings, mappingNamer); //act var txt = target.Write(); //assert var hasScalarKey = txt.Contains("HasKey(x => x.Regnum);"); var hasForeignKey = txt.Contains("HasRequired(x => x.Vehicle);"); Assert.IsTrue(hasScalarKey); Assert.IsTrue(hasForeignKey); }
public void ForeignKeyIdTest() { //arrange DatabaseSchema schema = PrepareModel(); var products = schema.FindTableByName("Products"); var codeWriterSettings = new CodeWriterSettings { CodeTarget = CodeTarget.PocoEntityCodeFirst, UseForeignKeyIdProperties = true }; var target = new CodeFirstMappingWriter(products, codeWriterSettings, new MappingNamer()); //act var result = target.Write(); //assert var hasMappingClass = result.Contains("public class ProductMapping : EntityTypeConfiguration<Product>"); var hasForeignKeyIdProperty = result.Contains("Property(x => x.SupplierKeyId).HasColumnName(\"SupplierKey\")"); var hasForeignKey = result.Contains("HasRequired(x => x.SupplierKey).WithMany(c => c.ProductCollection).HasForeignKey(c => c.SupplierKeyId);"); Assert.IsTrue(hasMappingClass); Assert.IsTrue(hasForeignKeyIdProperty); Assert.IsTrue(hasForeignKey); }
public void MappingNameTest() { //arrange var schema = new DatabaseSchema(null, null); var table = schema.AddTable("Products") .AddColumn("ProductId", DbType.Int32).AddPrimaryKey().AddIdentity() .Table; table.NetName = "Product"; //we need datatypes schema.DataTypes.Add(new DataType("INT", "System.Int32")); //make sure it's all tied up DatabaseSchemaFixer.UpdateReferences(schema); var codeWriterSettings = new CodeWriterSettings { CodeTarget = CodeTarget.PocoEntityCodeFirst }; var target = new CodeFirstMappingWriter(table, codeWriterSettings, new MappingNamer()); //act target.Write(); //now the name is assigned var className = target.MappingClassName; //assert Assert.AreEqual("ProductMapping", className); }
public void IsImageTest() { //arrange var schema = new DatabaseSchema(null, null); var table = schema.AddTable("Products") .AddColumn("ProductId", DbType.Int32).AddPrimaryKey().AddIdentity() .AddColumn("Picture", "image") .Table; //we need datatypes schema.DataTypes.Add(new DataType("INT", "System.Int32")); schema.DataTypes.Add(new DataType("image", "System.Byte[]")); //make sure it's all tied up DatabaseSchemaFixer.UpdateReferences(schema); var codeWriterSettings = new CodeWriterSettings { CodeTarget = CodeTarget.PocoEntityCodeFirst }; var target = new CodeFirstMappingWriter(table, codeWriterSettings, new MappingNamer()); //act var result = target.Write(); //assert //EF CF will default to varbinary so we must specify var hasImageType = result.Contains("Property(x => x.Picture).HasColumnType(\"image\")"); Assert.IsTrue(hasImageType); }
public void TestIndexMultiColumnUnique() { //arrange var settings = new CodeWriterSettings(); settings.CodeTarget = CodeTarget.PocoEntityCodeFirst; settings.WriteCodeFirstIndexAttribute = true; var classBuilder = new ClassBuilder(); var table = new DatabaseTable { Name = "Test" }; var nameColumn = table.AddColumn <int>("Id").AddPrimaryKey() .AddColumn <string>("Category").AddNullable().AddIndex("IX_NAME") .AddColumn <string>("Name").AddNullable().AddIndex("IX_NAME") ; table.Indexes.First().IsUnique = true; var target = new DataAnnotationWriter(true, settings); //act target.Write(classBuilder, nameColumn); var result = classBuilder.ToString().Trim(); //ignore lines //assert Assert.AreEqual("[Index(\"IX_NAME\", 2, IsUnique = true)]", result); }
public void ExecuteTest() { DatabaseSchema schema = PrepareModel(); const string @namespace = "MyTest"; var settings = new CodeWriterSettings { Namespace = @namespace, CodeTarget = CodeTarget.PocoEntityCodeFirst }; var target = new CodeWriter(schema, settings); var directory = CreateDirectory("MyTest"); target.Execute(directory); //assert var mapping = directory.GetDirectories("mapping").FirstOrDefault(); Assert.IsNotNull(mapping); var files = mapping.GetFiles("*.cs"); var products = files.FirstOrDefault(f => f.Name == "ProductMapping.cs"); Assert.IsNotNull(products, "Should have written Product Mapping class"); var cs = File.ReadAllText(products.FullName); var ok = cs.Contains("EntityTypeConfiguration<Product>"); Assert.IsTrue(ok, "Should contain an EntityTypeConfiguration class mapper"); }
public void BuildGeneratedCodeTest() { //arrange var dbReader = TestHelper.GetNorthwindReader(); var schema = dbReader.ReadAll(); var directory = TestHelper.CreateDirectory("NorthwindCodeGen"); const string @namespace = "Northwind.Domain"; var settings = new CodeWriterSettings { Namespace = @namespace, CodeTarget = CodeTarget.PocoNHibernateHbm, Namer = new PluralizingNamer(), WriteProjectFile = true }; var codeWriter = new CodeWriter(schema, settings); //act codeWriter.Execute(directory); //assert var csproj = Path.Combine(directory.FullName, "Northwind.Domain.csproj"); Assert.IsTrue(File.Exists(csproj)); //can we build it? var projectIsBuilt = BuildProject(csproj); Assert.IsTrue(projectIsBuilt); //yes we can }
public void NorthwindProcedureTest() { var dbReader = TestHelper.GetNorthwindReader(); //remove the spCreateDiagram system sprocs dbReader.Exclusions.StoredProcedureFilter = new PrefixFilter("sp"); var schema = dbReader.ReadAll(); var procedure = schema.StoredProcedures .Find(x => string.Equals(x.Name, "Employee Sales by Country", StringComparison.OrdinalIgnoreCase)); if (procedure == null) { Assert.Inconclusive("No Employee Sales By Country found in Northwind"); } //getting the procedure resultsets is a special call var runner = new ResultSetReader(schema); runner.Execute(); var directory = TestHelper.CreateDirectory("NorthwindSproc"); const string @namespace = "Northwind.Domain"; var settings = new CodeWriterSettings { Namespace = @namespace, CodeTarget = CodeTarget.Poco, WriteStoredProcedures = true }; var codeWriter = new CodeWriter(schema, settings); codeWriter.Execute(directory); var procedures = directory.GetDirectories("Procedures").FirstOrDefault(); if (procedures == null) { Assert.Fail("Could not find Procedures subdirectory"); } var files = procedures.GetFiles("*.cs"); var employeeSales = files.FirstOrDefault(f => f.Name == "EmployeeSalesByCountry.cs"); Assert.IsNotNull(employeeSales, "Should have written EmployeeSalesByCountry class for Employee Sales By Country procedure"); var cs = File.ReadAllText(employeeSales.FullName); Assert.IsTrue(cs.Contains("public virtual IEnumerable<EmployeeSalesByCountryResult> Execute(DateTime? beginningDate, DateTime? endingDate)"), "Generated input signature"); var employeeSalesResult = files.FirstOrDefault(f => f.Name == "EmployeeSalesByCountryResult.cs"); Assert.IsNotNull(employeeSalesResult, "Should have written EmployeeSalesByCountryResult class for Employee Sales By Country procedure"); cs = File.ReadAllText(employeeSalesResult.FullName); Assert.IsTrue(cs.Contains("public virtual string Country { get; set; }"), "Generated property for resultSet column"); }
public MappingWriter(DatabaseTable table, CodeWriterSettings codeWriterSettings) { _codeWriterSettings = codeWriterSettings; var ns = codeWriterSettings.Namespace; _table = table; _doc = XDocument.Parse(@"<?xml version=""1.0"" encoding=""utf-8"" ?> <hibernate-mapping xmlns=""urn:nhibernate-mapping-2.2"" namespace=""" + ns + @""" assembly=""" + ns + @"""> </hibernate-mapping>"); var hibmap = _doc.Descendants(_xmlns + "hibernate-mapping").First(); //add the class element _classElement = new XElement(_xmlns + "class", new XAttribute("name", _table.NetName), new XAttribute("table", SqlSafe(_table.Name)), _table.SchemaOwner != null ? new XAttribute("schema", SqlSafe(_table.SchemaOwner)) : null, //consider this new XAttribute("dynamic-update", "true"), new XAttribute("optimistic-lock", "dirty")); if (_table is DatabaseView) { _classElement.Add(new XAttribute("mutable", "false")); } hibmap.Add(_classElement); }
public void WriteViewTest() { //arrange var view = new DatabaseView(); view.Name = "AlphabeticNames"; view.AddColumn("FirstName", typeof(string)).AddNullable() .AddColumn("LastName", typeof(string)).AddNullable(); var schema = new DatabaseSchema(null, null); schema.Views.Add(view); PrepareSchemaNames.Prepare(schema); var codeWriterSettings = new CodeWriterSettings { CodeTarget = CodeTarget.PocoNHibernateHbm, IncludeViews = true }; var cw = new ClassWriter(view, codeWriterSettings); //act var txt = cw.Write(); //assert var hasFirstName = txt.Contains("public virtual string FirstName"); var hasLastName = txt.Contains("public virtual string LastName"); var hasEquals = txt.Contains("public override bool Equals(object obj)"); Assert.IsTrue(hasFirstName); Assert.IsTrue(hasLastName); Assert.IsTrue(hasEquals); }
public DemoClass() { var s = new CodeWriterSettings(CodeWriterSettings.CSharpDefault); s.NewLineBeforeBlockBegin = false; s.TranslationMapping["`"] = "\""; var w = new CodeWriter(s); using (w.B("class Test")) { using (w.B("public int Sum(int a, int b)")) { w._("var r = a + b;", "return r;"); } using (w.B("public int Mul(int a, int b)")) { w._("var r = `a * b`;", "return r;"); } } w.HeadLines = new List <string> { "// COMMENT1", "// COMMENT2", "", "using System;", "", }; Debug.Log(w.ToString()); }
private CodeWriter CreateTestWriter() { var settings = new CodeWriterSettings(CodeWriterSettings.CSharpDefault); settings.Indent = " "; settings.NewLineBeforeBlockBegin = false; return(new CodeWriter(settings)); }
public FluentMappingWriter(DatabaseTable table, CodeWriterSettings codeWriterSettings, MappingNamer mappingNamer) { if (table == null) throw new ArgumentNullException("table"); if (mappingNamer == null) throw new ArgumentNullException("mappingNamer"); _codeWriterSettings = codeWriterSettings; _mappingNamer = mappingNamer; _table = table; _cb = new ClassBuilder(); }
public EntryCodeGenerator(Options options) { Options = options; var settings = new CodeWriterSettings(CodeWriterSettings.CSharpDefault); settings.TranslationMapping["`"] = "\""; CodeWriter = new CodeWriter.CodeWriter(settings); GenerateHead(); }
public void ProcedureTest() { var schema = PrepareModel(); var procedure = new DatabaseStoredProcedure { Name = "SelectCategory" }; var argument = new DatabaseArgument { Name = "p1", DatabaseDataType = "VARCHAR", Length = 10, DataType = DataTypeConverter.FindDataType("VARCHAR", schema.DataTypes, SqlType.SqlServer, null), In = true, }; procedure.Arguments.Add(argument); var rs = new DatabaseResultSet(); var resultColumn = new DatabaseColumn { Name = "Output", DbDataType = "VARCHAR" }; DataTypeConverter.AddDataType(resultColumn); rs.Columns.Add(resultColumn); procedure.ResultSets.Add(rs); schema.StoredProcedures.Add(procedure); var directory = TestHelper.CreateDirectory("MySprocTest"); const string @namespace = "MySprocTest"; var settings = new CodeWriterSettings { Namespace = @namespace, CodeTarget = CodeTarget.Poco, WriteStoredProcedures = true }; var target = new CodeWriter(schema, settings); target.Execute(directory); var procedures = directory.GetDirectories("Procedures").FirstOrDefault(); if (procedures == null) { Assert.Fail("Could not find Procedures subdirectory"); } var files = procedures.GetFiles("*.cs"); var products = files.FirstOrDefault(f => f.Name == "SelectCategory.cs"); Assert.IsNotNull(products, "Should have written SelectCategory class for SelectCategory procedure"); var category = files.FirstOrDefault(f => f.Name == "SelectCategoryResult.cs"); Assert.IsNotNull(category, "Should have written SelectCategoryResult class to the result of the sproc"); }
public EntryCodeGenerator(Options options) { Options = options; var settings = new CodeWriterSettings(CodeWriterSettings.CSharpDefault); settings.TranslationMapping["`"] = "\""; CodeWriter = new CodeWriter.CodeWriter(settings); GenerateHead(); }
public static void MakeHbm() { var dbReader = new DatabaseReader(connectionString, providername); var schema = dbReader.ReadAll(); var directory = new DirectoryInfo("C:\\Temp\\Models.NorthwindIB.NH"); var settings = new CodeWriterSettings { // or CodeTarget.PocoNHibernateFluent or CodeTarget.PocoEntityCodeFirst CodeTarget = CodeTarget.PocoNHibernateHbm, Namespace = "Models.NorthwindIB.NH" }; var codeWriter = new CodeWriter(schema, settings); codeWriter.Execute(directory); }
public void TestOneToOneTable() { //arrange var schema = Arrange(); var table = schema.FindTableByName("Products"); var codeWriterSettings = new CodeWriterSettings { CodeTarget = CodeTarget.PocoEntityCodeFirst }; var target = new CodeFirstMappingWriter(table, codeWriterSettings, new MappingNamer()); //act var txt = target.Write(); //assert Assert.IsTrue(txt.Contains("HasOptional(x => x.ProductDetail);")); }
public CodeFirstMappingWriter(DatabaseTable table, CodeWriterSettings codeWriterSettings, MappingNamer mappingNamer) { if (table == null) { throw new ArgumentNullException("table"); } if (mappingNamer == null) { throw new ArgumentNullException("mappingNamer"); } _codeWriterSettings = codeWriterSettings; _mappingNamer = mappingNamer; _table = table; _cb = new ClassBuilder(); }
public void ExecuteTest() { //arrange DatabaseSchema schema = PrepareModel(); var settings = new CodeWriterSettings(); var target = new CodeFirstContextWriter(settings); //act var result = target.Write(schema.Tables); //assert var hasDbSet = result.Contains("public IDbSet<Product> ProductCollection"); var hasMapping = result.Contains("modelBuilder.Configurations.Add(new ProductMapping());"); Assert.IsTrue(hasDbSet); Assert.IsTrue(hasMapping); }
public void OracleHrTest() { const string providername = "System.Data.OracleClient"; const string connectionString = ConnectionStrings.OracleHr; ProviderChecker.Check(providername, connectionString); var dbReader = new DatabaseReader(connectionString, providername); dbReader.Owner = "HR"; DatabaseSchema schema = null; try { schema = dbReader.ReadAll(); } catch (DbException exception) { Assert.Inconclusive("Cannot access database " + exception.Message); } var directory = TestHelper.CreateDirectory("Hr"); const string @namespace = "Hr.Domain"; var settings = new CodeWriterSettings { Namespace = @namespace, CodeTarget = CodeTarget.PocoNHibernateHbm }; var codeWriter = new CodeWriter(schema, settings); codeWriter.Execute(directory); var mapping = directory.GetDirectories("mapping").FirstOrDefault(); if (mapping == null) { Assert.Fail("Could not find Mapping subdirectory"); } var files = mapping.GetFiles("*.xml"); var employeeMap = files.First(f => f.Name == "Employee.hbm.xml"); var doc = XDocument.Load(employeeMap.FullName); var classElement = doc.Descendants("{urn:nhibernate-mapping-2.2}class").First(); Assert.AreEqual("Employee", (string)classElement.Attribute("name")); Assert.AreEqual("`EMPLOYEES`", (string)classElement.Attribute("table")); }
public void TableLinksToJoinTable() { //arrange var products = _schema.FindTableByName("Categories"); var codeWriterSettings = new CodeWriterSettings { CodeTarget = CodeTarget.PocoEfCore }; var target = new CodeFirstMappingWriter(products, codeWriterSettings, new MappingNamer()); //act var result = target.Write(); //assert var hasCategory = result.Contains("b.HasMany(x => x.CategoryProductCollection).WithOne("); Assert.IsTrue(hasCategory); }
public MappingWriter(DatabaseTable table, CodeWriterSettings codeWriterSettings) { _codeWriterSettings = codeWriterSettings; var ns = codeWriterSettings.Namespace; _table = table; _doc = XDocument.Parse(@"<?xml version=""1.0"" encoding=""utf-8"" ?> <hibernate-mapping xmlns=""urn:nhibernate-mapping-2.2"" namespace=""" + ns + @""" assembly=""" + ns + @"""> </hibernate-mapping>"); var hibmap = _doc.Descendants(_xmlns + "hibernate-mapping").First(); //add the class element _classElement = new XElement(_xmlns + "class", new XAttribute("name", _table.NetName), new XAttribute("table", SqlSafe(_table.Name)), _table.SchemaOwner != null ? new XAttribute("schema", SqlSafe(_table.SchemaOwner)) : null, //consider this new XAttribute("dynamic-update", "true"), new XAttribute("optimistic-lock", "dirty")); if (_table is DatabaseView) { _classElement.Add(new XAttribute("mutable", "false")); } hibmap.Add(_classElement); }
private static int Process(Options options) { try { Console.WriteLine("Start Process!"); // Resolve options var basePath = Path.GetFullPath(options.Path ?? "."); var sources = options.Sources.Where(p => string.IsNullOrWhiteSpace(p) == false && p.ToLower().IndexOf(".codegen.cs") == -1) .Select(p => MakeFullPath(p, basePath)) .ToArray(); var references = options.References.Where(p => string.IsNullOrWhiteSpace(p) == false) .Select(p => MakeFullPath(p, basePath)) .ToArray(); var targetDefaultPath = @".\Properties\TrackableData.CodeGen.cs"; var targetPath = MakeFullPath(options.TargetFile ?? targetDefaultPath, basePath); // Parse sources and extract interfaces Console.WriteLine("- Parse sources"); var syntaxTrees = sources.Select( file => CSharpSyntaxTree.ParseText(File.ReadAllText(file), path: file)).ToArray(); var interfaceDeclarations = syntaxTrees.SelectMany( st => st.GetRoot().DescendantNodes().OfType<InterfaceDeclarationSyntax>()).ToArray(); // Generate code Console.WriteLine("- Generate code"); var settings = new CodeWriterSettings(CodeWriterSettings.CSharpDefault); settings.TranslationMapping["`"] = "\""; var w = new CodeWriter.CodeWriter(settings); var relatedSourceTrees = new HashSet<SyntaxNode>(); w.HeadLines = new List<string> { "// ------------------------------------------------------------------------------", "// <auto-generated>", "// This code was generated by TrackableData.CodeGenerator.", "//", "// Changes to this file may cause incorrect behavior and will be lost if", "// the code is regenerated.", "// </auto-generated>", "// ------------------------------------------------------------------------------", "", "using System;", "using System.Collections.Generic;", "using System.Reflection;", "using System.Runtime.Serialization;", "using System.Linq;", "using System.Text;", "using TrackableData;", "" }; // TrackablePoco var pocoCodeGen = new TrackablePocoCodeGenerator() { Options = options }; foreach (var idecl in interfaceDeclarations) { var baseType = idecl.GetGenericBase("TrackableData.ITrackablePoco"); if (baseType != null) { var pocoType = baseType.TypeArgumentList.Arguments[0].ToString(); if (CodeAnalaysisExtensions.CompareTypeName(idecl.Identifier.ToString(), pocoType) == false) { throw new Exception($"Invalid base type of ITrackablePoco<{pocoType}>"); } pocoCodeGen.GenerateCode(idecl, w); relatedSourceTrees.Add(idecl.GetRootNode()); } } // TrackableContainer var containerCodeGen = new TrackableContainerCodeGenerator() { Options = options }; foreach (var idecl in interfaceDeclarations) { var baseType = idecl.GetGenericBase("TrackableData.ITrackableContainer"); if (baseType != null) { var containerType = baseType.TypeArgumentList.Arguments[0].ToString(); if (CodeAnalaysisExtensions.CompareTypeName(idecl.Identifier.ToString(), containerType) == false) { throw new Exception($"Invalid base type of ITrackableContainer<{containerType}>"); } containerCodeGen.GenerateCode(idecl, w); relatedSourceTrees.Add(idecl.GetRootNode()); } } // Resolve referenced using var usingDirectives = new HashSet<string>(relatedSourceTrees.SelectMany( st => st.DescendantNodes().OfType<UsingDirectiveSyntax>()).Select(x => x.Name.ToString())); foreach (var usingDirective in usingDirectives) EnsureUsing(w, usingDirective); // Save generated code Console.WriteLine("- Save code"); if (w.WriteAllText(targetPath, true) == false) Console.WriteLine("Nothing changed. Skip writing."); return 0; } catch (Exception e) { Console.WriteLine("Exception in processing:\n" + e); return 1; } }
public CodeFirstContextWriter(CodeWriterSettings codeWriterSettings) { _codeWriterSettings = codeWriterSettings; _cb = new ClassBuilder(); _contextName = CreateContextName(); }