public Composition Compose(
JObject input,
Path parentPath)
{
var iterable = _iterable.Compose(
input,
parentPath);
if (!iterable.IsSuccess)
{
throw new NotImplementedException("handle possible problems");
}
if (iterable.Value is JArray array)
{
var results = new List <JToken>();
foreach (var jToken in array)
{
var scopedInput = GetScopedInput(
input,
jToken);
var conditionResult = _condition.Evaluate(
scopedInput);
if (!conditionResult.IsSuccess)
{
throw new NotImplementedException("handle possible problems");
}
if (conditionResult.Value)
{
results.Add(jToken);
}
}
return(new CorrectComposition(
new JArray(results.ToArray())));
}
else
{
var scopedInput = GetScopedInput(
input,
iterable.Value);
var conditionResult = _condition.Evaluate(
scopedInput);
if (!conditionResult.IsSuccess)
{
throw new NotImplementedException("handle possible problems");
}
return(new CorrectComposition(
new JArray(iterable.Value)));
}
}
public Option <PickIndexElementComposition> Compose(
JObject input,
Path parentPath,
int index)
{
var conditionResult = _condition.Evaluate(
input);
if (!conditionResult.IsSuccess)
{
return(new PickIndexElementComposition.Failure(
index,
new PickIndexElementCompositionFailed(
innerErrors: conditionResult.Errors)));
}
if (!conditionResult.Value)
{
return(Option <PickIndexElementComposition> .None);
}
var composition = _valueComposer.Compose(
input,
parentPath);
if (composition.GetDecimal().IsInteger(out var value))
{
return(new PickIndexElementComposition.Success(
index,
new[] { value }));
}
throw new NotImplementedException();
}
public Option <ElementComposition> Compose(
JObject input,
Path parentPath,
int index)
{
var conditionResult = _condition.Evaluate(
input);
if (!conditionResult.IsSuccess)
{
return(ConditionFailure(
parentPath,
index,
conditionResult));
}
if (!conditionResult.Value)
{
return(Option <ElementComposition> .None);
}
return(_elementComposer.Compose(
input,
parentPath,
index));
}
public void Execute()
{
if (_condition.Evaluate())
{
_command.Start();
}
}
public bool React()
{
if (!Condition.Evaluate())
{
return(false);
}
// Go through all the Reactions and call their React function.
for (int i = 0; i < reactions.Length; i++)
{
// The DelayedReaction hides the Reaction.React function.
// Note again this is mainly done for demonstration purposes.
DelayedReaction delayedReaction = reactions[i] as DelayedReaction;
if (delayedReaction)
{
delayedReaction.React(GameObject);
}
else
{
reactions[i].React(GameObject);
}
}
return(true);
}
/// <summary>
/// Check if the user meets audience conditions to be in experiment or not
/// </summary>
/// <param name="config">ProjectConfig Configuration for the project</param>
/// <param name="experiment">Experiment Entity representing the experiment</param>
/// <param name="userAttributes">Attributes of the user. Defaults to empty attributes array if not provided</param>
/// <returns>true if the user meets audience conditions to be in experiment, false otherwise.</returns>
public static bool IsUserInExperiment(ProjectConfig config, Experiment experiment, UserAttributes userAttributes, ILogger logger)
{
if (userAttributes == null)
{
userAttributes = new UserAttributes();
}
ICondition expConditions = null;
if (experiment.AudienceConditionsList != null)
{
expConditions = experiment.AudienceConditionsList;
logger.Log(LogLevel.DEBUG, $@"Evaluating audiences for experiment ""{experiment.Key}"": {experiment.AudienceConditionsString}");
}
else
{
expConditions = experiment.AudienceIdsList;
logger.Log(LogLevel.DEBUG, $@"Evaluating audiences for experiment ""{experiment.Key}"": {experiment.AudienceIdsString}");
}
// If there are no audiences, return true because that means ALL users are included in the experiment.
if (expConditions == null)
{
return(true);
}
var result = expConditions.Evaluate(config, userAttributes, logger).GetValueOrDefault();
var resultText = result.ToString().ToUpper();
logger.Log(LogLevel.INFO, $@"Audiences for experiment ""{experiment.Key}"" collectively evaluated to {resultText}");
return(result);
}
public virtual bool Evaluate(IDelegateExecution execution)
{
if (Condition != null)
{
return(Condition.Evaluate(execution, execution));
}
throw new InvalidOperationException("Condtional event must have a condition!");
}
public ConditionResult Evaluate(JObject input)
{
var innerResult = _innerCondition.Evaluate(
input);
return(innerResult.Select(
(success) => new ConditionResult.Success(!success.Value),
(failure) => failure));
}
private void OnPreviewInvoke(object sender, PreviewInvokeEventArgs e)
{
ICondition condition = Condition;
if (condition != null)
{
e.Cancelling = !condition.Evaluate();
}
}
public bool Evaluate()
{
if (srchById.Evaluate() && srchByName.Evaluate())
{
return(true);
}
else
{
return(false);
}
}
/// <summary>
/// <see cref="IInstruction.Execute" />
/// </summary>
public void Execute()
{
if (_ifCondition.Evaluate())
{
_ifInstruction.Execute();
}
else if (_elseInstruction != null)
{
_elseInstruction.Execute();
}
}
public void Execute()
{
if (!_condition.Evaluate())
{
return;
}
foreach (IOperation op in _operations)
{
op.Execute();
}
}
public Composition Compose(
JObject input,
Path parentPath)
{
var conditionResult = _condition.Evaluate(input);
return(conditionResult.Value
? _ifComposer.Compose(
input,
parentPath)
: _elseComposer.Compose(
input,
parentPath));
}
public void Execute()
{
IEnumerable <IOperation> operations = _condition.Evaluate() ? _operationsThen : _operationsElse;
if (operations == null)
{
return;
}
foreach (IOperation op in operations)
{
op.Execute();
}
}
public Composition Compose(
JObject input,
Path parentPath)
{
var condition = _condition.Evaluate(
input);
if (condition.IsSuccess)
{
return(new CorrectComposition(
new JValue(condition.Value)));
}
return(new IncorrectComposition(
parentPath,
condition.Errors));
}
public ConditionResult Evaluate(JObject input)
{
var leftResult = _left.Evaluate(
input);
return(leftResult.Select(
(leftSuccess) =>
{
if (leftSuccess.Value)
{
return new ConditionResult.Success(true);
}
return _right.Evaluate(
input);
},
(failure) => failure));
}
/// <summary>
/// Check if the user meets audience conditions to be in experiment or not
/// </summary>
/// <param name="config">ProjectConfig Configuration for the project</param>
/// <param name="experiment">Experiment Entity representing the experiment</param>
/// <param name="userAttributes">Attributes of the user. Defaults to empty attributes array if not provided</param>
/// <param name="loggingKeyType">It can be either experiment or rule.</param>
/// <param name="loggingKey">In case loggingKeyType is experiment it will be experiment key or else it will be rule number.</param>
/// <returns>true if the user meets audience conditions to be in experiment, false otherwise.</returns>
public static Result <bool> DoesUserMeetAudienceConditions(ProjectConfig config,
Experiment experiment,
UserAttributes userAttributes,
string loggingKeyType,
string loggingKey,
ILogger logger)
{
var reasons = new DecisionReasons();
if (userAttributes == null)
{
userAttributes = new UserAttributes();
}
ICondition expConditions = null;
if (experiment.AudienceConditionsList != null)
{
expConditions = experiment.AudienceConditionsList;
logger.Log(LogLevel.DEBUG, $@"Evaluating audiences for {loggingKeyType} ""{loggingKey}"": {experiment.AudienceConditionsString}.");
}
else
{
expConditions = experiment.AudienceIdsList;
logger.Log(LogLevel.DEBUG, $@"Evaluating audiences for {loggingKeyType} ""{loggingKey}"": {experiment.AudienceIdsString}.");
}
// If there are no audiences, return true because that means ALL users are included in the experiment.
if (expConditions == null)
{
return(Result <bool> .NewResult(true, reasons));
}
var result = expConditions.Evaluate(config, userAttributes, logger).GetValueOrDefault();
var resultText = result.ToString().ToUpper();
logger.Log(LogLevel.INFO, reasons.AddInfo($@"Audiences for {loggingKeyType} ""{loggingKey}"" collectively evaluated to {resultText}"));
return(Result <bool> .NewResult(result, reasons));
}
public Option <PropertyComposition> Compose(
JObject input,
Path parentPath)
{
var conditionResult = _condition.Evaluate(
input);
if (!conditionResult.IsSuccess)
{
return(ConditionFailure(
parentPath,
conditionResult));
}
if (!conditionResult.Value)
{
return(Option <PropertyComposition> .None);
}
return(_propertyComposer.Compose(
input,
parentPath));
}
public bool Evaluate(ConditionSettings settings, params string[] replacements)
{
return(!_condition.Evaluate(settings, replacements));
}
bool ITransition.IsTriggered(FTrigger trigger)
{
return(this._trigger == trigger && (_condition == null || _condition.Evaluate()));
}
public virtual bool Evaluate(IInstanceResolver resolver, object context)
{
return(evaluation.Evaluate(context));
}
protected override bool Condition(T instance)
{
return(_condition.Evaluate(instance));
}
/// <summary>Evaluates the condition</summary>
public override bool Evaluate()
{
return(m_cond1.Evaluate() && m_cond2.Evaluate());
}
public override bool Evaluate(Facts facts)
{
return(_condition.Evaluate(facts));
}
/// <summary>
/// Evalutes the Condition against the Question's answer.
/// </summary>
/// <param name="actor">The Screenplay Actor.</param>
/// <returns></returns>
public bool Evaluate(IActor actor)
{
_answer = actor.AsksFor(Question);
return(Condition.Evaluate(_answer));
}
/// <summary>Evaluates the condition</summary>
public override bool Evaluate()
{
return(!m_cond.Evaluate());
}
public override bool Evaluate <T>(T context)
{
return(_condition.Evaluate(context));
}
/// <summary>
/// <see cref="ICondition.Evaluate" />
/// </summary>
public bool Evaluate()
{
return(!_condition.Evaluate());
}
