public static int Main([NotNull] string[] args)
{
ConsoleCommandLogger.IsVerbose = HandleVerboseOption(ref args);
HandleDebugSwitch(ref args);
try
{
return(ExecuteCommand.Create(ref args).Execute(args));
}
catch (Exception ex)
{
// TODO ensure always a json response if --json is supplied
if (ex is TargetInvocationException)
{
ex = ex.InnerException;
}
if (!(ex is OperationException))
{
ConsoleCommandLogger.Error(ex.ToString());
}
ConsoleCommandLogger.Error(ex.Message.Bold().Red());
return(1);
}
}
private static int Execute(CommonOptions commonOptions,
string from,
string to,
string output,
bool idempotent,
string context,
string environment)
{
var sql = new OperationExecutor(commonOptions, environment)
.ScriptMigration(from, to, idempotent, context);
if (string.IsNullOrEmpty(output))
{
ConsoleCommandLogger.Output(sql);
}
else
{
ConsoleCommandLogger.Verbose("Writing SQL script to '" + output + "'".Bold().Black());
File.WriteAllText(output, sql, Encoding.UTF8);
ConsoleCommandLogger.Output("Done");
}
return(0);
}
private static async Task <int> ExecuteAsync(CommonOptions commonOptions,
string connection,
string provider,
bool dataAnnotations,
string context,
bool force,
string outputDir,
IEnumerable <string> schemas,
IEnumerable <string> tables,
string environment)
{
await new OperationExecutor(commonOptions, environment)
.ReverseEngineerAsync(
provider,
connection,
outputDir,
context,
schemas,
tables,
dataAnnotations,
force);
ConsoleCommandLogger.Output("Done");
return(0);
}
private static void EnsureValidDispatchRecipient(ref string[] args)
{
if (!args.Contains(DispatcherVersionArgumentName, StringComparer.OrdinalIgnoreCase))
{
return;
}
var dispatcherArgumentIndex = Array.FindIndex(
args,
(value) => string.Equals(value, DispatcherVersionArgumentName, StringComparison.OrdinalIgnoreCase));
var dispatcherArgumentValueIndex = dispatcherArgumentIndex + 1;
if (dispatcherArgumentValueIndex < args.Length)
{
var dispatcherVersion = args[dispatcherArgumentValueIndex];
if (string.Equals(dispatcherVersion, GetVersion(), StringComparison.Ordinal))
{
// Remove dispatcher arguments from
var preDispatcherArgument = args.Take(dispatcherArgumentIndex);
var postDispatcherArgument = args.Skip(dispatcherArgumentIndex + 2);
var newProgramArguments = preDispatcherArgument.Concat(postDispatcherArgument);
args = newProgramArguments.ToArray();
return;
}
ConsoleCommandLogger.Verbose("Expected dispatch version " + GetVersion() + " but received " + dispatcherVersion);
}
// Could not validate the dispatcher version.
throw new OperationException(
"Could not invoke command. Ensure project.json has matching versions of 'Microsoft.EntityFrameworkCore.Design' in the 'dependencies' section and 'Microsoft.EntityFrameworkCore.Tools' in the 'tools' section.");
}
private static void ReportJson(MigrationFiles files)
{
var sb = new StringBuilder();
sb.AppendLine("//BEGIN");
sb.AppendLine("{");
sb.AppendLine(" \"MigrationFile\": \"" + SerializePath(files.MigrationFile) + "\",");
sb.AppendLine(" \"MetadataFile\": \"" + SerializePath(files.MetadataFile) + "\",");
sb.AppendLine(" \"SnapshotFile\": \"" + SerializePath(files.SnapshotFile) + "\"");
sb.AppendLine("}");
sb.AppendLine("//END");
ConsoleCommandLogger.Output(sb.ToString());
}
private static void ReportResults(IEnumerable <MigrationInfo> migrations)
{
var any = false;
foreach (var migration in migrations)
{
ConsoleCommandLogger.Output(migration.Id as string);
any = true;
}
if (!any)
{
ConsoleCommandLogger.Error("No migrations were found");
}
}
private static void ReportJsonResults(IEnumerable <MigrationInfo> migrations)
{
var nameGroups = migrations.GroupBy(m => m.Name).ToList();
var output = migrations.Select(
m => new
{
id = m.Id,
name = m.Name,
safeName = nameGroups.Count(g => g.Key == m.Name) == 1
? m.Name
: m.Id
}).ToArray();
ConsoleCommandLogger.Json(output);
}
private static void ReportResults(IEnumerable <Type> contextTypes)
{
var any = false;
foreach (var contextType in contextTypes)
{
ConsoleCommandLogger.Output(contextType.FullName as string);
any = true;
}
if (!any)
{
ConsoleCommandLogger.Error("No DbContext was found");
}
}
private static int Execute(CommonOptions commonOptions,
string name,
string outputDir,
string context,
string environment,
Action <MigrationFiles> reporter)
{
var files = new OperationExecutor(commonOptions, environment)
.AddMigration(name, outputDir, context);
reporter?.Invoke(files);
ConsoleCommandLogger.Output("Done. To undo this action, use 'dotnet ef migrations remove'");
return(0);
}
private static void WriteLogo()
{
const string Bold = "\x1b[1m";
const string Normal = "\x1b[22m";
const string Magenta = "\x1b[35m";
const string White = "\x1b[37m";
const string Default = "\x1b[39m";
ConsoleCommandLogger.Output("");
ConsoleCommandLogger.Output(@" _/\__ ".Insert(21, Bold + White));
ConsoleCommandLogger.Output(@" ---==/ \\ ".Insert(20, Bold + White));
ConsoleCommandLogger.Output(@" ___ ___ |. \|\ ".Insert(26, Bold).Insert(21, Normal).Insert(20, Bold + White).Insert(9, Normal + Magenta));
ConsoleCommandLogger.Output(@" | __|| __| | ) \\\ ".Insert(20, Bold + White).Insert(8, Normal + Magenta));
ConsoleCommandLogger.Output(@" | _| | _| \_/ | //|\\ ".Insert(20, Bold + White).Insert(8, Normal + Magenta));
ConsoleCommandLogger.Output(@" |___||_| / \\\/\\".Insert(33, Normal + Default).Insert(23, Bold + White).Insert(8, Normal + Magenta));
ConsoleCommandLogger.Output("");
}
private static void ReportJsonResults(IEnumerable <Type> contextTypes)
{
var nameGroups = contextTypes.GroupBy(t => t.Name).ToList();
var fullNameGroups = contextTypes.GroupBy(t => t.FullName).ToList();
var output = new StringBuilder();
output.AppendLine("//BEGIN");
output.Append("[");
var first = true;
foreach (var contextType in contextTypes)
{
if (first)
{
first = false;
}
else
{
output.Append(",");
}
var safeName = nameGroups.Count(g => g.Key == contextType.Name) == 1
? contextType.Name
: fullNameGroups.Count(g => g.Key == contextType.FullName) == 1
? contextType.FullName
: contextType.AssemblyQualifiedName;
output.AppendLine();
output.AppendLine(" {");
output.AppendLine(" \"fullName\": \"" + contextType.FullName + "\",");
output.AppendLine(" \"safeName\": \"" + safeName + "\",");
output.AppendLine(" \"name\": \"" + contextType.Name + "\",");
output.AppendLine(" \"assemblyQualifiedName\": \"" + contextType.AssemblyQualifiedName + "\"");
output.AppendLine(" }");
}
output.AppendLine();
output.AppendLine("]");
output.AppendLine("//END");
ConsoleCommandLogger.Output(output.ToString());
}
public static void Configure([NotNull] CommandLineApplication command, [NotNull] CommonCommandOptions commonOptions)
{
command.Description = "Add a new migration";
var name = command.Argument("[name]", "The name of the migration");
var outputDir = command.Option(
"-o|--output-dir <path>",
"The directory (and sub-namespace) to use. If omitted, \"Migrations\" is used. Relative paths are relative the directory in which the command is executed.");
var context = command.Option(
"-c|--context <context>",
"The DbContext to use. If omitted, the default DbContext is used");
var environment = command.Option(
"-e|--environment <environment>",
"The environment to use. If omitted, \"Development\" is used.");
var json = command.JsonOption();
command.HelpOption();
command.VerboseOption();
command.OnExecute(
() =>
{
if (string.IsNullOrEmpty(name.Value))
{
ConsoleCommandLogger.Error(("Missing required argument '" + name.Name + "'").Bold().Red());
command.ShowHelp();
return(1);
}
return(Execute(commonOptions.Value(),
name.Value,
outputDir.Value(),
context.Value(),
environment.Value(),
json.HasValue()
? (Action <MigrationFiles>)ReportJson
: null));
});
}
private static void ReportJsonResults(IEnumerable <MigrationInfo> migrations)
{
var nameGroups = migrations.GroupBy(m => m.Name).ToList();
var output = new StringBuilder();
output.AppendLine("//BEGIN");
output.Append("[");
var first = true;
foreach (var m in migrations)
{
if (first)
{
first = false;
}
else
{
output.Append(",");
}
var safeName = nameGroups.Count(g => g.Key == m.Name) == 1
? m.Name
: m.Id;
output.AppendLine();
output.AppendLine(" {");
output.AppendLine(" \"id\": \"" + m.Id + "\",");
output.AppendLine(" \"name\": \"" + m.Name + "\",");
output.AppendLine(" \"safeName\": \"" + safeName + "\"");
output.Append(" }");
}
output.AppendLine();
output.AppendLine("]");
output.AppendLine("//END");
ConsoleCommandLogger.Output(output.ToString());
}
private static int Execute(CommonOptions commonOptions,
string context,
string environment,
bool isForced)
{
new OperationExecutor(commonOptions, environment)
.DropDatabase(
context,
(database, dataSource) =>
{
if (isForced)
{
return(true);
}
ConsoleCommandLogger.Output(
$"Are you sure you want to drop the database '{database}' on server '{dataSource}'? (y/N)");
var readedKey = Console.ReadKey().KeyChar;
return((readedKey == 'y') || (readedKey == 'Y'));
});
return(0);
}
public static void Configure([NotNull] CommandLineApplication command, [NotNull] CommonCommandOptions commonOptions)
{
command.Description = "Scaffolds a DbContext and entity type classes for a specified database";
var connection = command.Argument(
"[connection]",
"The connection string of the database");
var provider = command.Argument(
"[provider]",
"The provider to use. For example, Microsoft.EntityFrameworkCore.SqlServer");
var dataAnnotations = command.Option(
"-a|--data-annotations",
"Use DataAnnotation attributes to configure the model where possible. If omitted, the output code will use only the fluent API.",
CommandOptionType.NoValue);
var context = command.Option(
"-c|--context <name>",
"Name of the generated DbContext class.");
var force = command.Option(
"-f|--force",
"Force scaffolding to overwrite existing files. Otherwise, the code will only proceed if no output files would be overwritten.",
CommandOptionType.NoValue);
var outputDir = command.Option(
"-o|--output-dir <path>",
"Directory of the project where the classes should be output. If omitted, the top-level project directory is used.");
var schemas = command.Option(
"--schema <schema>",
"Selects a schema for which to generate classes.",
CommandOptionType.MultipleValue);
var tables = command.Option(
"-t|--table <schema.table>",
"Selects a table for which to generate classes.",
CommandOptionType.MultipleValue);
var environment = command.Option(
"-e|--environment <environment>",
"The environment to use. If omitted, \"Development\" is used.");
command.HelpOption();
command.VerboseOption();
command.OnExecute(
() =>
{
if (string.IsNullOrEmpty(connection.Value))
{
ConsoleCommandLogger.Error(("Missing required argument '" + connection.Name + "'").Bold().Red());
command.ShowHelp();
return(Task.FromResult(1));
}
if (string.IsNullOrEmpty(provider.Value))
{
ConsoleCommandLogger.Error(("Missing required argument '" + provider.Name + "'").Bold().Red());
command.ShowHelp();
return(Task.FromResult(1));
}
return(ExecuteAsync(commonOptions.Value(),
connection.Value,
provider.Value,
dataAnnotations.HasValue(),
context.Value(),
force.HasValue(),
outputDir.Value(),
schemas.Values,
tables.Values,
environment.Value()));
});
}
private static void ReportJsonResults(IEnumerable <Type> contextTypes)
{
var typeNames = contextTypes.Select(t => new { fullName = t.FullName }).ToArray();
ConsoleCommandLogger.Json(typeNames);
}
private static void ReportJson(MigrationFiles files) => ConsoleCommandLogger.Json(files);