private void WriteGetListCommon(IEnumerable <Parameter> methodParameters, string innerJoinClause, string columnsToReturn)
{
WriteGetListMethodSummary(methodParameters);
var methodSignature = CodeWriterUtils.GetGetListMethodSignature(table, codeWriterSettings, methodParameters);
using (classBuilder.BeginNest($"public {methodSignature}"))
{
CodeWriterUtils.WriteEntryLogging(classBuilder, methodSignature);
var sqlCommandText = ConstructSqlQuery(methodParameters, innerJoinClause, columnsToReturn);
classBuilder.AppendLine($"var entities = new List<{table.NetName}>();");
WriteBeginCreateConnection();
WriteBeginCreateCommand();
classBuilder.AppendLine($"command.CommandText = {sqlCommandText};");
WriteAddParametersToCommand(methodParameters);
WriteBeginExecuteReader();
WriteBeginReadReaderMultiple();
classBuilder.AppendLine($"var entity = ({table.NetName}){_serviceProviderFieldName}.GetService(typeof({table.NetName}));");
WriteParseEntityFromReader("entity");
classBuilder.AppendLine("entities.Add(entity);");
classBuilder.EndNest();
classBuilder.EndNest();
classBuilder.EndNest();
classBuilder.EndNest();
classBuilder.AppendLine("");
classBuilder.AppendLine("return entities;");
CodeWriterUtils.WriteExitLogging(classBuilder, methodSignature);
}
classBuilder.AppendLine("");
}
private void WriteGetListBy(IEnumerable <DatabaseColumn> columns)
{
var methodParameters = CodeWriterUtils.GetMethodParametersForColumns(columns, codeWriterSettings);
WriteGetListByMethodSummary(methodParameters);
var methodSignature = CodeWriterUtils.GetGetListByMethodSignature(table, columns, codeWriterSettings, methodParameters);
using (classBuilder.BeginNest($"public {methodSignature}"))
{
CodeWriterUtils.WriteEntryLogging(classBuilder, methodSignature);
var sqlCommandText = ConstructSqlQuery(methodParameters, null, GetAllColumnNames(new List <DatabaseTable> {
table
}));
classBuilder.AppendLine($"var entities = new List<{table.NetName}>();");
WriteBeginCreateConnection();
WriteBeginCreateCommand();
classBuilder.AppendLine($"command.CommandText = {sqlCommandText};");
WriteAddParametersToCommand(methodParameters);
WriteBeginExecuteReader();
WriteBeginReadReaderMultiple();
classBuilder.AppendLine($"var entity = ({table.NetName}){_serviceProviderFieldName}.GetService(typeof({table.NetName}));");
WriteParseEntityFromReader("entity");
classBuilder.AppendLine("entities.Add(entity);");
classBuilder.EndNest();
classBuilder.EndNest();
classBuilder.EndNest();
classBuilder.EndNest();
classBuilder.AppendLine("");
classBuilder.AppendLine("return entities;");
CodeWriterUtils.WriteExitLogging(classBuilder, methodSignature);
}
}
private void WriteUpdate()
{
var methodParameters = CodeWriterUtils.GetUpdateMethodParameters(table, codeWriterSettings, false, false);
methodParameters = CodeWriterUtils.AddEntityParameter(methodParameters, table, "An entity with updated values.");
classBuilder.AppendLine($"{CodeWriterUtils.GetUpdateMethodSignature(table, codeWriterSettings, methodParameters)};");
}
private void WriteDeletePhysicalCommon(IEnumerable <Parameter> methodParameters, string usingClause, string whereClause)
{
var partialMethodName = CodeWriterUtils.ConvertParametersToMethodNameByPart(methodParameters, codeWriterSettings);
classBuilder.BeginNest($"private int {CodeWriterUtils.BaseMethodNameDelete}PhysicalBy{partialMethodName}({CodeWriterUtils.PrintParametersForSignature(methodParameters)})");
var thisTableAlias = codeWriterSettings.Namer.NameToAcronym(table.Name);
var sqlCommandText = $"\"DELETE FROM ONLY \\\"{table.Name}\\\" AS {thisTableAlias}";
if (!string.IsNullOrEmpty(usingClause))
{
sqlCommandText = $"{sqlCommandText} USING {usingClause}";
}
sqlCommandText = $"{sqlCommandText} WHERE {whereClause};\"";
WriteBeginCreateConnection();
WriteBeginCreateCommand();
classBuilder.AppendLine($"command.CommandText = {sqlCommandText};");
WriteAddParametersToCommand(methodParameters);
classBuilder.BeginNest("try");
classBuilder.AppendLine($"return command.ExecuteNonQuery();");
classBuilder.EndNest();
classBuilder.BeginNest("catch (Exception e)");
classBuilder.BeginNest($"if (e is Npgsql.PostgresException pge && pge.SqlState == \"23503\")");
classBuilder.AppendLine("throw new EntityHasDependenciesException();");
classBuilder.EndNest();
classBuilder.AppendLine("");
classBuilder.AppendLine("throw;");
classBuilder.EndNest();
classBuilder.EndNest();
classBuilder.EndNest();
// TODO: KE - consider throwing here if multiple rows were modified! It should never be the case except for bad data even though the schema allows it
classBuilder.EndNest();
}
private void WriteDeleteLogicalCommon(IEnumerable <Parameter> methodParameters, string fromClause, string whereClause, string columnsToReturn)
{
var partialMethodName = CodeWriterUtils.ConvertParametersToMethodNameByPart(methodParameters, codeWriterSettings);
using (classBuilder.BeginNest($"private {table.NetName} {CodeWriterUtils.BaseMethodNameDelete}LogicalBy{partialMethodName}({CodeWriterUtils.PrintParametersForSignature(methodParameters)})"))
{
var logicalDeleteColumn = table.Columns.Single(c => logicalDeleteColumns.Contains(c.Name));
var setClause = $"\\\"{logicalDeleteColumn.Name}\\\" = NOW()";
var thisTableAlias = codeWriterSettings.Namer.NameToAcronym(table.Name);
var sqlCommandText = $"\"UPDATE ONLY \\\"{table.Name}\\\" AS {thisTableAlias} SET {setClause}";
if (!string.IsNullOrEmpty(fromClause))
{
sqlCommandText = $"{sqlCommandText} FROM {fromClause}";
}
sqlCommandText = $"{sqlCommandText} WHERE {whereClause} RETURNING {columnsToReturn};\";";
var entityVariableName = "deletedEntity";
classBuilder.AppendLine($"{table.NetName} {entityVariableName} = null;");
WriteBeginCreateConnection();
WriteBeginCreateCommand();
classBuilder.AppendLine($"command.CommandText = {sqlCommandText};");
WriteAddParametersToCommand(methodParameters);
WriteBeginExecuteReader();
WriteBeginReadReaderSingle();
// TODO: KE - consider throwing here if multiple rows were modified! It should never be the case except for bad data even though the schema allows it
classBuilder.AppendLine($"{entityVariableName} = ({table.NetName}){_serviceProviderFieldName}.GetService(typeof({table.NetName}));");
WriteParseEntityFromReader(entityVariableName);
classBuilder.EndNest();
classBuilder.EndNest();
classBuilder.EndNest();
classBuilder.EndNest();
WriteReturnEntityIfNotNull(entityVariableName);
}
}
public void WriteWith(DatabaseTable foreignKeyChild)
{
var ffks = CodeWriterUtils.GetWithForeignKeys(table, foreignKeyChild).ToList();
foreach (var ffk in ffks)
{
var ffkTable = table.DatabaseSchema.FindTableByName(ffk.TableName);
var ffkReferencedTable = ffk.ReferencedTable(table.DatabaseSchema);
var ffkColumns = ffk.Columns.Select(item => ffkTable.FindColumn(item));
ffkColumns.OrderBy(item => item.Name);
var ffkReferencedColumns = ffk.ReferencedColumns(table.DatabaseSchema).Select(item => ffkReferencedTable.FindColumn(item));
var withMethodSignature = CodeWriterUtils.GetWithMethodSignature(
ffkReferencedTable,
ffkTable,
ffk,
codeWriterSettings);
string propertyName = null;
string repositoryMethodNameForFfkTable = null;
if (table.IsSharedPrimaryKey(foreignKeyChild))
{
propertyName = foreignKeyChild.Name;
repositoryMethodNameForFfkTable = CodeWriterUtils.GetGetMethodName(ffkColumns, codeWriterSettings, true);
}
else
{
propertyName = codeWriterSettings.Namer.ForeignKeyCollectionName(ffkReferencedTable.Name, ffkTable, ffk);
repositoryMethodNameForFfkTable = CodeWriterUtils.GetGetMethodName(ffkColumns, codeWriterSettings, false);
}
classBuilder.BeginNest($"public virtual {withMethodSignature}");
var repositoryMethodCallParametersForFfkTable = new List <string>();
foreach (var ffkReferencedColumn in ffkReferencedColumns)
{
var parameter = $"{CodeWriterUtils.GetPropertyNameForDatabaseColumn(ffkReferencedColumn)}";
if (ffkReferencedColumn.Nullable && CodeWriterUtils.FindDataType(ffkReferencedColumn).EndsWith("?"))
{
using (classBuilder.BeginNest($"if (!{parameter}.HasValue)"))
{
classBuilder.AppendLine($"{propertyName} = new List<{ffkTable.NetName}>();");
classBuilder.AppendLine("return this;");
}
classBuilder.AppendLine("");
parameter += ".Value";
}
repositoryMethodCallParametersForFfkTable.Add(parameter);
}
var repositoryMethodCallParametersForFfkTablePrinted = string.Join(", ", repositoryMethodCallParametersForFfkTable);
var fieldNameForFfkTableRepository = NameFixer.ToCamelCase(CodeWriterUtils.GetRepositoryImplementationName(foreignKeyChild));
classBuilder.AppendLine($"{propertyName} = _{fieldNameForFfkTableRepository}.{repositoryMethodNameForFfkTable}({repositoryMethodCallParametersForFfkTablePrinted});");
classBuilder.AppendLine("return this;");
classBuilder.EndNest();
classBuilder.AppendLine("");
}
}
private void WriteGet()
{
var methodParameters = CodeWriterUtils.GetGetMethodParameters(table, codeWriterSettings, false, false).ToList();
WriteGetCommon(methodParameters, null, GetAllColumnNames(new List <DatabaseTable> {
table
}));
}
private void WriteConstructorsAndFields()
{
var tables = CodeWriterUtils.GetAllForeignTables(table);
var fields = CodeWriterUtils.GetTablesAsParameters(tables);
WriteFields(fields);
WriteConstructor();
WriteConstructor(fields);
}
private void WriteUpdate()
{
var methodParameters = CodeWriterUtils.GetUpdateMethodParameters(table, codeWriterSettings, false, false);
var whereClause = GetWhereClauseFromMethodParameters(methodParameters.ToList());
WriteUpdateCommon(methodParameters, null, whereClause, GetAllColumnNames(new List <DatabaseTable> {
table
}));
}
private void WriteGetListBys()
{
var combinations = CodeWriterUtils.GetGetListByColumnCombinations(table)?.ToList();
combinations?.ForEach(c =>
{
WriteGetListBy(c);
classBuilder.AppendLine("");
});
}
public void Execute()
{
foreach (var t in schema.Tables)
{
table = t;
classBuilder = new ClassBuilder();
var implementationText = Write();
CodeWriterUtils.WriteClassFile(codeWriterSettings.OutputDirectory, CodeWriterUtils.GetRepositoryInterfaceName(table), implementationText);
}
}
private string Write(EnumeratedDataType type)
{
CodeWriterUtils.WriteFileHeader(classBuilder);
WriteUsings();
classBuilder.BeginNest($"namespace {codeWriterSettings.Namespace}");
classBuilder.BeginNest($"public enum {type.NetDataType}");
WriteEnumerationValues(type);
classBuilder.EndNest();
classBuilder.EndNest();
return(classBuilder.ToString());
}
private void WriteDeleteUnique()
{
var methodParameters = CodeWriterUtils.GetDeleteMethodParameters(table, codeWriterSettings, false, true);
if (methodParameters == null || !methodParameters.Any())
{
return;
}
classBuilder.AppendLine($"{CodeWriterUtils.GetDeleteMethodSignature(table, codeWriterSettings, methodParameters)};");
}
private void WriteGetUniqueByCustomer()
{
var methodParametersUniqueByCustomer = CodeWriterUtils.GetGetMethodParameters(table, codeWriterSettings, true, true);
if (methodParametersUniqueByCustomer == null || !methodParametersUniqueByCustomer.Any())
{
return;
}
WriteGetCommon(methodParametersUniqueByCustomer, GetInnerJoinOrgUnitClause(), GetAllColumnNamesByCustomer());
}
private void WriteGetByCustomer()
{
var methodParameters = CodeWriterUtils.GetGetMethodParameters(table, codeWriterSettings, true, false);
if (methodParameters == null || !methodParameters.Any())
{
return;
}
classBuilder.AppendLine($"{CodeWriterUtils.GetGetMethodSignature(table, codeWriterSettings, methodParameters)};");
}
private void WriteConstructor(IEnumerable <Parameter> fields)
{
var constructorSignature = string.Join(", ", fields.Select(f => $"{f.DataType} {f.Name}"));
using (classBuilder.BeginNest($"public {CodeWriterUtils.GetRepositoryImplementationName(table)}({constructorSignature})"))
{
foreach (var f in fields)
{
classBuilder.AppendLine($"this.{f.Name} = {f.Name};");
}
}
}
private void WriteGetLists()
{
classBuilder.AppendLine($"{CodeWriterUtils.GetGetListMethodSignature(table, codeWriterSettings, CodeWriterUtils.GetGetListMethodParameters(table, codeWriterSettings, false))};");
var methodParametersByCustomer = CodeWriterUtils.GetGetListMethodParameters(table, codeWriterSettings, true);
if (methodParametersByCustomer == null || !methodParametersByCustomer.Any())
{
return;
}
classBuilder.AppendLine($"{CodeWriterUtils.GetGetListMethodSignature(table, codeWriterSettings, methodParametersByCustomer)};");
}
private void WriteUpdateUniqueByCustomer()
{
var methodParameters = CodeWriterUtils.GetUpdateMethodParameters(table, codeWriterSettings, true, true);
if (methodParameters == null || !methodParameters.Any())
{
return;
}
methodParameters = CodeWriterUtils.AddEntityParameter(methodParameters, table, "An entity with updated values.");
classBuilder.AppendLine($"{CodeWriterUtils.GetUpdateMethodSignature(table, codeWriterSettings, methodParameters)};");
}
private void WriteGetUnique()
{
var methodParametersUnique = CodeWriterUtils.GetGetMethodParameters(table, codeWriterSettings, false, true);
if (methodParametersUnique == null || !methodParametersUnique.Any())
{
return;
}
WriteGetCommon(methodParametersUnique, null, GetAllColumnNames(new List <DatabaseTable> {
table
}));
}
public void WriteWith(DatabaseConstraint foreignKey)
{
// TODO: refactor this method to be consistent with approach taken for other overload
var refTable = foreignKey.ReferencedTable(table.DatabaseSchema);
var dataType = refTable.NetName;
if (foreignKey.Columns.Count != foreignKey.ReferencedColumns(table.DatabaseSchema).Count())
{
throw new InvalidOperationException("Number of foreign key columns does not match number of columns referenced!");
}
classBuilder.BeginNest($"public virtual {CodeWriterUtils.GetWithMethodSignature(table, foreignKey, codeWriterSettings)}");
var methodCallParameters = new List <string>();
var propertyName = codeWriterSettings.Namer.ForeignKeyName(table, foreignKey);
foreach (var fkc in foreignKey.Columns)
{
var tc = table.Columns.Single(_tc => _tc.Name == fkc);
var parameter = $"{CodeWriterUtils.GetPropertyNameForDatabaseColumn(tc)}";
if (tc.Nullable && CodeWriterUtils.FindDataType(tc).EndsWith("?")) // KE: need the check for the "?" so that we correctly handle reference types like string
{
using (classBuilder.BeginNest($"if (!{parameter}.HasValue)"))
{
classBuilder.AppendLine($"{propertyName} = null;");
classBuilder.AppendLine("return this;");
}
classBuilder.AppendLine("");
parameter += ".Value";
}
methodCallParameters.Add(parameter);
}
var s = string.Join(", ", methodCallParameters);
var referencedColumnNames = foreignKey.ReferencedColumns(table.DatabaseSchema).ToList();
referencedColumnNames.Sort();
var referencedColumns = referencedColumnNames.Select(c => foreignKey.ReferencedTable(table.DatabaseSchema).FindColumn(c));
var methodParameters = CodeWriterUtils.GetMethodParametersForColumns(referencedColumns, codeWriterSettings);
var methodName = CodeWriterUtils.GetMethodName(methodParameters, codeWriterSettings, true, CodeWriterUtils.BaseMethodNameGet);
var fieldNameForFkTableRepository = NameFixer.ToCamelCase(CodeWriterUtils.GetRepositoryImplementationName(refTable));
classBuilder.AppendLine($"{propertyName} = _{fieldNameForFkTableRepository}.{methodName}({s});");
classBuilder.AppendLine("return this;");
classBuilder.EndNest();
classBuilder.AppendLine("");
}
private void WriteDelete(bool isLogicalDelete)
{
var methodParameters = CodeWriterUtils.GetDeleteMethodParameters(table, codeWriterSettings, false, false);
if (isLogicalDelete)
{
WriteDeleteLogical(methodParameters);
classBuilder.AppendLine("");
}
WriteDeletePhysical(methodParameters);
classBuilder.AppendLine("");
WriteDeleteCommon(methodParameters, isLogicalDelete);
}
private void WriteUpdateCommon(IEnumerable <Parameter> methodParameters, string fromClause, string whereClause, string columnsToReturn)
{
var entityParameterSummary = "An entity with updated values.";
var methodParametersWithEntity = CodeWriterUtils.AddEntityParameter(methodParameters, table, entityParameterSummary);
WriteUpdateMethodSummary(methodParametersWithEntity);
var methodSignature = CodeWriterUtils.GetUpdateMethodSignature(table, codeWriterSettings, methodParametersWithEntity);
using (classBuilder.BeginNest($"public {methodSignature}"))
{
CodeWriterUtils.WriteEntryLogging(classBuilder, methodSignature);
WriteGetPropertyColumnPairs();
classBuilder.AppendLine("var setClause = string.Join(\", \", propertyColumnPairs.Select(pcp => $\"{pcp.Value} = @{pcp.Key.Name}\"));");
var thisTableAlias = codeWriterSettings.Namer.NameToAcronym(table.Name);
if (!string.IsNullOrEmpty(fromClause))
{
classBuilder.AppendLine($"var sqlCommandText = $\"UPDATE ONLY \\\"{table.Name}\\\" AS {thisTableAlias} SET {{setClause}} FROM {fromClause} WHERE {whereClause} RETURNING {columnsToReturn};\";");
}
else
{
classBuilder.AppendLine($"var sqlCommandText = $\"UPDATE ONLY \\\"{table.Name}\\\" AS {thisTableAlias} SET {{setClause}} WHERE {whereClause} RETURNING {columnsToReturn};\";");
}
var entityVariableName = "updatedEntity";
classBuilder.AppendLine($"{table.NetName} {entityVariableName} = null;");
WriteBeginCreateConnection();
WriteBeginCreateCommand();
classBuilder.AppendLine($"command.CommandText = sqlCommandText;");
WriteAddParametersToCommand(methodParameters);
WriteAddParametersToCommand();
classBuilder.BeginNest("try");
WriteBeginExecuteReader();
WriteBeginReadReaderSingle();
// TODO: KE - consider throwing here if multiple rows were modified! It should never be the case except for bad data even though the schema allows it
classBuilder.AppendLine($"{entityVariableName} = ({table.NetName}){_serviceProviderFieldName}.GetService(typeof({table.NetName}));");
WriteParseEntityFromReader(entityVariableName);
classBuilder.EndNest();
classBuilder.EndNest();
classBuilder.EndNest();
WriteCatchPostgresExceptions();
classBuilder.EndNest();
classBuilder.EndNest();
WriteReturnEntityIfNotNull(entityVariableName);
CodeWriterUtils.WriteExitLogging(classBuilder, methodSignature);
}
classBuilder.AppendLine("");
}
private string Write()
{
CodeWriterUtils.WriteFileHeader(classBuilder);
WriteUsings();
using (classBuilder.BeginNest($"namespace {codeWriterSettings.Namespace}"))
{
using (classBuilder.BeginNest($"public static class {className}"))
{
WriteRegisterRepositories();
WriteRegisterEntities();
}
}
return(classBuilder.ToString());
}
private void WriteRegisterRepositories()
{
using (classBuilder.BeginNest($"public static IServiceCollection AddEnterpriseDataRepositories(this IServiceCollection services)"))
{
foreach (var t in schema.Tables)
{
var interfaceName = CodeWriterUtils.GetRepositoryInterfaceName(t);
var implementationName = CodeWriterUtils.GetRepositoryImplementationName(t);
classBuilder.AppendLine($"services.AddTransient<{interfaceName}, {implementationName}>();");
}
classBuilder.AppendLine("return services;");
}
classBuilder.AppendLine("");
}
private void WriteUpdateUniqueByCustomer()
{
var methodParameters = CodeWriterUtils.GetUpdateMethodParameters(table, codeWriterSettings, true, true);
if (methodParameters == null || !methodParameters.Any())
{
return;
}
var orgUnitTableAlias = codeWriterSettings.Namer.NameToAcronym(CodeWriterUtils.CustomerAssetOrganizationTableName);
var fromClause = $"\\\"{CodeWriterUtils.CustomerAssetOrganizationTableName}\\\" {orgUnitTableAlias}";
var whereClause = GetWhereClauseFromMethodParameters(methodParameters.ToList());
var thisTableAlias = codeWriterSettings.Namer.NameToAcronym(table.Name);
var joinOnClause = $"{thisTableAlias}.\\\"{CodeWriterUtils.CustomerAssetOrganizationIDColumnName}\\\" = {orgUnitTableAlias}.\\\"{CodeWriterUtils.CustomerAssetOrganizationIDColumnName}\\\"";
whereClause = $"{joinOnClause} AND {whereClause}";
WriteUpdateCommon(methodParameters, fromClause, whereClause, GetAllColumnNamesByCustomer());
}
private void WriteColumn(DatabaseColumn column, bool notNetName)
{
var propertyName = CodeWriterUtils.GetPropertyNameForDatabaseColumn(column);
var dataType = CodeWriterUtils.FindDataType(column);
if (notNetName)
{
//in EF, you want a fk Id property
//must not conflict with entity fk name
propertyName += "Id";
}
codeWriterSettings.CodeInserter.WriteColumnAnnotations(table, column, classBuilder);
dataAnnotationWriter.Write(classBuilder, column, propertyName);
var useVirtual = true;
classBuilder.AppendAutomaticProperty(dataType, propertyName, useVirtual);
}
public static IEnumerable <Parameter> GetTablesAsParameters(IEnumerable <DatabaseTable> tables)
{
var fields = new List <Parameter>();
foreach (var t in tables.Distinct().OrderBy(t => t.Name))
{
var field = new Parameter
{
ColumnNameToQueryBy = null,
DataType = CodeWriterUtils.GetRepositoryInterfaceName(t),
Name = NameFixer.ToCamelCase(CodeWriterUtils.GetRepositoryImplementationName(t))
};
fields.Add(field);
}
return(fields);
}
private void WriteDeleteUniqueByCustomer(bool isLogicalDelete)
{
var methodParameters = CodeWriterUtils.GetDeleteMethodParameters(table, codeWriterSettings, true, true);
if (methodParameters == null || !methodParameters.Any())
{
return;
}
if (isLogicalDelete)
{
WriteDeleteLogicalUniqueByCustomer(methodParameters);
classBuilder.AppendLine("");
}
WriteDeletePhysicalUniqueByCustomer(methodParameters);
classBuilder.AppendLine("");
WriteDeleteCommon(methodParameters, isLogicalDelete);
}
public void Execute()
{
foreach (var type in schema.DataTypes)
{
classBuilder = new ClassBuilder();
if (!(type is EnumeratedDataType))
{
continue;
}
var implementationText = Write(type as EnumeratedDataType);
if (string.IsNullOrEmpty(implementationText))
{
continue;
}
CodeWriterUtils.WriteClassFile(codeWriterSettings.OutputDirectory, type.NetDataType, implementationText);
}
}
private string Write()
{
if (string.IsNullOrEmpty(table.NetName) && table.DatabaseSchema != null)
{
PrepareSchemaNames.Prepare(table.DatabaseSchema, codeWriterSettings.Namer);
}
CodeWriterUtils.WriteFileHeader(classBuilder);
WriteUsings();
CodeWriterUtils.BeginNestNamespace(classBuilder, codeWriterSettings);
var tableOrView = table is DatabaseView ? "view" : "table";
var comment = $"Interface providing repository CRUD operations for the {table.Name} {tableOrView}";
var interfaceDefinition = $"public partial interface {CodeWriterUtils.GetRepositoryInterfaceName(table)}";
classBuilder.AppendXmlSummary(comment);
classBuilder.BeginNest(interfaceDefinition);
WriteInterfaceMembers();
classBuilder.EndNest(); // interface
classBuilder.EndNest(); // namespace
return(classBuilder.ToString());
}
