/// <summary>
/// Adds a parameter to the call (for all types other than strings)
/// </summary>
/// <param name="ID">Name of the parameter</param>
/// <param name="Value">Value to add</param>
/// <param name="Type">SQL type of the parameter</param>
/// <param name="Direction">Parameter direction (defaults to input)</param>
public virtual void AddParameter(string ID, DbType Type, object Value = null, ParameterDirection Direction = ParameterDirection.Input)
{
if (ExecutableCommand != null)
{
ExecutableCommand.AddParameter(ID, Type, Value, Direction);
}
}
/// <summary>
/// Hlavná slučka hry
/// </summary>
public void Run()
{
GameRunning = true;
while (GameRunning)
{
string consolePromt = ConsolePromt();
ExecutableCommand cmd = _parser.ParseLine(consolePromt, State);
if (cmd != null)
{
try
{
string result = cmd.Execute(this);
if (!string.IsNullOrEmpty(result))
{
Console.WriteLine(result);
}
}
catch (EndGameException ex)
{
State = GameState.End;
Console.WriteLine(ex.Message);
EndGame();
}
}
else
{
var suggestion = TextTools.GetSuggestion(_parser.GetCommands(State), consolePromt);
Console.WriteLine("Invallid command." + (suggestion != "" ? " Did you mean " + suggestion + "?" : ""));
}
}
}
// ReSharper disable once InconsistentNaming
protected void Throws <T>(ExecutableCommand When) where T : Exception
{
Exception exceptionThrown = null;
try
{
this.When(When);
}
catch (Exception e)
{
exceptionThrown = e;
}
formatter.Block("Then:");
Assert(
exceptionThrown is T,
() => formatter.Write("It throws " + typeof(T).Name).NewLine(),
() =>
{
if (exceptionThrown == null)
{
formatter.Write("But it did not.");
return;
}
formatter.Write("But got " + exceptionThrown.GetType().Name).NewLine();
});
// consume all events
results = Enumerable.Empty <DomainEvent>();
}
/// <summary>
/// Adds a parameter to the call (for strings only)
/// </summary>
/// <param name="ID">Name of the parameter</param>
/// <param name="Value">Value to add</param>
/// <param name="Length">Size of the string(either -1 or greater than 4000 should be used to indicate nvarchar(max))</param>
/// <param name="Direction">Parameter direction (defaults to input)</param>
public virtual void AddParameter(string ID, int Length, string Value = "", ParameterDirection Direction = ParameterDirection.Input)
{
if (ExecutableCommand != null)
{
ExecutableCommand.AddParameter(ID, Length, Value, Direction);
}
}
/// <summary>
/// Executes the stored procedure and returns a reader object
/// </summary>
public virtual void ExecuteReader()
{
Open();
if (ExecutableCommand != null)
{
Reader = ExecutableCommand.ExecuteReader();
}
}
/// <summary>
/// Returns a parameter's value
/// </summary>
/// <typeparam name="DataType">Data type of the object</typeparam>
/// <param name="ID">Parameter name</param>
/// <param name="Default">Default value for the parameter</param>
/// <param name="Direction">Parameter direction (defaults to input)</param>
/// <returns>if the parameter exists (and isn't null or empty), it returns the parameter's value. Otherwise the default value is returned.</returns>
public virtual DataType GetParameter <DataType>(string ID, DataType Default = default(DataType), ParameterDirection Direction = ParameterDirection.Input)
{
if (Direction == ParameterDirection.Output)
{
return(ExecutableCommand.GetOutputParameter <DataType>(ID, Default));
}
return(Reader.GetParameter <DataType>(ID, Default));
}
/// <summary>
/// Adds a parameter to the call (for all types other than strings)
/// </summary>
/// <param name="ID">Name of the parameter</param>
/// <param name="Value">Value to add</param>
/// <param name="Type">SQL type of the parameter</param>
/// <param name="Direction">Parameter direction (defaults to input)</param>
/// <returns>This</returns>
public virtual SQLHelper AddParameter(string ID, DbType Type, object Value = null, ParameterDirection Direction = ParameterDirection.Input)
{
if (ExecutableCommand != null)
{
ExecutableCommand.AddParameter(ID, Type, Value, Direction);
}
return(this);
}
/// <summary>
/// Adds a parameter to the call (for strings only)
/// </summary>
/// <param name="ID">Name of the parameter</param>
/// <param name="Value">Value to add</param>
/// <param name="Length">Size of the string(either -1 or greater than 4000 should be used to indicate nvarchar(max))</param>
/// <param name="Direction">Parameter direction (defaults to input)</param>
/// <returns>This</returns>
public virtual SQLHelper AddParameter(string ID, int Length, string Value = "", ParameterDirection Direction = ParameterDirection.Input)
{
if (ExecutableCommand != null)
{
ExecutableCommand.AddParameter(ID, Length, Value, Direction);
}
return(this);
}
/// <summary>
/// Executes the stored procedure and returns a reader object
/// </summary>
public virtual SQLHelper ExecuteReader()
{
Open();
if (ExecutableCommand != null)
{
Reader = ExecutableCommand.ExecuteReader();
}
return(this);
}
/// <summary>
/// Creates a command from its properties
/// </summary>
/// <param name="name">The name of the executed command, such as 'plugins' for '/plugins'</param>
/// <param name="description">The description of the command given by /help</param>
/// <param name="help">The help given by doing /help [command] or when a command fails</param>
/// <param name="method">The method executed when calling the method</param>
internal Command(string name, string description, string help, ExecutableCommand method)
{
this.Name = name;
this.Description = description;
this.Help = help;
this._method = method;
_commands.Add(this);
}
protected void When(ExecutableCommand command)
{
BeforeExecute(command);
formatter
.Block("When users:")
.Write(command, new EventFormatter(formatter));
results = Context.ProcessCommand(command);
}
protected void When(ExecutableCommand command)
{
//SetupAuthenticationMetadata(command.Meta);
//command.IdGenerator = new FakeIdGenerator(this);
formatter
.Block("When users:")
.Write(command, new EventFormatter(formatter));
results = Context.ProcessCommand(command);
}
public RunnerViewModel()
{
Specifications = new ObservableCollection <Test>();
FooterVM = new FooterViewModel();
RunSuiteCommand = new ExecutableCommand(
() => RunSuite(),
() => AllowTestRun);
ExportResultsCommand = new ExecutableCommand(
() => ViewBinder.Instance.DisplayActive <TestActiveViewModel>(),
() => AllowTestRun && FooterVM.AllTestsPassed.HasValue);
}
internal static async Task <int> Main(string[] args)
{
using ILoggerFactory loggerFactory = LoggerFactory.Create(builder => builder.AddConsole());
ILogger logger = loggerFactory.CreateLogger <Program>();
RootCommand rootCommand = new();
rootCommand.Name = "dotnet-template-localizer";
foreach (Func <ILoggerFactory, ExecutableCommand> commandCreator in CommandCreators)
{
ExecutableCommand command = commandCreator(loggerFactory);
rootCommand.AddCommand(command.CreateCommand());
}
return(await rootCommand.InvokeAsync(args).ConfigureAwait(false));
}
private void RecreateConnection()
{
if (Reader != null)
{
Reader.Close();
Reader.Dispose();
Reader = null;
}
if (ExecutableCommand != null)
{
ExecutableCommand.Dispose();
ExecutableCommand = null;
}
ExecutableCommand = Factory.CreateCommand();
ExecutableCommand.CommandText = _Command;
ExecutableCommand.Connection = Connection;
ExecutableCommand.CommandType = CommandType;
if (Transaction != null)
{
ExecutableCommand.Transaction = Transaction;
}
}
public virtual void Dispose()
{
Close();
if (Connection != null)
{
Connection.Dispose();
Connection = null;
}
if (Transaction != null)
{
Transaction.Dispose();
Transaction = null;
}
if (ExecutableCommand != null)
{
ExecutableCommand.Dispose();
ExecutableCommand = null;
}
if (Reader != null)
{
Reader.Dispose();
Reader = null;
}
}
/// <summary>
/// Opens the connection
/// </summary>
public virtual void Open()
{
ExecutableCommand.Open();
}
/// <summary>
/// Clears the parameters
/// </summary>
public virtual SQLHelper ClearParameters()
{
ExecutableCommand.ClearParameters();
return(this);
}
/// <summary>
/// Executes the stored procedure as a scalar query
/// </summary>
/// <typeparam name="DataType">Data type to return</typeparam>
/// <returns>The object of the first row and first column</returns>
public virtual DataType ExecuteScalar <DataType>()
{
return(ExecutableCommand.ExecuteScalar <DataType>());
}
/// <summary>
/// Commits a transaction
/// </summary>
public virtual SQLHelper Commit()
{
ExecutableCommand.Commit();
return(this);
}
/// <summary>
/// Executes the stored procedure as a non query
/// </summary>
/// <returns>Number of rows effected</returns>
public virtual int ExecuteNonQuery()
{
Open();
return((ExecutableCommand != null) ? ExecutableCommand.ExecuteNonQuery() : 0);
}
public void EmitCommand( ExecutableCommand cmd )
{
cmd.BuildAssembly( il );
}
/// <summary>
/// Commits a transaction
/// </summary>
public virtual void Commit()
{
ExecutableCommand.Commit();
}
/// <summary>
/// Closes the connection
/// </summary>
public virtual void Close()
{
ExecutableCommand.Close();
}
/// <summary>
/// Clears the parameters
/// </summary>
public virtual void ClearParameters()
{
ExecutableCommand.ClearParameters();
}
/// <summary>
/// Begins a transaction
/// </summary>
public virtual void BeginTransaction()
{
Transaction = ExecutableCommand.BeginTransaction();
Command = _Command;
}
/// <summary>
/// Opens the connection
/// </summary>
public virtual SQLHelper Open()
{
ExecutableCommand.Open();
return(this);
}
/// <summary>
/// Rolls back a transaction
/// </summary>
public virtual SQLHelper Rollback()
{
ExecutableCommand.Rollback();
return(this);
}
/// <summary>
/// Rolls back a transaction
/// </summary>
public virtual void Rollback()
{
ExecutableCommand.Rollback();
}
/// <summary>
/// Executes the query and returns a data set
/// </summary>
/// <returns>A dataset filled with the results of the query</returns>
public virtual DataSet ExecuteDataSet()
{
return(ExecutableCommand.ExecuteDataSet(Factory));
}
public TransferFile ExecuteCommand(string command, string session)
{
bool executeasync = false;
CleanUp();
if (command.ToLower().StartsWith("start "))
{
executeasync = true;
command = command.Substring(6);
}
var commands = command.Split('|').Where(p => p != "").ToArray();
List <ExecutableCommand> ecommands = new List <ExecutableCommand>();
foreach (var cmds in commands)
{
ExecutableCommand ecmd = new ExecutableCommand();
var parts = SplitArguments(cmds).Where(p => p != "").ToArray(); //TODO: Better arguments handling (support quotes)
ecmd.Parameters = parts.Skip(1).ToArray();
//Support piping
if (Commands.ContainsKey(parts.First().ToLower()))
{
var cmdd = Commands[parts.First().ToLower()];
//Create command object
var cmd = cmdd.CreateNew <IConsoleCommand>();
ecmd.Command = cmd;
//Map parameters
for (int i = 1; i < parts.Length; i += 2)
{
if (parts[i].StartsWith("-"))
{
try
{
//Parameter
if (cmdd.Parameters.ContainsKey(parts[i].ToLower().TrimStart('-')))
{
var pi = cmdd.Parameters[parts[i].ToLower().TrimStart('-')];
if (pi.PropertyType == typeof(string))
{
pi.SetValue(cmd, parts[i + 1]); //TODO: Support other types than string
}
else if (pi.PropertyType == typeof(bool))
{
pi.SetValue(cmd, bool.Parse(parts[i + 1]));
}
else if (pi.PropertyType == typeof(int))
{
pi.SetValue(cmd, int.Parse(parts[i + 1]));
}
else if (pi.PropertyType.IsEnum)
{
pi.SetValue(cmd, Enum.Parse(pi.PropertyType, parts[i + 1], true));
}
}
else
{
AddLogToSession(session, new CommandLog("System", "Unrecognized parameter"));
}
} catch (Exception exc)
{
AddLogToSession(session, new CommandLog("System", $"Error in parameters for {cmdd}: {exc.Message}"));
}
}
else
{
//Log.Add("Unknown parameter: " + parts[i]);
}
}
}
else
{
AddLogToSession(session, new CommandLog("System", $"Unknown Command: {parts.First()}"));
}
if (ecmd.Command is IConsoleOutputCommand)
{
((IConsoleOutputCommand)ecmd.Command).OutputToConsole += new OutputToConsoleHandler((c, s) => { if (s != null)
{
AddLogToSession(session, new CommandLog(c.GetType().Name, s));
}
});
}
if (ecmd.Command is ILogAwareCommand)
{
((ILogAwareCommand)ecmd.Command).Log = NewSession(session);
}
if (ecmd.Command is IInputCommand && ecommands.Any() && (ecommands.Last().Command is IOutputCommand))
{
(ecmd.Command as IInputCommand).Initialize(ecommands.Last().Command as IOutputCommand, ecmd.Parameters);
}
if (ecommands.Count > 0 && !(ecmd.Command is IInputCommand))
{
AddLogToSession(session, new CommandLog("System", "You cannot pipe content to that command"));
return(null);
}
else if (commands.Length > 1 && ecommands.Count == 0 && !(ecmd.Command is IOutputCommand))
{
AddLogToSession(session, new CommandLog("System", "You cannot pipe content from that command"));
return(null);
}
ecommands.Add(ecmd);
}
TransferFile df = null;
//Execute
Action ExecuteCommands = () => {
foreach (var ec in ecommands)
{
try
{
var exec = ec.Command.Execute(ec.Parameters);
if (!string.IsNullOrEmpty(exec))
{
AddLogToSession(session, new CommandLog(ec.Command.GetType().Name, exec));
}
if (ec.Command is IReturnsFile)
{
df = (ec.Command as IReturnsFile).File;
}
}
catch (Exception exc)
{
AddLogToSession(session, new CommandLog(ec.Command.GetType().Name, exc.Message));
//TODO: Logging?
}
}
};
if (executeasync)
{
//Queue task
AddLogToSession(session, new CommandLog("System", "Starting Task"));
System.Threading.Tasks.Task t = System.Threading.Tasks.Task.Run(ExecuteCommands);
Tasks.Add(t);
}
else
{
ExecuteCommands();
}
return(df);
}
