public void GetPackageNameAutoComplete(AutoCompleteValuesFunctionContext context)
{
foreach (var package in PackageLogic.Instance.PackagesCollection.Packages)
{
context.Values.Add(package.Name);
}
}
public void GetCommandNameValues(AutoCompleteValuesFunctionContext context)
{
foreach (var cmd in base.Host.Commands)
{
context.Values.Add(cmd.CommandName);
context.Values.AddRange(cmd.Aliases);
}
}
public void GetModuleNamesAutoComplete(AutoCompleteValuesFunctionContext context)
{
if (!string.IsNullOrWhiteSpace(Assembly))
{
var asm = LoadAssembly();
context.Values.AddRange(asm.GetTypes().Where(t => t.GetInterface(typeof(IModule).FullName) != null).Select(t => ((IModule)Activator.CreateInstance(t)).Name));
}
}
public void GetModuleNameAutoComplete(AutoCompleteValuesFunctionContext context)
{
if (string.IsNullOrWhiteSpace(Package))
{
return;
}
context.Values.AddRange(
PackageLogic.Instance.PackagesCollection.Packages
.FirstOrDefault(e => e.Name.Equals(Package, StringComparison.OrdinalIgnoreCase))
.Modules.Select(m => m.Name));
}
public void GetVariableNamesAutoComplete(AutoCompleteValuesFunctionContext context)
{
if (AllContexts.IsPresent)
{
context.Values.AddRange(VariableContextLogic.Instance.VariableContextCollection.Contexts
.SelectMany(c => c.Variables.Select(v => v.Name)).Distinct().ToList());
}
else
{
var ctx = VariableContextLogic.Instance.CurrentContext;
if (ctx == null && !string.IsNullOrWhiteSpace(Context))
{
ctx = VariableContextLogic.Instance.VariableContextCollection.Contexts.FirstOrDefault(c => c.Name.Equals(Context, StringComparison.OrdinalIgnoreCase));
}
if (ctx == null)
{
return;
}
context.Values.AddRange(ctx.Variables.Select(v => v.Name).ToList());
}
}
public static List <string> GetParameterAutoCompleteValues(CommandResolver resolver, ParameterDef paramDef, IHostInterface host)
{
if (string.IsNullOrWhiteSpace(paramDef.AutoCompleteValuesFunction))
{
throw new ArgumentException(string.Format("Parameter definition for parameter {0} does not define an auto complete values function"
, paramDef.Name));
}
var cmd = new CommandActivator().Create(resolver, host);
var methodInfo = cmd.GetType().GetMethod(paramDef.AutoCompleteValuesFunction);
if (methodInfo == null)
{
throw new ArgumentException(string.Format("Auto complete values function '{0}' cannot be found for parameter {0}"
, paramDef.AutoCompleteValuesFunction, paramDef.Name));
}
var context = new AutoCompleteValuesFunctionContext();
methodInfo.Invoke(cmd, new object[] { context });
return(context.Values);
}
public void GetContextNamesAutoComplete(AutoCompleteValuesFunctionContext context)
{
context.Values.AddRange(VariableContextLogic.Instance.VariableContextCollection.Contexts.Select(c => c.Name).ToList());
}
public void GetModuleNameAutoComplete(AutoCompleteValuesFunctionContext context)
{
context.Values.AddRange(base.Host.Modules.Select(m => m.Name));
}
public void GetLoadedPackageNames(AutoCompleteValuesFunctionContext context)
{
context.Values.AddRange(PackageLogic.Instance.LoadedPackages.Select(e => e.Name).ToList());
}
public void GetPackageNamesAutoComplete(AutoCompleteValuesFunctionContext context)
{
context.Values.AddRange(PackageLogic.Instance.PackagesCollection.Packages.Select(e => e.Name));
}
public void GetAssemblyFilenameAutoCompleteValues(AutoCompleteValuesFunctionContext context)
{
context.Values.AddRange(new UserAssemblyRepository().Assemblies.Select(a => a.Name));
}
private void ValidateParameterValues()
{
var definition = Command.GetType().DescribeInputCommand();
foreach (var param in definition.Parameters.Where(p =>
(p.UseAutoCompleteForValidation && !string.IsNullOrWhiteSpace(p.AutoCompleteValuesFunction)) ||
!string.IsNullOrWhiteSpace(p.ValidationFunction)))
{
// get parameter value
string value = param.PropertyInfo.GetValue(Command)?.ToString();
if (value != null) // compare to validation values
{
// get validation values
try
{
bool isValid = false;
string validationMessage = null;
if (param.UseAutoCompleteForValidation)
{
var methodInfo = Command.GetType().GetMethod(param.AutoCompleteValuesFunction);
var context = new AutoCompleteValuesFunctionContext();
methodInfo.Invoke(Command, new object[] { context });
isValid = context.Values.Contains(value, StringComparer.OrdinalIgnoreCase);
}
else
{
var methodInfo = Command.GetType().GetMethod(param.ValidationFunction);
var context = new ValidationFunctionContext(value);
methodInfo.Invoke(Command, new object[] { context });
isValid = context.IsValid;
validationMessage = context.Message;
}
// evaluate
if (!isValid)
{
Errors.Add(new CommandValidatorError()
{
Type = CommandValidationType.InvalidParameterValue,
Parameters = new List <ParameterDef>()
{
param
},
Message = validationMessage ?? string.Format("The value of parameter {0} is invalid", param.Name)
});
}
}
catch (Exception ex)
{
Errors.Add(new CommandValidatorError()
{
Type = CommandValidationType.InvalidValidationValuesFunction,
Parameters = new List <ParameterDef>()
{
param
},
Message = string.Format("An error occured during the invocation of the validation values function for parameter {0}", param.Name),
Error = ex
});
}
}
}
}
public void GetEnumNames(AutoCompleteValuesFunctionContext ctx)
{
ctx.Values.AddRange(Enum.GetNames(typeof(TestEnumType)));
}
