// validate --duration based on --run-loop
static string ValidateDuration(CommandResult result)
{
OptionResult runLoop = null;
OptionResult duration = null;
foreach (OptionResult c in result.Children)
{
if (c.Symbol.Name == "duration")
{
duration = c;
}
else if (c.Symbol.Name == "run-loop")
{
runLoop = c;
}
}
if (runLoop == null || runLoop.Token == null || (runLoop.Tokens.Count > 0 && !bool.Parse(runLoop.Tokens[0].Value)))
{
if (duration != null && duration.Tokens != null && duration.Tokens.Count > 0 && int.TryParse(duration.Tokens[0].Value, out int d) && d > 0)
{
return("--run-loop must be true to use --duration");
}
}
return(string.Empty);
}
// this could be further broken down into another class (IntegerSettingOption) but not right now
protected override OptionResult Run(GameHitParameters <GameObject> parameters)
{
OptionResult result = base.Run(parameters);
if (result != OptionResult.Failure)
{
string text = StringInputDialog.Show(Name, Common.Localize(GetTitlePrefix() + ":Prompt", false), ""); // def
if (string.IsNullOrEmpty(text))
{
return(OptionResult.Failure);
}
int value;
if (!int.TryParse(text, out value))
{
SimpleMessageDialog.Show(Name, Common.Localize("Numeric:Error"));
return(OptionResult.Failure);
}
foreach (OccupationNames name in base.mPicks)
{
NRaas.CareerSpace.PersistedSettings.CareerSettings settings = NRaas.Careers.Settings.GetCareerSettings(name, true);
settings.minCoworkers = value;
NRaas.Careers.Settings.UpdateCareerSettings(settings);
}
Common.Notify("Generic:Success");
return(OptionResult.SuccessLevelDown);
}
return(result);
}
// validate --random based on --run-loop
static string ValidateRandom(CommandResult result)
{
OptionResult runLoop = null;
OptionResult random = null;
foreach (OptionResult c in result.Children)
{
if (c.Symbol.Name == "run-loop")
{
runLoop = c;
}
else if (c.Symbol.Name == "random")
{
random = c;
}
}
if (runLoop == null || runLoop.Token == null || (runLoop.Tokens.Count > 0 && !bool.Parse(runLoop.Tokens[0].Value)))
{
if (random != null && random.Token != null && random.Tokens != null && (random.Tokens.Count == 0 || bool.Parse(random.Tokens[0].Value)))
{
return("--run-loop must be true to use --random");
}
}
return(string.Empty);
}
/// <summary>
/// Validates that the specified option result is an unsigned integer.
/// </summary>
private static void ValidateOptionValueIsUnsignedInteger(OptionResult result)
{
if (result.Tokens.Select(token => token.Value).Where(v => !uint.TryParse(v, out _)).Any())
{
result.ErrorMessage = $"Please give a positive integer to option '{result.Option.Name}'.";
}
}
private string?GetValueForOption(string parameterName, OptionResult optionResult)
{
//if default value is used, no need to return it - it will be populated in template engine edge instead.
if (optionResult.IsImplicit)
{
return(null);
}
var optionValue = optionResult.GetValueOrDefault();
if (optionValue == null)
{
return(null);
}
if (!Template.CliParameters.TryGetValue(parameterName, out CliTemplateParameter? parameter))
{
throw new InvalidOperationException($"Parameter {parameterName} is not defined for {Template.Identity}.");
}
if (parameter.Type == ParameterType.Hex && optionResult.Option.ValueType == typeof(long))
{
var intValue = (long)optionValue;
return($"0x{intValue.ToString("X")}");
}
return(optionValue.ToString());
}
// this could be further broken down into another class (IntegerSettingOption) but not right now
protected override OptionResult Run(GameHitParameters <GameObject> parameters)
{
OptionResult result = base.Run(parameters);
if (result != OptionResult.Failure)
{
foreach (OccupationNames name in base.mPicks)
{
string defaultText = string.Empty;
if (name != OccupationNames.Any)
{
NRaas.CareerSpace.PersistedSettings.CareerSettings settings = NRaas.Careers.Settings.GetCareerSettings(name, true);
defaultText = settings.mMaxCoworkers.ToString();
}
string text = StringInputDialog.Show(Name, Common.Localize(GetTitlePrefix() + ":Prompt", false), defaultText);
if (string.IsNullOrEmpty(text))
{
return(OptionResult.Failure);
}
int value;
if (!int.TryParse(text, out value))
{
SimpleMessageDialog.Show(Name, Common.Localize("InputError:Numeric"));
return(OptionResult.Failure);
}
if (name == OccupationNames.Any)
{
foreach (Career career in CareerManager.CareerList)
{
PersistedSettings.CareerSettings settings = NRaas.Careers.Settings.GetCareerSettings(career.Guid, true);
settings.mMaxCoworkers = value;
NRaas.Careers.Settings.SetCareerData(settings);
}
Common.Notify(GetTitlePrefix() + " " + Common.Localize("Selection:All") + " " + value);
}
else
{
PersistedSettings.CareerSettings settings = NRaas.Careers.Settings.GetCareerSettings(name, true);
settings.mMaxCoworkers = value;
NRaas.Careers.Settings.SetCareerData(settings);
Common.Notify(GetTitlePrefix() + " " + CareerManager.GetStaticCareer(name).Name + " " + value);
}
}
Common.Notify(Common.Localize("Generic:Success"));
return(OptionResult.SuccessLevelDown);
}
return(result);
}
protected override OptionResult Run(GameHitParameters <Sim> parameters)
{
OptionResult result = OptionResult.Failure;
if (mCategory == OutfitCategories.PrimaryCategories)
{
List <AddOutfit> outfits = new List <AddOutfit> ();
GetOptions(outfits);
foreach (AddOutfit outfit in outfits)
{
if (outfit.mCategory == OutfitCategories.PrimaryCategories)
{
continue;
}
ApplyOutfit(parameters.mTarget.SimDescription, outfit.mCategory);
}
result = OptionResult.SuccessClose;
}
else
{
result = ApplyOutfit(parameters.mTarget.SimDescription, mCategory);
if (result != OptionResult.Failure)
{
CommonSpace.Helpers.SwitchOutfits.SwitchNoSpin(parameters.mTarget, new CASParts.Key(mCategory, 0));
}
}
return(result);
}
internal static OptionResult CreateImplicit(
IOption option,
CommandResult parent)
{
var result = new OptionResult(option,
option.Token());
result.IsImplicit = true;
if (option.Argument.HasDefaultValue)
{
var value = option.Argument.GetDefaultValue();
switch (value)
{
case string arg:
result.TryTakeToken(new Token(arg, TokenType.Argument));
break;
default:
result.Result = ArgumentParseResult.Success(value);
break;
}
}
return(result);
}
public void SetEventData()
{
currentEvent = database.GetEventData();
InGameUI.Instance.skyText.text = currentEvent.eventText;
if (!string.IsNullOrEmpty(currentEvent.choiceOne.choice))
{
InGameUI.Instance.leftChoiceText.text = "[ " + currentEvent.choiceOne.choice;
InGameUI.Instance.leftChoice.onClick.AddListener(() =>
{
result = currentEvent.choiceOne.result;
ShowPanel(currentEvent.choiceOne.detail);
ClearUIText();
});
}
if (!string.IsNullOrEmpty(currentEvent.choiceTwo.choice))
{
InGameUI.Instance.rightChoiceText.text = currentEvent.choiceTwo.choice + " ]";
InGameUI.Instance.rightChoice.onClick.AddListener(() =>
{
result = currentEvent.choiceTwo.result;
ShowPanel(currentEvent.choiceTwo.detail);
ClearUIText();
});
}
}
protected override OptionResult Run(GameHitParameters <GameObject> parameters)
{
RecipeSelection recipeSelection = RecipeSelection.Create(new List <string>(Cupcake.Settings.mRandomRestockSettings.Keys));
OptionResult recipeResult = recipeSelection.Perform();
if (recipeResult != OptionResult.SuccessClose)
{
return(OptionResult.Failure);
}
QualitySelection qualitySelection = QualitySelection.Create(new List <Quality>(Cupcake.Settings.RandomRestockQualitiesAsList()));
OptionResult qualityResult = qualitySelection.Perform();
if (qualityResult != OptionResult.SuccessClose)
{
return(OptionResult.Failure);
}
foreach (Recipe recipe in recipeSelection.selectedItems)
{
Cupcake.Settings.AddRandomRestockRecipe(recipe.Key, qualitySelection.selectedItems);
}
Common.Notify(Common.Localize("General:Success"));
return(OptionResult.SuccessClose);
}
protected override OptionResult Run(GameHitParameters <GameObject> parameters)
{
OptionResult result = base.Run(parameters);
if (result != OptionResult.Failure)
{
switch (Value)
{
case SaveStyle.RealTime:
if (Saver.Settings.mRealMinutesBetweenSaves <= 0)
{
Saver.Settings.mRealMinutesBetweenSaves = 30;
}
break;
case SaveStyle.SimTime:
if (Saver.Settings.mSimMinutesBetweenSaves <= 0)
{
Saver.Settings.mSimMinutesBetweenSaves = 1440;
}
break;
case SaveStyle.SimHour:
if (Saver.Settings.mSimSaveHour.Count == 0)
{
Saver.Settings.mSimSaveHour.Add(5);
}
break;
}
Saver.RestartTimers();
}
return(result);
}
public void UpdateOptionResult(Guid id, OptionResult updatedResult)
{
var result = _context.OptionResults.FirstOrDefault(u => u.Id == id);
result.IsChecked = updatedResult.IsChecked;
_context.SaveChanges();
}
private static bool IsNotImplicit(SymbolResult symbolResult)
{
return(symbolResult switch
{
ArgumentResult argumentResult => !argumentResult.IsImplicit,
OptionResult optionResult => !optionResult.IsImplicit,
_ => true
});
private static MemberResultValueFrom GetValueFrom(OptionResult optionResult)
{
return(optionResult is null
? MemberResultValueFrom.DefaultFromType
: optionResult.Token is null
? MemberResultValueFrom.DefaultFromCli
: MemberResultValueFrom.UserEntry);
}
/// <summary>
/// Validates that the specified option result has an allowed value.
/// </summary>
private static void ValidateOptionValueIsAllowed(OptionResult result, IEnumerable <string> allowedValues)
{
if (result.Tokens.Select(token => token.Value).Where(v => !allowedValues.Contains(v)).Any())
{
result.ErrorMessage = $"Please give an allowed value to option '{result.Option.Name}': " +
$"{string.Join(", ", allowedValues)}.";
}
}
/// <summary>
/// Validates that the specified exclusive option is available.
/// </summary>
private static void ValidateExclusiveOptionValueIsAvailable(OptionResult result, Option exclusive)
{
OptionResult exclusiveResult = result.FindResultFor(exclusive);
if (!result.IsImplicit && exclusiveResult != null && !exclusiveResult.IsImplicit)
{
result.ErrorMessage = $"Setting options '{result.Option.Name}' and '{exclusive.Name}' at the same time is not allowed.";
}
}
internal static Token Token(this SymbolResult symbolResult)
{
return(symbolResult switch
{
CommandResult commandResult => commandResult.Token,
OptionResult optionResult => optionResult.Token ??
new Token($"--{optionResult.Option.Name}", TokenType.Option),
_ => null
});
private static string OutputValidiator(OptionResult optionResult)
{
ArgumentNullException.ThrowIfNull(optionResult);
var outPath = optionResult?.GetValueOrDefault <string>();
if (outPath is null)
{
return(default);
/// <summary>
/// Validates that the specified prerequisite option is available.
/// </summary>
private static void ValidatePrerequisiteOptionValueIsAvailable(OptionResult result, Option prerequisite)
{
OptionResult prerequisiteResult = result.FindResultFor(prerequisite);
if (!result.IsImplicit && (prerequisiteResult is null || prerequisiteResult.IsImplicit))
{
result.ErrorMessage = $"Setting option '{result.Option.Name}' requires option '{prerequisite.Name}'.";
}
}
protected override OptionResult Run(GameHitParameters <GameObject> parameters)
{
OptionResult result = base.Run(parameters);
if (result != OptionResult.Failure)
{
Item selection = new CommonSelection <Item>(Name, this.GetCarOptions()).SelectSingle();
if (selection == null)
{
return(OptionResult.Failure);
}
foreach (CareerLevelSettingOption.LevelData level in base.mPicks)
{
if (level.mLevel == -1)
{
foreach (Career career in CareerManager.CareerList)
{
foreach (string branch in career.CareerLevels.Keys)
{
foreach (KeyValuePair <int, Sims3.Gameplay.Careers.CareerLevel> levelData in career.CareerLevels[branch])
{
PersistedSettings.CareerSettings settings = NRaas.Careers.Settings.GetCareerSettings(level.mCareer, true);
PersistedSettings.CareerLevelSettings levelSettings = settings.GetSettingsForLevel(level.mBranchName, level.mLevel, true);
levelSettings.mCarpoolType = selection.Value;
levelData.Value.CarpoolType = selection.Value;
}
}
}
}
else
{
PersistedSettings.CareerSettings settings = NRaas.Careers.Settings.GetCareerSettings(level.mCareer, true);
PersistedSettings.CareerLevelSettings levelSettings = settings.GetSettingsForLevel(level.mBranchName, level.mLevel, true);
levelSettings.mCarpoolType = selection.Value;
NRaas.Careers.Settings.SetCareerData(settings);
}
}
foreach (Sim sim in LotManager.Actors)
{
if (sim.Occupation != null)
{
sim.Occupation.RescheduleCarpool();
}
}
Common.Notify(Common.Localize("Generic:Success"));
return(OptionResult.SuccessLevelDown);
}
return(result);
}
public TradeOptionViewModel(BindingList <PortfolioData> portfolioList, OptionResult selectedOption)
{
this.TradeOptionCommand = new DelegateCommand <object>(this.TradeOption);
this.CloseWindowCommand = new DelegateCommand <object>(this.Close);
this.selectedOption = selectedOption;
this.portfolioList = portfolioList;
this.actionWarningLabel = new WarningLabel();
this.notionalWarningLabel = new WarningLabel();
}
public ActionResult CollaborateList(SearchCollaborateModel model, OptionResult option)
{
if (Session["loginid"].ToString() != "admin")
{
model.NguoiDi = Int32.Parse(Session["userid"].ToString());
}
var result = _dataService.CollaborateMany(model, option);
return(Json(result, JsonRequestBehavior.AllowGet));
}
public static string Validator <T>(OptionResult result, Func <T, bool> validator)
{
var value = result.GetValueOrDefault <T>();
if (!validator(value))
{
return($"Option {result.Token?.Value} cannot be set to {value}");
}
return(string.Empty);
}
protected override OptionResult Run(GameHitParameters <GameObject> parameters)
{
OptionResult result = base.Run(parameters);
if (result != OptionResult.Failure)
{
PersistedSettings.ResetSpeeds();
}
return(result);
}
protected override OptionResult Run(GameHitParameters <GameObject> parameters)
{
OptionResult result = base.Run(parameters);
if (result != OptionResult.Failure)
{
PriorValues.sFactorChanged = true;
}
return(result);
}
internal static Token Token(this SymbolResult symbolResult)
{
return(symbolResult switch
{
CommandResult commandResult => commandResult.Token,
OptionResult optionResult => optionResult.Token ??
new Token($"--{optionResult.Option.Name}", TokenType.Option),
ArgumentResult argResult => new Token(argResult.GetValueOrDefault <string>(), TokenType.Argument),
_ => null
});
protected override OptionResult Run(GameHitParameters <GameObject> parameters)
{
OptionResult result = base.Run(parameters);
if (result != OptionResult.Failure)
{
Saver.RestartTimers();
}
return(result);
}
public void An_option_with_a_default_value_and_no_explicitly_provided_argument_has_an_empty_arguments_property()
{
var option = new Option(
"-x",
"",
new Argument <string>("default"));
var result = new OptionResult(option);
result.Arguments.Should().BeEmpty();
}
protected override OptionResult Run(GameHitParameters <GameObject> parameters)
{
OptionResult result = base.Run(parameters);
if (result != OptionResult.Failure)
{
UpdateTrafficTaskEx.ApplyTrafficDelta();
}
return(result);
}
private static void ValidateAllowedValues(OptionResult optionResult, string[] allowedValues, string?allowedHiddenValue = null)
{
var invalidArguments = optionResult.Tokens.Where(token => !allowedValues.Append(allowedHiddenValue).Contains(token.Value, StringComparer.OrdinalIgnoreCase)).ToList();
if (invalidArguments.Any())
{
optionResult.ErrorMessage = string.Format(
LocalizableStrings.Commands_Validator_WrongArgumentValue,
string.Join(", ", invalidArguments.Select(arg => $"'{arg.Value}'")),
string.Join(", ", allowedValues.Select(allowedValue => $"'{allowedValue}'")));
}
}
