public CommandResponse StoreValidOptions()
{
if (_args.Length == 0)
{
return CommandResponse.Set(false, "Please enter valid arguments.");
}
for (var a = 0; a < _args.Length; a++)
{
//Only interested in option names.
//If not a valid option name then the command is probably incorrect
if (!IsEven(a))
{
continue;
}
var arg = _args[a];
if (!string.IsNullOrWhiteSpace(arg))
{
var option = _args.ElementAt(a).Replace("-", "").ToLowerInvariant();
var optionValueKey = a + 1;
//Check if is valid option
var validOption = ValidOptions.FirstOrDefault(k => k.Key.Equals(option) || k.Key.First().ToString() == option);
if (validOption.Key == null)
{
return CommandResponse.Set(false, $"The OPTION {option} is unknown.");
}
//Checks to see if last OPTION has a value
//Apart from -v & -h all other options should have a value
if (optionValueKey > _args.Length - 1)
{
return CommandResponse.Set(false, $"The OPTION {option} has not been supplied with a value.");
}
var optionValue = _args.ElementAt(optionValueKey);
if (!string.IsNullOrEmpty(optionValue) && !SensitiveOptions.Contains(validOption.Key))
{
optionValue = optionValue.ToLowerInvariant();
}
//If the OPTION has set values, check the incoming against this list
if (validOption.Key != "parameters" && validOption.Key != "setheaders" && validOption.Value.Any() && optionValue != null && !validOption.Value.Contains(optionValue))
{
return CommandResponse.Set(false, $"The OPTION {option} value is invalid.");
}
//Store the Option values
//Doing this here because we already have the key/values parsed
StoreOptionValue(validOption.Key, optionValue);
}
}
return CommandResponse.Set(true, "Command Validated.");
}
override public bool IsValid(string data)
{
var rVal = false;
var comparison = (this.CaseSensitive ? StringComparison.Ordinal : StringComparison.OrdinalIgnoreCase);
var enumer = ValidOptions.GetEnumerator();
while (rVal == false && enumer.MoveNext())
{
if (enumer.Current.Equals(data, comparison))
{
rVal = true;
}
}
return(rVal);
}
private ValidOption GetLongOption(string longOpt)
{
switch (ValidOptions.Count(v => v.LongOption.StartsWith(longOpt)))
{
case 0:
throw new InvalidOptionException(string.Format("{0} is not a valid option", longOpt));
case 1:
return(ValidOptions.FirstOrDefault(v => v.LongOption.StartsWith(longOpt)));
default:
string message = string.Format("{0} could be interpreted as {1}", longOpt,
string.Join(" or ", (from v in ValidOptions
where v.LongOption.StartsWith(longOpt)
select v.LongOption).ToList()));
throw new AmbiguousOptionException(message);
}
}
private IDictionary<string, string> GetOptionDictionay(string key, string value)
{
var paramsList = value?.Split(",") ?? new string[0];
var parameters = new Dictionary<string, string>();
for (var p = 0; p < paramsList.Length; p++)
{
var keyValParam = paramsList.ElementAt(p).Split("|");
var validOptions = ValidOptions.FirstOrDefault(k => k.Key.Equals(key));
if (keyValParam.Length == 2 && validOptions.Value.Contains(keyValParam.ElementAt(0)))
{
parameters.Add(keyValParam.ElementAt(0), keyValParam.ElementAt(1));
}
}
return parameters;
}
public void ValidTests(ValidTypes type, ValidUsers user, ValidDepts dept, ValidDates start, ValidDates end, ValidOptions option)
{
var request = CreateGetRequest(TypeMapper[type], null, null);
GenerateParamValues(TypeToResource[type], user, dept, start, end, option, request);
TestPerform(request);
}
private void GenerateParamValues(ResourceType resourceType, ValidUsers user, ValidDepts dept, ValidDates start, ValidDates end, ValidOptions option, Dictionary <string, string> request)
{
var startDate = UnixDateMapper[start];
var endDate = UnixDateMapper[end];
var opt = user == ValidUsers.Admin ? AdminUserTestRecords.Data : NormalUserTestRecords.Data;
var userType = new Dictionary <ValidUsers, string>()
{
[ValidUsers.Admin] = UserAdmin.ToString(),
[ValidUsers.Normal] = UserNormal.ToString(),
[ValidUsers.ArrayUsers] = $"[{UserAdmin},{UserNormal}]"
};
var deptType = new Dictionary <ValidDepts, string>()
{
[ValidDepts.ExistedDept] = DefaultDeparment.ToString(),
[ValidDepts.ArrayDepts] = $"[{DefaultDeparment}, {NoneExistDepartment}]"
};
var optType = new Dictionary <ValidOptions, string>()
{
[ValidOptions.ExistedOption] = Options.Data[$"{resourceType}1"].Id.ToString(),
[ValidOptions.ArrayOptions] = $"[{Options.Data[$"{resourceType}1"].Id},{Options.Data[$"{resourceType}1"].Id}]"
};
request[ParamMapper[Params.Start]] = startDate.ToString();
request[ParamMapper[Params.End]] = endDate.ToString();
if (user != ValidUsers.Missing)
{
request[ParamMapper[Params.User]] = userType[user];
}
if (dept != ValidDepts.Missing)
{
request[ParamMapper[Params.Dept]] = deptType[dept];
}
if (option != ValidOptions.Missing)
{
request[ParamMapper[Params.Option]] = optType[option];
}
}
/// <summary>Validates the specified value.</summary>
/// <param name="value">The value to validate.</param>
/// <returns>
/// <c>true</c> if <paramref name="value"/> is valid; otherwise <c>false</c> .
/// </returns>
protected internal override bool Validate(object value)
{
return(ValidOptions.Contains(value as string));
}
public void Parse(IEnumerable <string> argv)
{
Options = new List <Option>();
Arguments = new List <string>();
bool needOptArg = false;
bool stopScanning = false;
foreach (string argument in argv)
{
if (stopScanning)
{
Arguments.Add(argument);
continue;
}
if (!argument.StartsWith("-"))
{
if (!needOptArg)
{
Arguments.Add(argument);
continue;
}
Options[Options.Count - 1].Argument = argument;
needOptArg = false;
continue;
}
if (argument == "--")
{
stopScanning = true;
continue;
}
if (argument.StartsWith("--"))
{
string[] parts = argument.Split('=', ':');
string longOpt = parts[0].Substring(2);
ValidOption validOption = GetLongOption(longOpt);
Options.Add(new Option {
Flag = validOption.Flag
});
if (validOption.OptionType != OptionType.None)
{
if (parts.Length > 1)
{
Options[Options.Count - 1].Argument = parts[1];
}
else
{
needOptArg = true;
}
}
continue;
}
foreach (char flag in argument.Where(c => c != '-'))
{
if (ValidOptions.Count(v => v.Flag == flag) == 0)
{
throw new InvalidOptionException(string.Format("{0} is not a valid option.", flag));
}
Options.Add(new Option {
Flag = flag
});
}
needOptArg = ValidOptions.Last(m => m.Flag == Options[Options.Count - 1].Flag).OptionType !=
OptionType.None;
}
}
