public override void Execute()
{
base.Execute();
var invoker = new CommandInvoker(BasicActivator);
var commandCtor = invoker.GetConstructor(_commandType, new CommandLineObjectPicker(new string[0], BasicActivator.RepositoryLocator));
var sb = new StringBuilder();
PopulateBasicCommandInfo(sb);
var dynamicCtorAttribute = commandCtor?.GetCustomAttribute <UseWithCommandLineAttribute>();
//it is a basic command, one that expects a fixed number of proper objects
var sbParameters = new StringBuilder();
sbParameters.AppendLine();
sbParameters.AppendLine("PARAMETERS:");
// Usage
if (dynamicCtorAttribute != null)
{
//is it a dynamic command (one that processes it's own CommandLinePicker)
// Added to the call line e.g. "./rdmp cmd MyCall <param1> <someotherParam>"
sb.Append(dynamicCtorAttribute.ParameterHelpList);
sbParameters.Append(dynamicCtorAttribute.ParameterHelpBreakdown);
}
else
if (commandCtor == null || !invoker.IsSupported(commandCtor))
{
sb.AppendLine($"Command '{_commandType.Name}' is not supported by the current input type ({BasicActivator.GetType().Name})");
}
else
{
// For each thing the constructor takes
foreach (ParameterInfo p in commandCtor.GetParameters())
{
var req = new RequiredArgument(p);
//automatic delegates require no user input or CLI entry (e.g. IActivateItems)
if (invoker.GetDelegate(req).IsAuto)
{
continue;
}
// Added to the call line e.g. "./rdmp cmd MyCall <param1> <someotherParam>"
sb.Append($"<{req.Name}> ");
//document it for the breakdown table
sbParameters.AppendLine($"{req.Name}\t{req.Type.Name}\t{req.DemandIfAny?.Description}");
}
}
sb.AppendLine();
sb.AppendLine(sbParameters.ToString());
BasicActivator.Show(sb.ToString());
}
public void InRangeSpecifiedRequiredArgumentTest()
{
{
this.cakeArgs.Setup(
m => m.HasArgument(requiredArgName)
).Returns(true);
this.cakeArgs.Setup(
m => m.GetArgument(requiredArgName)
).Returns((minValue + 1).ToString());
RequiredArgument uut = ArgumentBinder.FromArguments <RequiredArgument>(this.cakeContext.Object);
Assert.AreEqual(minValue + 1, uut.IntProperty);
}
{
this.cakeArgs.Setup(
m => m.HasArgument(requiredArgName)
).Returns(true);
this.cakeArgs.Setup(
m => m.GetArgument(requiredArgName)
).Returns((maxValue - 1).ToString());
RequiredArgument uut = ArgumentBinder.FromArguments <RequiredArgument>(this.cakeContext.Object);
Assert.AreEqual(maxValue - 1, uut.IntProperty);
}
}
public void HasRequiredArgumentTest()
{
this.cakeArgs.Setup(
m => m.HasArgument(requiredArgName)
).Returns(true);
this.cakeArgs.Setup(
m => m.GetArgument(requiredArgName)
).Returns("true");
RequiredArgument uut = ArgumentBinderAliases.CreateFromArguments <RequiredArgument>(this.cakeContext.Object);
Assert.IsTrue(uut.BoolProperty);
}
public void HasRequiredArgumentTest()
{
this.cakeArgs.Setup(
m => m.HasArgument(requiredArgName)
).Returns(true);
this.cakeArgs.Setup(
m => m.GetArgument(requiredArgName)
).Returns(minValue.ToString());
RequiredArgument uut = ArgumentBinder.FromArguments <RequiredArgument>(this.cakeContext.Object);
Assert.AreEqual(minValue, uut.IntProperty);
}
public void HasRequiredArgumentTest()
{
const string value = "Arg Value";
this.cakeArgs.Setup(
m => m.HasArgument(requiredArgName)
).Returns(true);
this.cakeArgs.Setup(
m => m.GetArgument(requiredArgName)
).Returns(value);
RequiredArgument uut = ArgumentBinder.FromArguments <RequiredArgument>(this.cakeContext.Object);
Assert.AreEqual(value, uut.StringProperty);
}
public void HasRequiredArgumentTest()
{
const Enum1 expectedValue = Enum1.Value2;
this.cakeArgs.Setup(
m => m.HasArgument(requiredArgName)
).Returns(true);
this.cakeArgs.SetupGetArgumentSingle(
requiredArgName,
expectedValue.ToString()
);
RequiredArgument uut = ArgumentBinderAliases.CreateFromArguments <RequiredArgument>(this.cakeContext.Object);
Assert.AreEqual(expectedValue, uut.Enum1Property);
}
private string FormatParameterDescription(RequiredArgument req, ConstructorInfo ctor)
{
int nameColWidth = ctor.GetParameters().Max(p => p.Name.Length);
int typeColWidth = ctor.GetParameters().Max(p => p.ParameterType.Name.Length);
try
{
if (BasicActivator is ConsoleInputManager)
{
var name = req.Name.Length < nameColWidth?req.Name.PadRight(nameColWidth) : req.Name.Substring(0, nameColWidth);
var type = req.Type.Name.Length < typeColWidth?req.Type.Name.PadRight(typeColWidth) : req.Type.Name.Substring(0, typeColWidth);
var desc = req.DemandIfAny?.Description;
if (string.IsNullOrWhiteSpace(desc))
{
return($"{name} {type}");
}
else
{
var availableWidth = Console.WindowWidth;
var occupied = nameColWidth + 1 + typeColWidth + 1;
var availableDescriptionWidth = availableWidth - occupied;
if (availableDescriptionWidth < 0)
{
return($"{name} {type}");
}
var wrappedDesc = Wrap(desc, availableDescriptionWidth, occupied);
return($"{name} {type} {wrappedDesc}");
}
}
}
catch (Exception)
{
return($"{req.Name}\t{req.Type.Name}\t{req.DemandIfAny?.Description}");
}
return($"{req.Name}\t{req.Type.Name}\t{req.DemandIfAny?.Description}");
}
public void HasRequiredArgumentTest()
{
// Setup
const string value = "somedir";
this.cakeArgs.Setup(
m => m.HasArgument(requiredArgName)
).Returns(true);
this.cakeArgs.SetupGetArgumentSingle(
requiredArgName,
value
);
// Act
RequiredArgument uut = ArgumentBinderAliases.CreateFromArguments <RequiredArgument>(this.cakeContext.Object);
// Check
Assert.AreEqual(value, uut.DirectoryPathProperty.ToString());
}
public override Task <IEnumerable <Claim> > GetAccessTokenClaimsAsync(ClaimsPrincipal subject, Client client,
IEnumerable <Scope> scopes, ValidatedRequest request)
{
if (!request.Raw.Validate(RequiredArgument))
{
throw new Exception(string.Format("RequiredArgument failed need the following [{0}]", string.Join(",", RequiredArgument.ToArray())));
}
var result = base.GetAccessTokenClaimsAsync(subject, client, scopes, request);
var rr = request.Raw.AllKeys.ToDictionary(k => k, k => request.Raw[k]);
List <Claim> finalClaims = new List <Claim>(result.Result);
string output = JsonConvert.SerializeObject(rr);
finalClaims.Add(new Claim(P5.IdentityServer3.Common.Constants.ClaimTypes.ClientRequestNameValueCollection, output));
if (subject != null)
{
// Extra claims that came in from an upstream ICustomGrantValidator, but only those that match the ones in our know
// ClaimTypes
// look for claims in subject.Claims that match those in P5ClaimTypes
/*
* var query = from item in subject.Claims
* join name in P5ClaimTypes
* on item.Type equals name
* select item;
* if (!query.Any())
* {
* return result;
* }
* finalClaims.AddRange(query);
*/
finalClaims.AddRange(subject.Claims.Where(p2 =>
finalClaims.All(p1 => p1.Type != p2.Type)));
}
// if we find any, than add them to the original and send that back.
IEnumerable <Claim> claimresults = finalClaims;
var taskResult = Task.FromResult(claimresults);
return(taskResult);
}
public override Task <IEnumerable <Claim> > GetAccessTokenClaimsAsync(ClaimsPrincipal subject, Resources resources, ValidatedRequest request)
{
if (!request.Raw.ContainsAny(RequiredArgument))
{
var ex = new Exception(string.Format("RequiredArgument failed need the following [{0}]", string.Join(",", RequiredArgument.ToArray())));
_logger.LogError(LoggingEvents.REQUIRED_ITEMS_MISSING, ex);
throw ex;
}
var result = base.GetAccessTokenClaimsAsync(subject, resources, request);
var rr = request.Raw.AllKeys.ToDictionary(k => k, k => request.Raw[k]);
List <Claim> finalClaims = new List <Claim>(result.Result);
string output = JsonConvert.SerializeObject(rr);
finalClaims.Add(new Claim(P7.IdentityServer4.Common.Constants.ClaimTypes.ClientRequestNameValueCollection, output));
if (subject != null)
{
finalClaims.AddRange(subject.Claims.Where(p2 =>
finalClaims.All(p1 => p1.Type != p2.Type)));
}
// if we find any, than add them to the original and send that back.
IEnumerable <Claim> claimresults = finalClaims;
var taskResult = Task.FromResult(claimresults);
return(taskResult);
}
public override void Execute()
{
base.Execute();
var invoker = new CommandInvoker(BasicActivator);
var commandCtor = invoker.GetConstructor(_commandType);
var help = new CommentStore();
help.ReadComments(Environment.CurrentDirectory);
var sb = new StringBuilder();
if (commandCtor == null || !invoker.IsSupported(commandCtor))
{
sb.AppendLine($"Command '{_commandType.Name}' is not supported by the current input type ({BasicActivator.GetType().Name})");
}
else
{
sb.AppendLine("COMMAND:" + _commandType.FullName);
var helpText = help.GetTypeDocumentationIfExists(_commandType);
if (helpText != null)
{
sb.AppendLine(helpText);
}
sb.AppendLine("USAGE:");
sb.Append(EnvironmentInfo.IsLinux ? "./rdmp" : "./rdmp.exe");
sb.Append(" cmd ");
sb.Append(BasicCommandExecution.GetCommandName(_commandType.Name));
sb.Append(" ");
var sbParameters = new StringBuilder();
sbParameters.AppendLine("PARAMETERS:");
foreach (ParameterInfo p in commandCtor.GetParameters())
{
var req = new RequiredArgument(p);
//automatic delegates require no user input or CLI entry (e.g. IActivateItems)
if (invoker.GetDelegate(req).IsAuto)
{
continue;
}
sb.Append($"<{req.Name}> ");
sbParameters.AppendLine($"{req.Name}\t{req.Type.Name}\t{req.DemandIfAny?.Description}");
}
sb.AppendLine();
sb.AppendLine(sbParameters.ToString());
}
BasicActivator.Show(sb.ToString());
}
