public List <string> GetProcedures(int dbTypeInt)
{
var result = new List <string>();
DatabaseType databaseType = (DatabaseType)dbTypeInt;
if (databaseType != DatabaseType.SQLServer)
{
return(result);
}
var procedureModelFactory = serviceProvider.GetService <IProcedureModelFactory>();
var procedureModelOptions = new ProcedureModelFactoryOptions
{
FullModel = false,
Procedures = new List <string>(),
};
var procedureModel = procedureModelFactory.Create(_connectionString, procedureModelOptions);
foreach (var procedure in procedureModel.Procedures)
{
result.Add($"[{procedure.Schema}].[{procedure.Name}]");
}
result.Sort();
return(result);
}
private ProcedureModel GetStoredProcedures(string dacpacPath, ProcedureModelFactoryOptions options)
{
var result = new List <RevEng.Core.Abstractions.Metadata.Procedure>();
var errors = new List <string>();
if (options.FullModel && !options.Procedures.Any())
{
return(new ProcedureModel
{
Procedures = result,
Errors = errors,
});
}
var consolidator = new DacpacConsolidator();
dacpacPath = consolidator.Consolidate(dacpacPath);
var model = new TSqlTypedModel(dacpacPath);
var procedures = model.GetObjects <TSqlProcedure>(DacQueryScopes.UserDefined)
.ToList();
var filter = new HashSet <string>(options.Procedures);
foreach (var proc in procedures)
{
var procedure = new RevEng.Core.Abstractions.Metadata.Procedure
{
Schema = proc.Name.Parts[0],
Name = proc.Name.Parts[1],
};
if (filter.Count == 0 || filter.Contains($"[{procedure.Schema}].[{procedure.Name}]"))
{
if (options.FullModel)
{
procedure.Parameters = GetStoredProcedureParameters(proc);
try
{
procedure.ResultElements = GetStoredProcedureResultElements(proc);
}
catch (Exception ex)
{
errors.Add($"Unable to get result set shape for {procedure.Schema}.{procedure.Name}" + Environment.NewLine + ex.Message);
_logger?.Logger.LogWarning(ex, $"Unable to get result set shape for {procedure.Schema}.{procedure.Name}" + Environment.NewLine + ex.Message);
}
}
result.Add(procedure);
}
}
return(new ProcedureModel
{
Procedures = result,
Errors = errors,
});
}
public List <TableModel> GetProcedures()
{
var result = new List <TableModel>();
if (_databaseType != DatabaseType.SQLServer && _databaseType != DatabaseType.SQLServerDacpac)
{
return(result);
}
var procedureModelFactory = serviceProvider.GetService <IProcedureModelFactory>();
var procedureModelOptions = new ProcedureModelFactoryOptions
{
FullModel = false,
Procedures = new List <string>(),
};
var procedureModel = procedureModelFactory.Create(_connectionString, procedureModelOptions);
foreach (var procedure in procedureModel.Procedures)
{
result.Add(new TableModel(procedure.Name, procedure.Schema, _databaseType, ObjectType.Procedure, null));
}
return(result.OrderBy(c => c.DisplayName).ToList());
}
public ProcedureModel Create(string connectionString, ProcedureModelFactoryOptions options)
{
//TODO Filter based on options later
var model = new ProcedureModel
{
Procedures = GetStoredProcedures(connectionString)
};
return(model);
}
public ProcedureModel Create(string dacpacPath, ProcedureModelFactoryOptions options)
{
if (string.IsNullOrEmpty(dacpacPath))
{
throw new ArgumentException(@"invalid path", nameof(dacpacPath));
}
if (!File.Exists(dacpacPath))
{
throw new ArgumentException($"Dacpac file not found: {dacpacPath}");
}
return(GetStoredProcedures(dacpacPath, options));
}
public ReverseEngineerResult GenerateFiles(ReverseEngineerCommandOptions reverseEngineerOptions)
{
var errors = new List<string>();
var warnings = new List<string>();
var reporter = new OperationReporter(
new OperationReportHandler(
m => errors.Add(m),
m => warnings.Add(m)));
var serviceProvider = ServiceProviderBuilder.Build(reverseEngineerOptions);
var scaffolder = serviceProvider.GetService<IReverseEngineerScaffolder>();
var schemas = new List<string>();
if (reverseEngineerOptions.DefaultDacpacSchema != null)
{
schemas.Add(reverseEngineerOptions.DefaultDacpacSchema);
}
if (reverseEngineerOptions.FilterSchemas)
{
schemas.AddRange(reverseEngineerOptions.Schemas.Select(s => s.Name));
}
var outputDir = !string.IsNullOrEmpty(reverseEngineerOptions.OutputPath)
? Path.IsPathFullyQualified(reverseEngineerOptions.OutputPath)
? reverseEngineerOptions.OutputPath
: Path.GetFullPath(Path.Combine(reverseEngineerOptions.ProjectPath, reverseEngineerOptions.OutputPath))
: reverseEngineerOptions.ProjectPath;
var outputContextDir = !string.IsNullOrEmpty(reverseEngineerOptions.OutputContextPath)
? Path.IsPathFullyQualified(reverseEngineerOptions.OutputContextPath)
? reverseEngineerOptions.OutputContextPath
: Path.GetFullPath(Path.Combine(reverseEngineerOptions.ProjectPath, reverseEngineerOptions.OutputContextPath))
: outputDir;
var modelNamespace = !string.IsNullOrEmpty(reverseEngineerOptions.ModelNamespace)
? reverseEngineerOptions.ProjectRootNamespace + "." + reverseEngineerOptions.ModelNamespace
: PathHelper.GetNamespaceFromOutputPath(outputDir, reverseEngineerOptions.ProjectPath, reverseEngineerOptions.ProjectRootNamespace);
var contextNamespace = !string.IsNullOrEmpty(reverseEngineerOptions.ContextNamespace)
? reverseEngineerOptions.ProjectRootNamespace + "." + reverseEngineerOptions.ContextNamespace
: PathHelper.GetNamespaceFromOutputPath(outputContextDir, reverseEngineerOptions.ProjectPath, reverseEngineerOptions.ProjectRootNamespace);
SavedModelFiles procedurePaths = null;
var procedureModelScaffolder = serviceProvider.GetService<IProcedureScaffolder>();
if (procedureModelScaffolder != null
&& reverseEngineerOptions.Tables.Where(t => t.ObjectType == RevEng.Shared.ObjectType.Procedure).Count() > 0)
{
var procedureOptions = new ProcedureScaffolderOptions
{
ContextDir = outputContextDir,
ContextName = reverseEngineerOptions.ContextClassName,
ContextNamespace = contextNamespace,
ModelNamespace = modelNamespace,
};
var procedureModelOptions = new ProcedureModelFactoryOptions
{
FullModel = true,
Procedures = reverseEngineerOptions.Tables.Where(t => t.ObjectType == RevEng.Shared.ObjectType.Procedure).Select(m => m.Name),
};
var procedureModel = procedureModelScaffolder.ScaffoldModel(reverseEngineerOptions.ConnectionString, procedureOptions, procedureModelOptions, ref errors);
if (procedureModel != null)
{
procedurePaths = procedureModelScaffolder.Save(
procedureModel,
Path.GetFullPath(Path.Combine(reverseEngineerOptions.ProjectPath, reverseEngineerOptions.OutputPath ?? string.Empty)),
contextNamespace);
}
}
var modelOptions = new ModelReverseEngineerOptions
{
UseDatabaseNames = reverseEngineerOptions.UseDatabaseNames,
#if CORE50
NoPluralize = !reverseEngineerOptions.UseInflector,
#endif
};
var codeOptions = new ModelCodeGenerationOptions
{
UseDataAnnotations = !reverseEngineerOptions.UseFluentApiOnly,
Language = "C#",
ContextName = reverseEngineerOptions.ContextClassName,
ContextDir = outputContextDir,
RootNamespace = null,
ContextNamespace = contextNamespace,
ModelNamespace = modelNamespace,
SuppressConnectionStringWarning = false,
ConnectionString = reverseEngineerOptions.ConnectionString,
#if CORE50
SuppressOnConfiguring = !reverseEngineerOptions.IncludeConnectionString,
#endif
};
var dbOptions = new DatabaseModelFactoryOptions(reverseEngineerOptions.Tables.Where(t => t.ObjectType.HasColumns()).Select(m => m.Name), schemas);
var scaffoldedModel = scaffolder.ScaffoldModel(
reverseEngineerOptions.Dacpac ?? reverseEngineerOptions.ConnectionString,
dbOptions,
modelOptions,
codeOptions);
var filePaths = scaffolder.Save(
scaffoldedModel,
Path.GetFullPath(Path.Combine(reverseEngineerOptions.ProjectPath, reverseEngineerOptions.OutputPath ?? string.Empty)),
overwriteFiles: true);
#if CORE50
#else
RemoveOnConfiguring(filePaths.ContextFile, reverseEngineerOptions.IncludeConnectionString);
#endif
foreach (var file in filePaths.AdditionalFiles)
{
PostProcess(file);
}
PostProcess(filePaths.ContextFile);
var entityTypeConfigurationPaths = SplitDbContext(filePaths.ContextFile, reverseEngineerOptions.UseDbContextSplitting, contextNamespace);
var cleanUpPaths = new SavedModelFiles(filePaths.ContextFile, filePaths.AdditionalFiles);
if (procedurePaths != null)
{
cleanUpPaths.AdditionalFiles.Add(procedurePaths.ContextFile);
foreach (var additionalFile in procedurePaths.AdditionalFiles)
{
cleanUpPaths.AdditionalFiles.Add(additionalFile);
}
}
CleanUp(cleanUpPaths, entityTypeConfigurationPaths);
var result = new ReverseEngineerResult
{
EntityErrors = errors,
EntityWarnings = warnings,
EntityTypeFilePaths = filePaths.AdditionalFiles,
ContextFilePath = filePaths.ContextFile,
ContextConfigurationFilePaths = entityTypeConfigurationPaths,
};
return result;
}
public ScaffoldedModel ScaffoldModel(string connectionString, ProcedureScaffolderOptions procedureScaffolderOptions, ProcedureModelFactoryOptions procedureModelFactoryOptions, ref List <string> errors)
{
var result = new ScaffoldedModel();
var model = procedureModelFactory.Create(connectionString, procedureModelFactoryOptions);
errors = model.Errors;
foreach (var procedure in model.Procedures)
{
var name = GenerateIdentifierName(procedure, model) + "Result";
var classContent = WriteResultClass(procedure, procedureScaffolderOptions.ModelNamespace, name);
result.AdditionalFiles.Add(new ScaffoldedFile
{
Code = classContent,
Path = $"{name}.cs",
});
}
var dbContext = WriteProcedureDbContext(procedureScaffolderOptions, model);
result.ContextFile = new ScaffoldedFile
{
Code = dbContext,
Path = Path.GetFullPath(Path.Combine(procedureScaffolderOptions.ContextDir, procedureScaffolderOptions.ContextName + "Procedures.cs")),
};
return(result);
}
private ProcedureModel GetStoredProcedures(string connectionString, ProcedureModelFactoryOptions options)
{
var dtResult = new DataTable();
var result = new List <Procedure>();
var errors = new List <string>();
if (options.FullModel && !options.Procedures.Any())
{
return(new ProcedureModel
{
Procedures = result,
Errors = errors,
});
}
using (var connection = new SqlConnection(connectionString))
{
string sql = $@"
SELECT * FROM INFORMATION_SCHEMA.ROUTINES
WHERE ROUTINE_TYPE = 'PROCEDURE'
ORDER BY ROUTINE_NAME";
connection.Open();
var adapter = new SqlDataAdapter
{
SelectCommand = new SqlCommand(sql, connection)
};
adapter.Fill(dtResult);
var filter = options.Procedures.ToHashSet();
foreach (DataRow row in dtResult.Rows)
{
try
{
var procedure = new Procedure
{
Schema = row["ROUTINE_SCHEMA"].ToString(),
Name = row["ROUTINE_NAME"].ToString()
};
if (filter.Count == 0 || filter.Contains($"[{procedure.Schema}].[{procedure.Name}]"))
{
if (options.FullModel)
{
procedure.Parameters = GetStoredProcedureParameters(connection, procedure.Schema, procedure.Name);
procedure.ResultElements = GetStoredProcedureResultElements(connection, procedure.Schema, procedure.Name);
}
result.Add(procedure);
}
}
catch (Exception ex)
{
errors.Add($"Unable to scaffold {row["ROUTINE_NAME"]}" + Environment.NewLine + ex.Message);
_logger?.Logger.LogWarning(ex, $"Unable to scaffold {row["ROUTINE_NAME"]}");
}
}
}
return(new ProcedureModel
{
Procedures = result,
Errors = errors,
});
}
public ProcedureModel Create(string connectionString, ProcedureModelFactoryOptions options)
{
return(GetStoredProcedures(connectionString, options));
}
private ProcedureModel GetStoredProcedures(string connectionString, ProcedureModelFactoryOptions options)
{
var result = new List <Procedure>();
var found = new List <Tuple <string, string> >();
var errors = new List <string>();
if (options.FullModel && !options.Procedures.Any())
{
return(new ProcedureModel
{
Procedures = result,
Errors = errors,
});
}
var filter = options.Procedures.ToHashSet();
using (var connection = new SqlConnection(connectionString))
{
var sql = $@"
SELECT ROUTINE_SCHEMA, ROUTINE_NAME FROM INFORMATION_SCHEMA.ROUTINES
WHERE ROUTINE_TYPE = 'PROCEDURE'
ORDER BY ROUTINE_NAME;";
using (var command = new SqlCommand(sql, connection))
{
connection.Open();
using (var reader = command.ExecuteReader())
{
while (reader.Read())
{
found.Add(new Tuple <string, string>(reader.GetString(0), reader.GetString(1)));
}
}
}
foreach (var foundProcedure in found)
{
if (filter.Count == 0 || filter.Contains($"[{foundProcedure.Item1}].[{foundProcedure.Item2}]"))
{
var procedure = new Procedure
{
Schema = foundProcedure.Item1,
Name = foundProcedure.Item2,
HasValidResultSet = true,
};
if (options.FullModel)
{
procedure.Parameters = GetStoredProcedureParameters(connection, procedure.Schema, procedure.Name);
try
{
procedure.ResultElements = GetStoredProcedureResultElements(connection, procedure.Schema, procedure.Name);
}
catch (Exception ex)
{
procedure.HasValidResultSet = false;
errors.Add($"Unable to get result set shape for {procedure.Schema}.{procedure.Name}" + Environment.NewLine + ex.Message);
_logger?.Logger.LogWarning(ex, $"Unable to scaffold {procedure.Schema}.{procedure.Name}");
}
}
result.Add(procedure);
}
}
}
return(new ProcedureModel
{
Procedures = result,
Errors = errors,
});
}
