public void PascalCasePlural()
{
var formatter = new PascalCaseTextFormatter();
Assert.AreEqual("ColumnNames", formatter.FormatPlural("Column_Name"));
Assert.AreEqual("ColumnNames", formatter.FormatPlural("COLUMN_NAME"));
}
public void PascalCaseSingular()
{
var formatter = new PascalCaseTextFormatter();
Assert.AreEqual("ColumnName", formatter.FormatSingular("Column_Names"));
Assert.AreEqual("ColumnName", formatter.FormatSingular("COLUMN_NAMES"));
}
public void PascalCasePlural()
{
var formatter = new PascalCaseTextFormatter();
Inflector.EnableInflection = true;
Assert.AreEqual("ColumnNames", formatter.FormatPlural("Column_Name"));
Assert.AreEqual("ColumnNames", formatter.FormatPlural("COLUMN_NAME"));
}
public void ConvertStringToPascalCase()
{
var formatter = new PascalCaseTextFormatter();
Assert.AreEqual("ColumnName", formatter.FormatText("column_name"));
Assert.AreEqual("TheNameIsBondJamesBond", formatter.FormatText("the_name_is_BOND_james_bond"));
}
public override void Generate(bool writeToFile = true)
{
var pascalCaseTextFormatter = new PascalCaseTextFormatter { PrefixRemovalList = appPrefs.FieldPrefixRemovalList };
var className = string.Format("{0}{1}{2}", appPrefs.ClassNamePrefix, pascalCaseTextFormatter.FormatSingular(Table.Name), "Map");
var compileUnit = GetCompleteCompileUnit(className);
var generateCode = GenerateCode(compileUnit, className);
if (writeToFile)
{
WriteToFile(generateCode, className);
}
}
public override void Generate(bool writeToFile = true)
{
var pascalCaseTextFormatter = new PascalCaseTextFormatter { PrefixRemovalList = appPrefs.FieldPrefixRemovalList };
var className = string.Format("{0}{1}", appPrefs.ClassNamePrefix, pascalCaseTextFormatter.FormatSingular(Table.Name));
var compileUnit = GetCompileUnit(className);
if (writeToFile)
{
WriteToFile(compileUnit, className);
} else
{
// Output to property
GeneratedCode = WriteToString(compileUnit, GetCodeDomProvider());
}
}
public CodeCompileUnit GetCompleteCompileUnit(string className)
{
var codeGenerationHelper = new CodeGenerationHelper();
var compileUnit = codeGenerationHelper.GetCodeCompileUnit(nameSpace, className);
var newType = compileUnit.Namespaces[0].Types[0];
newType.IsPartial = appPrefs.GeneratePartialClasses;
var pascalCaseTextFormatter = new PascalCaseTextFormatter { PrefixRemovalList = appPrefs.FieldPrefixRemovalList };
newType.BaseTypes.Add(string.Format("ClassMap<{0}{1}>", appPrefs.ClassNamePrefix, pascalCaseTextFormatter.FormatSingular(Table.Name)));
var constructor = new CodeConstructor {Attributes = MemberAttributes.Public};
constructor.Statements.Add(new CodeSnippetStatement(TABS + "Table(\"" + Table.Name + "\");"));
constructor.Statements.Add(new CodeSnippetStatement(TABS + "LazyLoad();"));
if(UsesSequence)
{
constructor.Statements.Add(new CodeSnippetStatement(String.Format(TABS + "Id(x => x.{0}).Column(x => x.{1}).GeneratedBy.Sequence(\"{2}\")",
Formatter.FormatText(Table.PrimaryKey.Columns[0].Name), Table.PrimaryKey.Columns[0].Name, appPrefs.Sequence)));
}
else if (Table.PrimaryKey.Type == PrimaryKeyType.PrimaryKey)
{
constructor.Statements.Add(GetIdMapCodeSnippetStatement(this.appPrefs, Table.PrimaryKey.Columns[0].Name, Table.PrimaryKey.Columns[0].DataType, Formatter));
}
else
{
constructor.Statements.Add(GetIdMapCodeSnippetStatement(Table.PrimaryKey, Formatter));
}
foreach (var fk in Table.ForeignKeys.Where(fk => fk.Columns.First().IsForeignKey && appPrefs.IncludeForeignKeys))
{
constructor.Statements.Add(new CodeSnippetStatement(string.Format(TABS + "References(x => x.{0}).Column(\"{1}\");", Formatter.FormatSingular(fk.UniquePropertyName), fk.Columns.First().Name)));
}
foreach (var column in Table.Columns.Where(x => !x.IsPrimaryKey && (!x.IsForeignKey || !appPrefs.IncludeForeignKeys)))
{
var columnMapping = new DBColumnMapper().Map(column, Formatter, appPrefs.IncludeLengthAndScale);
constructor.Statements.Add(new CodeSnippetStatement(TABS + columnMapping));
}
Table.HasManyRelationships.ToList().ForEach(x =>
constructor.Statements.Add(new OneToMany(Formatter).Create(x))
);
newType.Members.Add(constructor);
return compileUnit;
}
public CodeCompileUnit GetCompleteCompileUnit(string className)
{
var codeGenerationHelper = new CodeGenerationHelper();
var compileUnit = codeGenerationHelper.GetCodeCompileUnit(nameSpace, className);
var newType = compileUnit.Namespaces[0].Types[0];
newType.IsPartial = appPrefs.GeneratePartialClasses;
var pascalCaseTextFormatter = new PascalCaseTextFormatter { PrefixRemovalList = appPrefs.FieldPrefixRemovalList };
newType.BaseTypes.Add(string.Format("ClassMap<{0}{1}>", appPrefs.ClassNamePrefix, pascalCaseTextFormatter.FormatSingular(Table.Name)));
var constructor = new CodeConstructor {Attributes = MemberAttributes.Public};
constructor.Statements.Add(new CodeSnippetStatement(TABS + "Table(\"" + Table.Name + "\");"));
if (appPrefs.UseLazy)
constructor.Statements.Add(new CodeSnippetStatement(TABS + "LazyLoad();"));
if(UsesSequence)
{
var fieldName = FixPropertyWithSameClassName(Table.PrimaryKey.Columns[0].Name, Table.Name);
constructor.Statements.Add(new CodeSnippetStatement(String.Format(TABS + "Id(x => x.{0}).Column(x => x.{1}).GeneratedBy.Sequence(\"{2}\")",
Formatter.FormatText(fieldName), fieldName, appPrefs.Sequence)));
}
else if (Table.PrimaryKey !=null && Table.PrimaryKey.Type == PrimaryKeyType.PrimaryKey)
{
var fieldName = FixPropertyWithSameClassName(Table.PrimaryKey.Columns[0].Name, Table.Name);
constructor.Statements.Add(GetIdMapCodeSnippetStatement(this.appPrefs, Table, Table.PrimaryKey.Columns[0].Name, fieldName, Table.PrimaryKey.Columns[0].DataType, Formatter));
}
else if (Table.PrimaryKey != null)
{
constructor.Statements.Add(GetIdMapCodeSnippetStatement(Table.PrimaryKey, Table, Formatter));
}
// Many To One Mapping
foreach (var fk in Table.ForeignKeys.Where(fk => fk.Columns.First().IsForeignKey && appPrefs.IncludeForeignKeys))
{
var propertyName = appPrefs.NameFkAsForeignTable ? fk.UniquePropertyName : fk.Columns.First().Name;
string name = propertyName;
propertyName = Formatter.FormatSingular(propertyName);
var fieldName = FixPropertyWithSameClassName(propertyName, Table.Name);
var pkAlsoFkQty = (from fks in Table.ForeignKeys.Where(fks => fks.UniquePropertyName == name) select fks).Count();
if (pkAlsoFkQty > 1)
{
constructor.Statements.Add(new CodeSnippetStatement(string.Format(TABS + "References(x => x.{0}).Column(\"{1}\").ForeignKey(\"{2}\");", fieldName, fk.Columns.First().Name, fk.Columns.First().ConstraintName)));
}
else
{
constructor.Statements.Add(new CodeSnippetStatement(string.Format(TABS + "References(x => x.{0}).Column(\"{1}\");", fieldName, fk.Columns.First().Name)));
}
}
// Property Map
foreach (var column in Table.Columns.Where(x => !x.IsPrimaryKey && (!x.IsForeignKey || !appPrefs.IncludeForeignKeys)))
{
var propertyName = Formatter.FormatText(column.Name);
var fieldName = FixPropertyWithSameClassName(propertyName, Table.Name);
var columnMapping = new DBColumnMapper().Map(column, fieldName, Formatter, appPrefs.IncludeLengthAndScale);
constructor.Statements.Add(new CodeSnippetStatement(TABS + columnMapping));
}
// Bag (HasMany in FluentMapping)
if (appPrefs.IncludeHasMany)
Table.HasManyRelationships.ToList().ForEach(x => constructor.Statements.Add(new OneToMany(Formatter).Create(x)));
newType.Members.Add(constructor);
return compileUnit;
}
public CodeCompileUnit GetCompileUnit(string className)
{
var codeGenerationHelper = new CodeGenerationHelper();
var compileUnit = codeGenerationHelper.GetCodeCompileUnitWithInheritanceAndInterface(nameSpace, className, appPrefs.InheritenceAndInterfaces);
var mapper = new DataTypeMapper();
var newType = compileUnit.Namespaces[0].Types[0];
newType.IsPartial = appPrefs.GeneratePartialClasses;
CreateProperties(codeGenerationHelper, mapper, newType);
// Generate GetHashCode() and Equals() methods.
if (Table.PrimaryKey != null && Table.PrimaryKey.Columns.Count != 0 && Table.PrimaryKey.Type == PrimaryKeyType.CompositeKey)
{
var pkColsList = new List<string>();
foreach (var pkCol in Table.PrimaryKey.Columns)
{
if (pkCol.IsForeignKey && appPrefs.IncludeForeignKeys)
{
pkColsList.Add(Formatter.FormatSingular(pkCol.ForeignKeyTableName) + "." + Formatter.FormatText(pkCol.ForeignKeyColumnName));
}
else
{
pkColsList.Add(Formatter.FormatText(pkCol.Name));
}
}
var equalsCode = CreateCompositeKeyEqualsMethod(pkColsList);
var getHashKeyCode = CreateCompositeKeyGetHashKeyMethod(pkColsList);
equalsCode.StartDirectives.Add(new CodeRegionDirective(CodeRegionMode.Start, "NHibernate Composite Key Requirements"));
newType.Members.Add(equalsCode);
newType.Members.Add(getHashKeyCode);
getHashKeyCode.EndDirectives.Add(new CodeRegionDirective(CodeRegionMode.End, string.Empty));
}
// Dont create a constructor if there are no relationships.
if (Table.HasManyRelationships.Count == 0)
return compileUnit;
var pascalCaseTextFormatter = new PascalCaseTextFormatter { PrefixRemovalList = appPrefs.FieldPrefixRemovalList };
var constructorStatements = new CodeStatementCollection();
if (appPrefs.IncludeHasMany)
foreach (var hasMany in Table.HasManyRelationships)
{
if (appPrefs.Language == Language.CSharp)
{
newType.Members.Add(codeGenerationHelper.CreateAutoProperty(string.Format("{0}<{1}{2}>", appPrefs.ForeignEntityCollectionType, appPrefs.ClassNamePrefix, pascalCaseTextFormatter.FormatSingular(hasMany.Reference)), Formatter.FormatPlural(hasMany.Reference), appPrefs.UseLazy));
constructorStatements.Add(new CodeSnippetStatement(string.Format(TABS + "{0} = new {1}<{2}{3}>();", Formatter.FormatPlural(hasMany.Reference), codeGenerationHelper.InstatiationObject(appPrefs.ForeignEntityCollectionType), appPrefs.ClassNamePrefix, pascalCaseTextFormatter.FormatSingular(hasMany.Reference))));
} else if (appPrefs.Language == Language.VB)
{
newType.Members.Add(codeGenerationHelper.CreateAutoProperty(string.Format("{0}(Of {1}{2})", appPrefs.ForeignEntityCollectionType, appPrefs.ClassNamePrefix, pascalCaseTextFormatter.FormatSingular(hasMany.Reference)), Formatter.FormatPlural(hasMany.Reference), appPrefs.UseLazy));
constructorStatements.Add(new CodeSnippetStatement(string.Format(TABS + "{0} = New {1}(Of {2}{3})()", Formatter.FormatPlural(hasMany.Reference), codeGenerationHelper.InstatiationObject(appPrefs.ForeignEntityCollectionType), appPrefs.ClassNamePrefix, pascalCaseTextFormatter.FormatSingular(hasMany.Reference))));
}
}
var constructor = new CodeConstructor { Attributes = MemberAttributes.Public };
constructor.Statements.AddRange(constructorStatements);
newType.Members.Add(constructor);
return compileUnit;
}
private void CreateFullProperties(CodeGenerationHelper codeGenerationHelper, DataTypeMapper mapper, CodeTypeDeclaration newType)
{
var camelCaseFormatter = new CamelCaseTextFormatter();
if (Table.PrimaryKey != null)
{
foreach (var pk in Table.PrimaryKey.Columns)
{
if (pk.IsForeignKey && appPrefs.IncludeForeignKeys)
{
newType.Members.Add(codeGenerationHelper.CreateField(Formatter.FormatSingular(pk.ForeignKeyTableName), "_" + camelCaseFormatter.FormatSingular(pk.ForeignKeyTableName)));
newType.Members.Add(codeGenerationHelper.CreateProperty(Formatter.FormatSingular(pk.ForeignKeyTableName), Formatter.FormatSingular(pk.ForeignKeyTableName), appPrefs.UseLazy));
}
else
{
var mapFromDbType = mapper.MapFromDBType(appPrefs.ServerType, pk.DataType, pk.DataLength, pk.DataPrecision, pk.DataScale);
var pkAlsoFkQty = (from fk in Table.ForeignKeys.Where(fk => fk.UniquePropertyName == pk.Name) select fk).Count();
var fieldName = FixPropertyWithSameClassName(pk.Name, Table.Name);
if (pkAlsoFkQty > 0)
{
fieldName = fieldName + "Id";
}
newType.Members.Add(codeGenerationHelper.CreateField(mapFromDbType, "_" + camelCaseFormatter.FormatText(fieldName), true));
newType.Members.Add(codeGenerationHelper.CreateProperty(mapFromDbType, Formatter.FormatText(fieldName), appPrefs.UseLazy));
}
}
}
if (appPrefs.IncludeForeignKeys)
{
var pascalCaseTextFormatter = new PascalCaseTextFormatter { PrefixRemovalList = appPrefs.FieldPrefixRemovalList };
// Note that a foreign key referencing a primary within the same table will end up giving you a foreign key property with the same name as the table.
foreach (var fk in Table.Columns.Where(c => c.IsForeignKey && !c.IsPrimaryKey))
{
var typeName = appPrefs.ClassNamePrefix + pascalCaseTextFormatter.FormatSingular(fk.ForeignKeyTableName);
var propertyName = fk.ForeignKeyTableName;
var fieldName = FixPropertyWithSameClassName(propertyName, Table.Name);
newType.Members.Add(codeGenerationHelper.CreateField(typeName, string.Format("_{0}", camelCaseFormatter.FormatSingular(fieldName))));
newType.Members.Add(codeGenerationHelper.CreateProperty(typeName, Formatter.FormatSingular(fieldName), appPrefs.UseLazy));
}
}
foreach (var column in Table.Columns.Where(x => !x.IsPrimaryKey && (!x.IsForeignKey || !appPrefs.IncludeForeignKeys)))
{
var mapFromDbType = mapper.MapFromDBType(appPrefs.ServerType, column.DataType, column.DataLength, column.DataPrecision, column.DataScale);
var fieldName = FixPropertyWithSameClassName(column.Name, Table.Name);
newType.Members.Add(codeGenerationHelper.CreateField(mapFromDbType, "_" + camelCaseFormatter.FormatText(fieldName), column.IsNullable));
var property = codeGenerationHelper.CreateProperty(mapFromDbType, Formatter.FormatText(fieldName), column.IsNullable, appPrefs.UseLazy);
AttachValidatorAttributes(ref property, column);
newType.Members.Add(property);
}
}
private void CreateFields(CodeGenerationHelper codeGenerationHelper, DataTypeMapper mapper,
CodeTypeDeclaration newType)
{
if (Table.PrimaryKey != null)
{
foreach (var pk in Table.PrimaryKey.Columns)
{
var mapFromDbType = mapper.MapFromDBType(appPrefs.ServerType, pk.DataType, pk.DataLength, pk.DataPrecision, pk.DataScale);
var propertyName = Formatter.FormatText(pk.Name);
var fieldName = FixPropertyWithSameClassName(propertyName, Table.Name);
var pkAlsoFkQty = (from fk in Table.ForeignKeys.Where(fk => fk.UniquePropertyName == pk.Name) select fk).Count();
if (pkAlsoFkQty > 0)
fieldName = fieldName + "Id";
newType.Members.Add(codeGenerationHelper.CreateField(mapFromDbType, fieldName, true));
}
}
if (appPrefs.IncludeForeignKeys)
{
var pascalCaseTextFormatter = new PascalCaseTextFormatter();
// Note that a foreign key referencing a primary within the same table will end up giving you a foreign key property with the same name as the table.
foreach (var fk in Table.ForeignKeys.Where(fk => !string.IsNullOrEmpty(fk.References)))
{
var propertyName = fk.UniquePropertyName;
propertyName = Formatter.FormatSingular(propertyName);
var fieldName = FixPropertyWithSameClassName(propertyName, Table.Name);
var typeName = appPrefs.ClassNamePrefix + pascalCaseTextFormatter.FormatSingular(fk.References);
newType.Members.Add(codeGenerationHelper.CreateField(typeName, fieldName));
}
}
foreach (var column in Table.Columns.Where(x => !x.IsPrimaryKey && (!x.IsForeignKey || !appPrefs.IncludeForeignKeys)))
{
var mapFromDbType = mapper.MapFromDBType(appPrefs.ServerType, column.DataType, column.DataLength, column.DataPrecision, column.DataScale);
var propertyName = Formatter.FormatText(column.Name);
var fieldName = FixPropertyWithSameClassName(propertyName, Table.Name);
newType.Members.Add(codeGenerationHelper.CreateField(mapFromDbType, fieldName, column.IsNullable));
}
}
public static ITextFormatter GetTextFormatter(ApplicationPreferences applicationPreferences)
{
ITextFormatter formatter;
switch(applicationPreferences.FieldNamingConvention)
{
case FieldNamingConvention.SameAsDatabase:
formatter = new UnformattedTextFormatter();
break;
case FieldNamingConvention.CamelCase:
formatter = new CamelCaseTextFormatter();
break;
case FieldNamingConvention.PascalCase:
formatter = new PascalCaseTextFormatter();
break;
case FieldNamingConvention.Prefixed:
formatter = new PrefixedTextFormatter(applicationPreferences.Prefix);
break;
default:
throw new Exception("Invalid or unsupported field naming convention.");
}
formatter.PrefixRemovalList = applicationPreferences.FieldPrefixRemovalList;
return formatter;
}
public CodeCompileUnit GetCompleteCompileUnit(string className)
{
var codeGenerationHelper = new CodeGenerationHelper();
var compileUnit = codeGenerationHelper.GetCodeCompileUnit(nameSpace, className);
var newType = compileUnit.Namespaces[0].Types[0];
newType.IsPartial = appPrefs.GeneratePartialClasses;
var pascalCaseTextFormatter = new PascalCaseTextFormatter {PrefixRemovalList = appPrefs.FieldPrefixRemovalList};
newType.BaseTypes.Add(string.Format("EntityTypeConfiguration<{0}{1}>", appPrefs.ClassNamePrefix, pascalCaseTextFormatter.FormatSingular(Table.Name)));
var constructor = new CodeConstructor {Attributes = MemberAttributes.Public};
constructor.Statements.Add(new CodeSnippetStatement(TABS + "ToTable(\"" + Table.Name + "\");"));
if (appPrefs.UseLazy)
constructor.Statements.Add(new CodeSnippetStatement(TABS + "LazyLoad();"));
if (UsesSequence)
{
var fieldName = FixPropertyWithSameClassName(Table.PrimaryKey.Columns[0].Name, Table.Name);
constructor.Statements.Add(new CodeSnippetStatement(String.Format(TABS + "Id(x => x.{0}).Column(x => x.{1}).GeneratedBy.Sequence(\"{2}\")", Formatter.FormatText(fieldName), fieldName, appPrefs.Sequence)));
}
else if (Table.PrimaryKey != null && Table.PrimaryKey.Type == PrimaryKeyType.PrimaryKey)
{
var fieldName = FixPropertyWithSameClassName(Table.PrimaryKey.Columns[0].Name, Table.Name);
constructor.Statements.Add(GetIdMapCodeSnippetStatement(appPrefs, Table, Table.PrimaryKey.Columns[0].Name, fieldName, Table.PrimaryKey.Columns[0].DataType, Formatter));
}
else if (Table.PrimaryKey != null)
{
constructor.Statements.Add(GetIdMapCodeSnippetStatement(Table.PrimaryKey, Table, Formatter));
}
// Many To One Mapping
foreach (var fk in Table.ForeignKeys.Where(fk => fk.Columns.First().IsForeignKey && appPrefs.IncludeForeignKeys))
{
var propertyName = appPrefs.NameFkAsForeignTable ? fk.UniquePropertyName : fk.Columns.First().Name;
propertyName = Formatter.FormatSingular(propertyName);
var fieldName = FixPropertyWithSameClassName(propertyName, Table.Name);
var propertyMapType = "HasRequired";
if (fk.IsNullable)
{
propertyMapType = "HasOptional";
}
var codeSnippet = string.Format(TABS + "{0}(x => x.{1}).WithMany(t => t.{2}).HasForeignKey(d => d.{3});", propertyMapType, fieldName, fk.Columns.First().ForeignKeyTableName, fk.Columns.First().ForeignKeyColumnName);
constructor.Statements.Add(new CodeSnippetStatement(codeSnippet));
}
foreach (var column in Table.Columns.Where(x => !x.IsPrimaryKey && (!x.IsForeignKey || !appPrefs.IncludeForeignKeys)))
{
var propertyName = Formatter.FormatText(column.Name);
var fieldName = FixPropertyWithSameClassName(propertyName, Table.Name);
var columnMapping = new DBColumnMapper().Map(column, fieldName, Formatter, appPrefs.IncludeLengthAndScale);
constructor.Statements.Add(new CodeSnippetStatement(TABS + columnMapping));
}
if (appPrefs.IncludeHasMany)
{
Table.HasManyRelationships.ToList().ForEach(x => constructor.Statements.Add(new EFOneToMany(Formatter, pascalCaseTextFormatter).Create(x)));
}
newType.Members.Add(constructor);
return compileUnit;
}
public EFOneToMany(ITextFormatter formatter, PascalCaseTextFormatter pascalCaseTextFormatter)
{
this.pascalCaseTextFormatter = pascalCaseTextFormatter;
Formatter = formatter;
}
private void CreateAutoProperties(CodeGenerationHelper codeGenerationHelper, DataTypeMapper mapper, CodeTypeDeclaration newType)
{
if (Table.PrimaryKey != null)
{
foreach (var pk in Table.PrimaryKey.Columns)
{
var mapFromDbType = mapper.MapFromDBType(this.appPrefs.ServerType, pk.DataType, pk.DataLength,
pk.DataPrecision, pk.DataScale);
newType.Members.Add(codeGenerationHelper.CreateAutoProperty(mapFromDbType.ToString(),
Formatter.FormatText(pk.Name),
appPrefs.UseLazy));
}
}
if (appPrefs.IncludeForeignKeys)
{
var pascalCaseTextFormatter = new PascalCaseTextFormatter { PrefixRemovalList = appPrefs.FieldPrefixRemovalList };
// Note that a foreign key referencing a primary within the same table will end up giving you a foreign key property with the same name as the table.
foreach (var fk in Table.ForeignKeys.Where(fk => !string.IsNullOrEmpty(fk.References)))
{
var typeName = appPrefs.ClassNamePrefix + pascalCaseTextFormatter.FormatSingular(fk.References);
newType.Members.Add(codeGenerationHelper.CreateAutoProperty(typeName, Formatter.FormatSingular(fk.UniquePropertyName), appPrefs.UseLazy));
}
}
foreach (var column in Table.Columns.Where(x => !x.IsPrimaryKey && (!x.IsForeignKey || !appPrefs.IncludeForeignKeys)))
{
var mapFromDbType = mapper.MapFromDBType(this.appPrefs.ServerType, column.DataType, column.DataLength, column.DataPrecision, column.DataScale);
var property = codeGenerationHelper.CreateAutoProperty(mapFromDbType, Formatter.FormatText(column.Name), column.IsNullable, appPrefs.UseLazy);
AttachValidatorAttributes(ref property, column);
newType.Members.Add(property);
}
}
private void CreateAutoProperties(CodeGenerationHelper codeGenerationHelper, DataTypeMapper mapper, CodeTypeDeclaration newType)
{
if (Table.PrimaryKey != null)
{
foreach (var pk in Table.PrimaryKey.Columns)
{
if (pk.IsForeignKey && appPrefs.IncludeForeignKeys)
{
newType.Members.Add(codeGenerationHelper.CreateAutoProperty(Formatter.FormatSingular(pk.ForeignKeyTableName),
Formatter.FormatSingular(pk.ForeignKeyTableName),
appPrefs.UseLazy));
}
else
{
var mapFromDbType = mapper.MapFromDBType(this.appPrefs.ServerType, pk.DataType, pk.DataLength,
pk.DataPrecision, pk.DataScale);
var fieldName = FixPropertyWithSameClassName(pk.Name, Table.Name);
var pkAlsoFkQty = (from fk in Table.ForeignKeys.Where(fk => fk.UniquePropertyName == pk.Name) select fk).Count();
if (pkAlsoFkQty > 0)
fieldName = fieldName + "Id";
newType.Members.Add(codeGenerationHelper.CreateAutoProperty(mapFromDbType.ToString(),
Formatter.FormatText(fieldName),
appPrefs.UseLazy));
}
}
}
if (appPrefs.IncludeForeignKeys)
{
var pascalCaseTextFormatter = new PascalCaseTextFormatter { PrefixRemovalList = appPrefs.FieldPrefixRemovalList };
// Note that a foreign key referencing a primary within the same table will end up giving you a foreign key property with the same name as the table.
string lastOne = null;
foreach (var fk in Table.Columns.Where(c => c.IsForeignKey && !c.IsPrimaryKey))
{
var typeName = appPrefs.ClassNamePrefix + pascalCaseTextFormatter.FormatSingular(fk.ForeignKeyTableName);
if (String.IsNullOrEmpty(typeName))
{
System.Diagnostics.Trace.WriteLine(String.Format("Skipping null ForeignKeyTableName for field {0}", fk.Name));
continue;
}
var propertyName = Formatter.FormatSingular(fk.ForeignKeyTableName);
var fieldName = FixPropertyWithSameClassName(propertyName, Table.Name);
if (lastOne != fieldName)
newType.Members.Add(codeGenerationHelper.CreateAutoProperty(typeName, fieldName, appPrefs.UseLazy));
lastOne = fieldName;
}
}
foreach (var column in Table.Columns.Where(x => !x.IsPrimaryKey && (!x.IsForeignKey || !appPrefs.IncludeForeignKeys)))
{
var mapFromDbType = mapper.MapFromDBType(this.appPrefs.ServerType, column.DataType, column.DataLength, column.DataPrecision, column.DataScale);
var fieldName = FixPropertyWithSameClassName(column.Name, Table.Name);
var property = codeGenerationHelper.CreateAutoProperty(mapFromDbType, Formatter.FormatText(fieldName), column.IsNullable, appPrefs.UseLazy);
AttachValidatorAttributes(ref property, column);
newType.Members.Add(property);
}
}