public void InvokeCliCall(CliCall cliCall)
{
var commandName = $"{cliCall.ControllerName}:{cliCall.ActionName}";
var command = GetCommand(commandName);
if (command == null)
{
Util.WriteLine($"<error>Command {commandName} is unknown</error>");
Util.WriteLine("Call help:list to see all available commands");
return;
}
var commandController = ObjectManager.Instance().Get(command.DeclaringType);
var arguments = MapArguments(command, cliCall);
var request = new CliRequest();
request.ActionName = cliCall.ActionName;
request.ControllerName = cliCall.ControllerName;
request.Arguments = new Dictionary <string, object>();
foreach (var parameter in command.GetParameters())
{
request.Arguments.Add(parameter.Name, arguments[parameter.Position]);
}
((AbstractCliController)commandController).SetCliReqest(request);
var actionName = Text.FirstCharToUpper(cliCall.ActionName) + "Command";
command.Invoke(commandController, arguments);
}
protected object[] MapArguments(MethodInfo actionInfo, CliCall cliCall)
{
var result = new List <object>();
var consumedParameters = 0;
foreach (var parameter in actionInfo.GetParameters())
{
var targetName = parameter.Name;
object[] argumentString = null;
object targetValue = null;
if (cliCall.HasArgument(targetName))
{
argumentString = cliCall.GetArgument(targetName);
}
else if (cliCall.HasArgument(consumedParameters))
{
argumentString = new object[1] {
cliCall.GetArgument(consumedParameters++)
};
}
else if (parameter.IsOptional && parameter.HasDefaultValue)
{
targetValue = parameter.DefaultValue;
}
else
{
throw new System.ArgumentException($"Missing parameter {targetName}.");
}
if (targetValue == null)
{
var typeConverter = TypeDescriptor.GetConverter(parameter.ParameterType);
targetValue = typeConverter.ConvertTo(argumentString[0], parameter.ParameterType);
}
result.Add(targetValue);
}
return(result.ToArray());
}
protected CliCall ParseCliCall(string[] args)
{
var cliCall = new CliCall();
if (args.Length < 1 || args[0].IndexOf(':') < 0)
{
throw new System.ArgumentException("Not a valid command");
}
var commandParts = args[0].Split(':');
cliCall.ControllerName = commandParts[0].ToLower();
cliCall.ActionName = commandParts[1].ToLower();
var namedArguments = new Dictionary <string, List <string> >();
var positionalArguments = new List <string>();
string currentArgument = null;
void addArgument(string n, string v)
{
if (!namedArguments.ContainsKey(n))
{
namedArguments.Add(n, new List <string>());
}
namedArguments[n].Add(v);
};
for (var i = 1; i < args.Length; i++)
{
var arg = args[i];
if (arg[0] == '-')
{
if (currentArgument != null)
{
addArgument(currentArgument, "true");
}
if (arg[1] == '-')
{
currentArgument = arg.Substring(2);
}
else
{
for (var j = 1; j < arg.Length - 1; j++)
{
addArgument(arg[j].ToString(), "true");
}
currentArgument = arg[arg.Length - 1].ToString();
}
}
else
{
if (currentArgument == null)
{
positionalArguments.Add(arg);
}
else
{
addArgument(currentArgument, arg);
currentArgument = null;
}
}
}
cliCall.PositionalArguments = positionalArguments;
cliCall.NamedArguments = namedArguments;
return(cliCall);
}
public void DescribeCommand(string commandName)
{
MethodInfo command = (new CliHandler()).GetCommand(commandName);
if (command == null)
{
Util.WriteLine($"<error>No command {commandName} was found</error>");
return;
}
var parameters = command.GetParameters();
Util.WriteLine($"<fg=DarkGrey>defined in {command.DeclaringType.Name}</>\n");
Util.WriteLine($"<fg=Yellow>Usage</>");
var usageStringBuilder = new StringBuilder(commandName);
foreach (var parameter in parameters)
{
if (parameter.IsOptional)
{
usageStringBuilder.Append($" [{parameter.Name}]");
}
else
{
usageStringBuilder.Append($" <{parameter.Name}>");
}
}
Util.WriteLine(usageStringBuilder.ToString(), 2);
Util.WriteLine();
var helpText = getHelpText(command);
if (!string.IsNullOrEmpty(helpText))
{
Util.WriteLine($"<fg=Yellow>Help</>");
Util.WriteLine(getHelpText(command));
Util.WriteLine();
}
if (parameters.Length > 0)
{
Util.WriteLine($"<fg=Yellow>Arguments</>");
var parameterAttributes = command.GetCustomAttributes(typeof(Parameter));
var parameterDescriptions = new Dictionary <string, string>();
foreach (var parameterAttribute in parameterAttributes)
{
var attribute = (Parameter)parameterAttribute;
parameterDescriptions.Add(attribute.GetName(), attribute.Description);
}
foreach (var parameter in parameters)
{
Util.Write($"<fg=White>--{CliCall.GetCliParameterName(parameter.Name)}</>", 2);
if (parameter.HasDefaultValue)
{
Util.Write($" <fg=DarkGrey>({parameter.DefaultValue.ToString()})</>", 2);
}
Util.WriteLine();
if (parameterDescriptions.ContainsKey(parameter.Name) && !string.IsNullOrEmpty(parameterDescriptions[parameter.Name]))
{
Util.WriteLine(parameterDescriptions[parameter.Name], 4);
}
}
}
}
