internal static void Run <TConfiguration, TTemplate, TGenerator>(string[] args, bool fromCli, Action <List <CommandLineApplication> > subCommands)
where TConfiguration : class, new()
where TTemplate : TConfiguration, new()
where TGenerator : GenymanGenerator <TConfiguration>, new()
{
// setup default generate command
var generateCommand = new GenerateCommand <TConfiguration, TGenerator>(fromCli);
generateCommand.Conventions.UseDefaultConventions();
var newCommand = new NewCommand <TConfiguration, TTemplate>(fromCli);
generateCommand.Commands.Add(newCommand);
var docCommand = new DocCommand <TConfiguration, TTemplate>(fromCli);
generateCommand.Commands.Add(docCommand);
subCommands?.Invoke(generateCommand.Commands);
try
{
generateCommand.Execute(args);
}
catch (CommandParsingException e)
{
Log.Debug(e.ToString());
generateCommand.ShowHelp();
}
catch (Exception e)
{
Log.Debug(e.ToString());
Log.Fatal($"Fatal error; something went wrong. Run again with --diagnostic for full details.");
}
}
public void GetConfiguration(Site site)
{
SiteCopy = new EditableSite(site);
//Defaults
Password = SiteCopy.Password;
//foreach (var item in Includes)
foreach (var item in SiteCopy.CharacterConfig)
{
item.PropertyChanged +=
delegate { GenerateCommand.RaiseCanExecuteChanged(); };
if (item.Label == "Symbols" &&
SiteCopy != null &&
SiteCopy.AllowedSymbols == "")
{
//clicking symbols checkbox when there are no allowed symbols will navigate
//user to the PasswordSymbolsView
item.PropertyChanged +=
delegate { if (SiteCopy.AllowedSymbols == "")
{
OnAdvanced(SiteCopy, SiteToChange);
}
};
//uncheck symbols if it's empty
if (SiteCopy != null || SiteCopy.AllowedSymbols == "")
{
item.IsEnabled = false;
}
}
}
}
public void RegistersExpectedCommands(string fullyQualifedCommandName)
{
var app = new GenerateCommand();
var abiCommand = app.Commands.FirstOrDefault(c => c.ToString() == fullyQualifedCommandName);
Assert.NotNull(abiCommand);
}
private void CreateTable(GenerateCommand command)
{
var tables = _tableRepository.GetAll();
var tableNames = command.AllTables ? tables.Select(t => t.Name).ToList() : TableHelper.ParseTableNames(command.TableNames);
foreach (var tableName in tableNames)
{
var table = tables.First(f => f.Name == tableName);
var columns = _tableRepository.GetColumns(tableName);
var builder = new CreateTableChangeSetBuilder(table, columns);
var changeSetCommand = new ChangeSetCommand(command.Author);
var changeSet = builder.Build(changeSetCommand);
var xml = changeSet.ToXml();
var path = Path.Combine(command.DirectoryPath, $"{ChangeSetCommand.Sequence:000}.{tableName.ToLower()}.create.xml");
FileHelper.Write(path, xml);
ChangeSetCommand.Next();
foreach (var column in columns.Where(w => w.AutoIncrement))
{
CreateSequence(command, changeSetCommand, table, column);
}
var foreignKeys = _tableRepository.GetForeignKeys(tableName);
foreach (var foreignKey in foreignKeys)
{
AddForeignKeyConstraint(command, changeSetCommand, table, foreignKey);
}
}
}
public void AreaMap_Clash_Double_Controller()
{
/// Currently unhandled, although why would you have a controller called "{X}Area" if you already have a "{X}" area?
/// This will cause a duplicate property/field on the MVC class, with an area shortcut MVC.UserArea and a controller shortcut MVC.UserArea
var controllers = new[]
{
new ControllerDefinition {
Name = "Home", Area = "Admin"
},
new ControllerDefinition {
Name = "Home", Area = "User"
},
new ControllerDefinition {
Name = "Home", Area = ""
},
new ControllerDefinition {
Name = "User", Area = ""
},
new ControllerDefinition {
Name = "UserArea", Area = ""
},
};
var command = new GenerateCommand(null, null, null, new Settings());
var areaMap = command.GenerateAreaMap(controllers);
Assert.Collection(areaMap,
k => { Assert.Equal("Admin", k.Key); Assert.Equal("Admin", k.Value); },
k => { Assert.Equal("User", k.Key); Assert.Equal("UserArea", k.Value); });
}
static int Main(string[] args)
{
Log.Logger = new LoggerConfiguration()
.WriteTo.Console(standardErrorFromLevel: LogEventLevel.Verbose)
.CreateLogger();
var rootCommand = new RootCommand
{
ServeCommand.Create(),
GenerateCommand.Create()
};
rootCommand.Name = "youtube-archiver-server";
rootCommand.Description = "YouTube Archiver Server";
try
{
return(rootCommand.InvokeAsync(args).Result);
}
catch (Exception ex)
{
Log.Logger.Error(ex, ex.Message);
return(1);
}
}
public void AreaMap_Clash()
{
var controllers = new[]
{
new ControllerDefinition {
Name = "Home", Area = "Admin"
},
new ControllerDefinition {
Name = "Home", Area = "User"
},
new ControllerDefinition {
Name = "Home", Area = ""
},
new ControllerDefinition {
Name = "User", Area = ""
},
};
var command = new GenerateCommand(null, null, null, new Settings());
var areaMap = command.GenerateAreaMap(controllers);
Assert.Collection(areaMap,
k => { Assert.Equal("Admin", k.Key); Assert.Equal("Admin", k.Value); },
k => { Assert.Equal("User", k.Key); Assert.Equal("UserArea", k.Value); });
}
public void When_Using_All_Available_Options(string[] args, ExitCode exitCode)
{
var directoryWrapper = new Mock <IDirectory>();
var fileWrapper = new Mock <IFile>();
var metadataReader = new Mock <IMetadataReader>();
var transformer = new Mock <ITransformer>();
fileWrapper.Setup(file => file.Exists(
It.IsAny <string>())).Returns(true);
directoryWrapper.Setup(dir => dir.Exists(
It.IsAny <string>())).Returns(true);
var entityNames = new List <string> {
"entity1"
};
metadataReader.Setup(reader => reader.ReadNames(It.IsAny <string>())).Returns(entityNames);
var command = new GenerateCommand(
args.ToList(),
transformer.Object,
metadataReader.Object,
directoryWrapper.Object,
fileWrapper.Object,
new OutputWriter());
var result = command.Execute();
Assert.True(result == exitCode);
}
public Sql GenCommand([FromBody] TwoTable tabs)
{
Console.WriteLine(tabs.type);
Sql sql = new Sql();
GenerateCommand gc = new GenerateCommand(tabs.source, tabs.dest);
if (tabs.type == "ins")
{
sql.query = gc.CreateCommand(SqlCommand.Insert);
return(sql);
}
else if (tabs.type == "merge")
{
sql.query = gc.createMerge();
return(sql);
}
else if (tabs.type == "update")
{
sql.query = gc.UpdateStm();
return(sql);
}
else if (tabs.type == "select")
{
sql.query = gc.CreateCommand(SqlCommand.Select);
return(sql);
}
else
{
sql.query = "something went wrong";
return(sql);
}
}
public static string Parse(List <string> args)
{
try
{
string result;
var command = args.First();
if (command == Statics.Commands.Help)
{
var helpCommand = new HelpCommand();
var numberOfArgs = helpCommand.GetNumberOfArgs();
if (numberOfArgs == args.Count - 1)
{
result = helpCommand.Execute(new List <string>());
}
else
{
throw new Exception("Command not recognized. Please use 'WixXmlGenerator -help' to see command the usages.");
}
}
else if (command == Statics.Commands.Version)
{
var versionCommand = new VersionCommand();
var numberOfArgs = versionCommand.GetNumberOfArgs();
if (numberOfArgs == args.Count - 1)
{
result = versionCommand.Execute(new List <string>());
}
else
{
throw new Exception("Command not recognized. Please use 'WixXmlGenerator -help' to see command the usages.");
}
}
else if (command == Statics.Commands.Generate)
{
var generateCommand = new GenerateCommand();
var numberOfArgs = generateCommand.GetNumberOfArgs();
if (numberOfArgs == args.Count - 1)
{
result = generateCommand.Execute(args);
}
else
{
throw new Exception("Command not recognized. Please use 'WixXmlGenerator -help' to see command the usages.");
}
}
else
{
throw new Exception("Command not recognized. Please use 'WixXmlGenerator -help' to see command the usages.");
}
return(result);
}
catch (Exception e)
{
throw e;
}
}
public void Generate(GenerateCommand command)
{
_validator.ValidateAndThrow(command);
ChangeSetCommand.Restart();
CreateTable(command);
}
private static async Task <int> RunGenerateAndReturnExitCode(GenerateOptions opts)
{
var repo = GetCorrectRepository(opts);
var cmd = new GenerateCommand(opts, repo, new FileSystem());
var result = await cmd.RunAsync();
return(!result ? 1 : 0);
}
public GeneratorViewModel()
{
this.generator = new PageObjectGenerator(DataManager.ReadTemplate());
this.LoadData();
this.GenerateCommand = new Command(this.OnGenerate, this.CanGenerate);
GenerateCommand.RaiseCanExecuteChanged();
this.CopyToClipBoardCommand = new Command(this.OnCopyToClipboard, this.CanCopyToClipBoard);
}
public void GenerateValidator_failed_if_gencontext_is_not_initialized()
{
GenContext.ToolBox = null;
var command = new GenerateCommand();
_validator
.ShouldHaveValidationErrorFor(t => GenContext.ToolBox, command)
.WithErrorMessage(StringRes.BadReqNotSynced);
}
protected override async Task InitializeAsync(CancellationToken cancellationToken, IProgress <ServiceProgressData> progress)
{
await JoinableTaskFactory.SwitchToMainThreadAsync();
await Logger.InitializeAsync(this, "WebP Generator").ConfigureAwait(true);
await GenerateCommand.InitializeAsync(this).ConfigureAwait(true);
OptionsPage = (OptionsPageGrid)GetDialogPage(typeof(OptionsPageGrid));
}
private static void AddForeignKeyConstraint(GenerateCommand command, ChangeSetCommand changeSetCommand, Table table, ForeignKey foreignKey)
{
var builder = new AddForeignKeyConstraintChangeSetBuilder(foreignKey);
var changeSet = builder.Build(changeSetCommand);
var xml = changeSet.ToXml();
var path = Path.Combine(command.DirectoryPath, $"{ChangeSetCommand.Sequence:000}.{table.Name.ToLower()}.{foreignKey.Name.ToLower()}.foreign-key.xml");
FileHelper.Write(path, xml);
ChangeSetCommand.Next();
}
static void Main(string[] args)
{
int width = 16;
bool help = false;
bool init = false;
bool clean = false;
string style = null;
var p = new OptionSet {
{ "w:|width:", (int v) => width = v },
{ "i|init", v => init = v != null },
{ "s|style:", v => style = v},
{ "c|clean", v => clean = v != null },
{ "h|?|help", v => help = v != null }
};
List<string> extra = p.Parse(args);
if (help)
{
ShowHelp(p);
return;
}
if (clean)
{
var cleanCmd = new CleanCommand();
cleanCmd.Execute();
}
if (init)
{
var initCmd = new InitCommand(style);
initCmd.Execute();
}
if (extra.Count > 0)
{
var generateCmd = new GenerateCommand(new GenerateSpecification
{
FileFilter = extra,
ColumnWidth = width
});
generateCmd.Execute();
}
else
{
// TODO: In case now command created -> Show help, otherwise process!
ShowHelp(p);
return;
}
}
private static void CreateSequence(GenerateCommand command, ChangeSetCommand changeSetCommand, Table table, Column column)
{
var builder = new CreateSequenceChangeSetBuilder(table);
var changeSet = builder.Build(changeSetCommand);
var xml = changeSet.ToXml();
var path = Path.Combine(command.DirectoryPath, $"{ChangeSetCommand.Sequence:000}.{table.Name.ToLower()}.{column.Name.ToLower()}.sequence.xml");
FileHelper.Write(path, xml);
ChangeSetCommand.Next();
}
public GenerateViewModel()
{
Command = new GenerateCommand
{
Author = "altair.sossai",
Database = Constants.Databases.SqlServer,
DirectoryPath = @"E:\liquibase-editor",
TableNames = "GA_TIMESHEET; GA_TIMESHEET_ITEM"
};
Command.UseSqlServerDefaultConfiguration();
}
public async Task It_can_GetBits()
{
// Arrange
var opts = new GenerateOptions();
var repo = Substitute.For <IFeatureBitsRepo>();
var filesystem = Substitute.For <IFileSystem>();
var it = new GenerateCommand(opts, repo, filesystem);
repo.GetAllAsync().Returns(info => _featureBitDefinitions);
// Act
(string Name, int Id)[] result = (await it.GetBits()).ToArray();
public void It_can_be_created()
{
// Arrange
var opts = new GenerateOptions();
var repo = Substitute.For <IFeatureBitsRepo>();
var filesystem = Substitute.For <IFileSystem>();
// Act
var it = new GenerateCommand(opts, repo, filesystem);
// Assert
it.Should().NotBeNull();
}
private static int Invoke(IFileSystem fileSystem, IProcessProxy processProxy, IConsole?console = null)
{
var command = new GenerateCommand()
{
Handler = new GenerateCommand.CommandHandler(
MockEnvironmentProxy.Default,
processProxy,
fileSystem,
MockLoggerFactory.CreateGenericLogger <GenerateCommand>()),
};
return(command.Invoke("", console));
}
private static int Main(string[] args)
{
Encoding.RegisterProvider(CodePagesEncodingProvider.Instance);
Logger.Initialize();
return(Parser.Default.ParseArguments <GenerateCommand, ParseCommand, CleanCommand, LanguageCommand>(args)
.MapResult(
(GenerateCommand opts) => GenerateCommand.Handle(opts),
(ParseCommand opts) => ParseCommand.Handle(opts),
(CleanCommand opts) => CleanCommand.Handle(opts),
(LanguageCommand opts) => LanguageCommand.Handle(opts),
(DocumentationCommand opts) => DocumentationCommand.Handle(opts),
errs => 1));
}
public MainViewModel()
{
_site = new Site();
_obstacle = new Obstacle();
_cell = new Cell();
GenerateCommandUpdate = new GenerateCommand(this);
Shapes = new BindableCollection <Polygon>();
Shapes.Add(_site.GetShape());
Shapes.Add(_obstacle.GetShape());
MinWindowHeight = "330";
MinWindowWidth = "500";
_yScaleFactor = 1;
_xScaleFactor = 1;
ErrorMessage = _noError;
}
public void AreaMap_NoAreas()
{
var controllers = new[]
{
new ControllerDefinition {
Name = "Home", Area = ""
},
new ControllerDefinition {
Name = "User", Area = ""
},
};
var command = new GenerateCommand(null, null, null, new Settings());
var areaMap = command.GenerateAreaMap(controllers);
Assert.Equal(0, areaMap.Count);
}
private void OnGenerate()
{
int numberOfWinners;
if (Int32.TryParse(NumberOfWinners, out numberOfWinners))
{
string winnersAre = "";
for (int i = 0; i < numberOfWinners; i++)
{
Random randomGenerator = new Random();
var luckyWinnerPosition = randomGenerator.Next(0, PeopleCollection.Count);
var luckyWinner = PeopleCollection[luckyWinnerPosition];
PeopleCollection.Remove(luckyWinner);
winnersAre += i + 1 + ": " + luckyWinner + System.Environment.NewLine;
}
MessageBox.Show(winnersAre, "Lucky Winners");
}
NumberOfWinners = "";
GenerateCommand.RaiseCanExecuteChanged();
}
private void RaiseCanExecuteChanged(object sender, DataErrorsChangedEventArgs e)
{
SaveCommand.RaiseCanExecuteChanged();
GenerateCommand.RaiseCanExecuteChanged();
}
public static void UseOracleDefaultConfiguration(this GenerateCommand command)
{
command.ConnectionString = "USER ID=GATEC_SIMPLEFARM_QA;PASSWORD=ga;DATA SOURCE=(DESCRIPTION =(ADDRESS_LIST =(ADDRESS = (PROTOCOL = TCP)(HOST = 10.0.1.25)(PORT = 1524)))(CONNECT_DATA =(SERVICE_NAME = DBDEV11)))";
}
private void OnPeopleCollectionChanged(object sender, NotifyCollectionChangedEventArgs e)
{
GenerateCommand.RaiseCanExecuteChanged();
ClearDataCommand.RaiseCanExecuteChanged();
}
public static void UseSqlServerDefaultConfiguration(this GenerateCommand command)
{
command.ConnectionString = "Server=localhost;Database=FC_SIMPLEFARM_DEV2004;User Id=sa;Password=ef66b58b-6ff2-4c78-bcec-6b279312b625;";
}
public async Task <ActionResult <RecoveryCodesList> > Generate([FromBody] GenerateCommand command)
{
return(await Mediator.Send(command));
}
