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()); }