public void SplitNamesReturnSuccessfully()
{
//Arrange
var conditionsWithLogic = new List <ConditionDefinition>();
var conditionWithLogic = new ConditionDefinition()
{
partitions = new List <PartitionDefinition>()
{
new PartitionDefinition()
{
size = 100, treatment = "on"
}
}
};
conditionsWithLogic.Add(conditionWithLogic);
var splitCache = new Mock <ISplitCache>();
var splits = new List <SplitBase>();
splits.Add(new Split()
{
name = "test1", changeNumber = 10000, killed = false, trafficTypeName = "user", seed = -1, conditions = conditionsWithLogic
});
splits.Add(new Split()
{
name = "test2", conditions = conditionsWithLogic
});
splits.Add(new Split()
{
name = "test3", conditions = conditionsWithLogic
});
splits.Add(new Split()
{
name = "test4", conditions = conditionsWithLogic
});
splits.Add(new Split()
{
name = "test5", conditions = conditionsWithLogic
});
splits.Add(new Split()
{
name = "test6", conditions = conditionsWithLogic
});
splitCache.Setup(x => x.GetAllSplits()).Returns(splits);
var manager = new RedisSplitManager(splitCache.Object);
//Act
var result = manager.SplitNames();
//Assert
Assert.IsNotNull(result);
Assert.AreEqual(6, result.Count);
var firstResult = result.Find(x => x == "test1");
Assert.AreEqual(firstResult, "test1");
}
private void AddConditionButton_Click(object sender, EventArgs e)
{
ConditionDefinition newDef = new ConditionDefinition();
newDef.DBID = GetNewDBID();
newDef.Type = "NewCondition";
mTriggerDefinition.ConditionDefinitions.Add(newDef);
RefreshUI();
ConditionsListBox.SelectedItem = "NewCondition";
}
public EffectFormBuilder SetConditionForm(ConditionDefinition condition, ConditionForm.ConditionOperation operation, bool applyToSelf, bool forceOnSelf, List <ConditionDefinition> detrimentalConditions)
{
effectForm.FormType = EffectForm.EffectFormType.Condition;
ConditionForm conditionForm = new ConditionForm
{
Operation = operation,
ConditionDefinition = condition
};
conditionForm.SetConditionDefinitionName(condition.Name);
conditionForm.SetApplyToSelf(applyToSelf);
conditionForm.SetForceOnSelf(forceOnSelf);
conditionForm.SetField("detrimentalConditions", detrimentalConditions);
effectForm.ConditionForm = conditionForm;
return(this);
}
public void SplitReturnSuccessfully()
{
//Arrange
var conditionsWithLogic = new List <ConditionDefinition>();
var conditionWithLogic = new ConditionDefinition()
{
conditionType = "rollout",
partitions = new List <PartitionDefinition>()
{
new PartitionDefinition()
{
size = 100, treatment = "on"
}
}
};
conditionsWithLogic.Add(conditionWithLogic);
var split = new Split {
name = "test1", changeNumber = 10000, killed = false, trafficTypeName = "user", seed = -1, conditions = conditionsWithLogic
};
_splitCache
.Setup(x => x.GetSplit("test1"))
.Returns(split);
_blockUntilReadyService
.Setup(mock => mock.IsSdkReady())
.Returns(true);
//Act
var result = manager.Split("test1");
//Assert
Assert.IsNotNull(result);
Assert.AreEqual(result.name, "test1");
Assert.AreEqual(result.changeNumber, 10000);
Assert.AreEqual(result.killed, false);
Assert.AreEqual(result.trafficType, "user");
Assert.AreEqual(result.treatments.Count, 1);
var firstTreatment = result.treatments[0];
Assert.AreEqual(firstTreatment, "on");
}
public void SplitReturnEmptyTreatmentsWhenNoRolloutCondition()
{
//Arrange
var conditionsWithLogic = new List <ConditionDefinition>();
var conditionWithLogic = new ConditionDefinition()
{
conditionType = "whitelist",
partitions = new List <PartitionDefinition>()
{
new PartitionDefinition()
{
size = 100, treatment = "on"
},
}
};
conditionsWithLogic.Add(conditionWithLogic);
var splitCache = new Mock <ISplitCache>();
var split = new Split()
{
name = "test1", changeNumber = 10000, killed = false, trafficTypeName = "user", seed = -1, conditions = conditionsWithLogic
};
splitCache.Setup(x => x.GetSplit("test1")).Returns(split);
var manager = new RedisSplitManager(splitCache.Object);
//Act
var result = manager.Split("test1");
//Assert
Assert.IsNotNull(result);
Assert.AreEqual(result.name, "test1");
Assert.AreEqual(result.treatments.Count, 0);
}
public override IEnumerable <TransitionDefinition> ParseTransitions(XElement schemeMedium, IEnumerable <ActorDefinition> actorDefinitions, IEnumerable <CommandDefinition> commandDefinitions, IEnumerable <ActionDefinition> actionDefinitions, IEnumerable <ActivityDefinition> activityDefinitions, IEnumerable <TimerDefinition> timerDefinitions)
{
if (schemeMedium == null)
{
throw new ArgumentNullException("schemeMedium");
}
if (commandDefinitions == null)
{
throw new ArgumentNullException("commandDefinitions");
}
if (actionDefinitions == null)
{
throw new ArgumentNullException("actionDefinitions");
}
if (activityDefinitions == null)
{
throw new ArgumentNullException("activityDefinitions");
}
var transitionElements = schemeMedium.SingleOrDefault("Transitions");
if (transitionElements == null)
{
throw new ArgumentNullException("");
}
var commandDefinitionsList = commandDefinitions.ToList();
var actionDefinitionsList = actionDefinitions.ToList();
var activityDefinitionsList = activityDefinitions.ToList();
var actorDefinitionsList = actorDefinitions.ToList();
var timerDefinitionsList = timerDefinitions.ToList();
var transitions = new List <TransitionDefinition>();
foreach (var transitionElement in transitionElements.Elements().ToList())
{
var fromActivity = activityDefinitionsList.Single(ad => ad.Name == GetFrom(transitionElement));
var toActivity = activityDefinitionsList.Single(ad => ad.Name == GetTo(transitionElement));
TriggerDefinition trigger = null;
var triggersElement = transitionElement.Element("Triggers");
if (triggersElement != null)
{
var triggerElement = triggersElement.Element("Trigger");
if (triggerElement != null)
{
trigger = TriggerDefinition.Create(GetType(triggerElement));
if (trigger.Type == TriggerType.Command)
{
(trigger as CommandTriggerDefinition).Command =
commandDefinitionsList.Single(cd => cd.Name == GetNameRef(triggerElement));
}
else if (trigger.Type == TriggerType.Timer)
{
(trigger as TimerTriggerDefinition).Timer =
timerDefinitionsList.Single(cd => cd.Name == GetNameRef(triggerElement));
}
}
}
ConditionDefinition condition = null;
var conditionsElement = transitionElement.Element("Conditions");
if (conditionsElement != null)
{
var conditionElement = conditionsElement.Element("Condition");
if (conditionElement != null)
{
condition = !string.IsNullOrEmpty(GetNameRefNullable(conditionElement))
? ConditionDefinition.Create(GetType(conditionElement), actionDefinitionsList.Single(ad => ad.Name == GetNameRef(conditionElement)), GetResultOnPreExecution(conditionElement))
: ConditionDefinition.Create(GetType(conditionElement), GetResultOnPreExecution(conditionElement));
}
}
var transition = TransitionDefinition.Create(GetName(transitionElement), GetClassifier(transitionElement), fromActivity,
toActivity, trigger, condition);
var restrictionsElement = transitionElement.Element("Restrictions");
if (restrictionsElement != null)
{
foreach (var element in restrictionsElement.Elements("Restriction"))
{
transition.AddRestriction(RestrictionDefinition.Create(GetType(element), actorDefinitionsList.Single(ad => ad.Name == GetNameRef(element))));
}
}
var onErrorsElement = transitionElement.Element("OnErrors");
if (onErrorsElement != null)
{
foreach (var element in onErrorsElement.Elements("OnError"))
{
//TODO Only One Type Of OnErrorHandler
transition.AddOnError(OnErrorDefinition.CreateSetActivityOnError(GetName(element), GetNameRef(element), GetPriority(element), GetTypeName(element) /*, GetIsExecuteImplementation(element),GetIsRethrow(element)*/));
}
}
transitions.Add(transition);
}
return(transitions);
}
public static T SetCondition <T>(this T entity, ConditionDefinition value)
where T : BehaviorModeDescription
{
entity.SetField("condition", value);
return(entity);
}
public static T SetTargetConditionAsset <T>(this T entity, ConditionDefinition value)
where T : EffectDescription
{
entity.SetField("targetConditionAsset", value);
return(entity);
}
void VersionListBox_SelectedIndexChanged(object sender, EventArgs e)
{
SaveToNewVersionButton.Enabled = false;
SaveToSelectedButton.Enabled = false;
mTempCondDef = null;
mTempEffectDef = null;
ConditionDefinition condDef = VersionListBox.SelectedItem as ConditionDefinition;
EffectDefinition effDef = VersionListBox.SelectedItem as EffectDefinition;
mCurrentCondDef = condDef;
mCurrentEffectDef = effDef;
TriggerComponentDefinition compDef = VersionListBox.SelectedItem as TriggerComponentDefinition;
if (condDef != null)
{
mTempCondDef = new ConditionDefinition();
condDef.CopyTo(mTempCondDef);
ItemPropertyGrid.SelectedObject = mTempCondDef;
InVariblesList.ObjectList = mTempCondDef.InParameterDefinitions;
OutVariablesList.ObjectList = mTempCondDef.OutParameterDefinitions;
ConversionList.ObjectList = mTempCondDef.ParameterConversionOverrides;
}
if (effDef != null)
{
mTempEffectDef = new EffectDefinition();
effDef.CopyTo(mTempEffectDef);
ItemPropertyGrid.SelectedObject = mTempEffectDef;
InVariblesList.ObjectList = mTempEffectDef.InParameterDefinitions;
OutVariablesList.ObjectList = mTempEffectDef.OutParameterDefinitions;
ConversionList.ObjectList = mTempEffectDef.ParameterConversionOverrides;
}
if (compDef != null)
{
int version = compDef.Version;
if (version > 1)
{
TriggerComponentDefinition lastversion = null;
foreach (object o in mEntries[compDef.Type])
{
TriggerComponentDefinition oldCompDef = o as TriggerComponentDefinition;
if (oldCompDef != null)
{
if (oldCompDef.Version == version - 1)
{
lastversion = oldCompDef;
break;
}
}
}
ConversionList.AddMetaDataForProp("ParameterConversionOverride", "OldParameter", "StringIntEnumeration", GetParameterConversionInfo(lastversion));
ConversionList.AddMetaDataForProp("ParameterConversionOverride", "NewParameter", "StringIntEnumeration", GetParameterConversionInfo(compDef));
ConversionList.ObjectList = compDef.ParameterConversionOverrides;
}
}
}
public EffectDescriptionBuilder SetRequiredCondition(ConditionDefinition targetConditionAsset)
{
effect.SetTargetConditionAsset(targetConditionAsset);
effect.SetTargetConditionName(targetConditionAsset.Name);
return(this);
}
public EffectFormBuilder SetSummonForm(SummonForm.Type summonType, ItemDefinition item, int number, string monsterDefinitionName, ConditionDefinition conditionDefinition,
bool persistOnConcentrationLoss, DecisionPackageDefinition decisionPackage, EffectProxyDefinition effectProxyDefinition)
{
effectForm.FormType = EffectForm.EffectFormType.Summon;
SummonForm summonForm = new SummonForm();
summonForm.SetSummonType(summonType);
summonForm.SetItemDefinition(item);
summonForm.SetNumber(number);
summonForm.SetMonsterDefinitionName(monsterDefinitionName);
summonForm.SetConditionDefinition(conditionDefinition);
summonForm.SetPersistOnConcentrationLoss(persistOnConcentrationLoss);
summonForm.SetDecisionPackage(decisionPackage);
summonForm.SetEffectProxyDefinitionName(effectProxyDefinition.Name);
effectForm.SetSummonForm(summonForm);
return(this);
}
public static T SetConditionDefinition <T>(this T entity, ConditionDefinition value)
where T : ItemPropertyDescription
{
entity.SetField("conditionDefinition", value);
return(entity);
}
public override void RegisterFinal(ProcessDefinition pd, List <WorkflowBlock> blocks)
{
//transitions
var commands = this["Commands"] as List <SimpleCommand>;
if (commands != null)
{
var restrictions = new List <RestrictionDefinition>();
if (this["_actorRestrictions"] is ActorDefinition)
{
restrictions.Add(RestrictionDefinition.Create(RestrictionType.Allow, (ActorDefinition)this["_actorRestrictions"]));
}
foreach (var c in commands)
{
var pdCommand = pd.Commands.Where(pdc => pdc.Name == c.Name).FirstOrDefault();
if (pdCommand == null)
{
pdCommand = CommandDefinition.Create(c.Name);
pd.Commands.Add(pdCommand);
}
if (c.Classifier == TransitionClassifier.Direct)
{
//CA
pd.Transitions.Add(new TransitionDefinition()
{
Name = string.Format("{0}_{1}_{2}", Name, c.ToBlock.Name, c.Name),
Classifier = c.Classifier,
From = (ActivityDefinition)this["_currentActivity"],
To = (ActivityDefinition)this["_currentActivity"],
Trigger = new TriggerDefinition(TriggerType.Command)
{
Command = pdCommand
},
Conditions = new List <ConditionDefinition>()
{
ConditionDefinition.Always
},
Restrictions = restrictions
});
//AC
pd.Transitions.Add(new TransitionDefinition()
{
Name = string.Format("{0}_{1}_{2}", Name, c.ToBlock.Name, "Auto"),
Classifier = c.Classifier,
From = (ActivityDefinition)this["_currentActivity"],
To = (ActivityDefinition)c.ToBlock["_currentActivity"],
Trigger = new TriggerDefinition(TriggerType.Auto),
Conditions = new List <ConditionDefinition>()
{
ConditionDefinition.Create("Action", ActionDefinitionReference.Create("BudgetItemIsLegalEntitySignsComplete", "0", Name), "false", "true")
}
});
}
else
{
pd.Transitions.Add(new TransitionDefinition()
{
Name = string.Format("{0}_{1}_{2}", Name, c.ToBlock.Name, c.Name),
Classifier = c.Classifier,
From = (ActivityDefinition)this["_currentActivity"],
To = (ActivityDefinition)c.ToBlock["_currentActivity"],
Trigger = new TriggerDefinition(TriggerType.Command)
{
Command = pdCommand
},
Conditions = new List <ConditionDefinition>()
{
ConditionDefinition.Always
},
Restrictions = restrictions
});
}
}
}
}
public static ExecutionRequestParameters Create(Guid processId, IEnumerable <ParameterDefinitionWithValue> parameters, ActivityDefinition activityToExecute, ConditionDefinition condition, bool isPreExecution)
{
List <ActionDefinitionForActivity> implementation = isPreExecution
? activityToExecute.PreExecutionImplemementation
: activityToExecute.Implemementation;
if (parameters == null)
{
throw new ArgumentNullException("parameters");
}
var parametersList = parameters.ToList();
var methods = new List <MethodToExecuteInfo>(implementation.Count);
var executionParameters = new ExecutionRequestParameters
{
ProcessId = processId,
ConditionType = condition.Type,
ConditionResultOnPreExecution = condition.ResultOnPreExecution,
ConditionMethod = condition.Type == ConditionType.Action ? GetMethodToExecuteInfo(parametersList, ActionDefinition.Create(condition.Action, 0)) : null,
};
methods.AddRange(implementation.Select(method => GetMethodToExecuteInfo(parametersList, method)));
var parameters1 = new List <ParameterContainerInfo>();
parameters1.AddRange(parameters.Where(p => p.Name != DefaultDefinitions.ParameterExecutedActivityState.Name).Select(p => new ParameterContainerInfo()
{
Name = p.Name, Type = p.Type, Value = p.Value
}));
parameters1.Add(new ParameterContainerInfo {
Name = DefaultDefinitions.ParameterExecutedActivityState.Name, Type = DefaultDefinitions.ParameterExecutedActivityState.Type, Value = activityToExecute.State
});
executionParameters.ParameterContainer = parameters1.ToArray();
executionParameters.Methods = methods.ToArray();
executionParameters.ActivityName = activityToExecute.Name;
return(executionParameters);
}
public void AddCancellingConditions(ConditionDefinition cancellingConditions)
{
condition.CancellingConditions.Add(cancellingConditions);
}
public void SetAdditionalConditionWhenHitFields(bool additionalConditionWhenHit, ConditionDefinition additionalCondition, RuleDefinitions.DurationType additionalConditionDurationType,
int additionalConditionDurationParameter)
{
Traverse.Create(condition).Field("additionalConditionWhenHit").SetValue(additionalConditionWhenHit);
Traverse.Create(condition).Field("additionalCondition").SetValue(additionalCondition);
Traverse.Create(condition).Field("additionalConditionDurationType").SetValue(additionalConditionDurationType);
Traverse.Create(condition).Field("additionalConditionDurationParameter").SetValue(additionalConditionDurationParameter);
}
public void SetParentCondition(ConditionDefinition parentCondition)
{
Traverse.Create(condition).Field("parentCondition").SetValue(parentCondition);
}
public void SetSubsequentOnRemoval(ConditionDefinition subsequentOnRemoval)
{
Traverse.Create(condition).Field("subsequentOnRemoval").SetValue(subsequentOnRemoval);
}
public ConditionBuilder()
{
condition = ScriptableObject.CreateInstance <ConditionDefinition>();
}
public static T SetParentCondition <T>(this T entity, ConditionDefinition value)
where T : ConditionDefinition
{
entity.SetField("parentCondition", value);
return(entity);
}
public static T SetRequiredTargetCondition <T>(this T entity, ConditionDefinition value)
where T : FeatureDefinitionAdditionalDamage
{
entity.SetField("requiredTargetCondition", value);
return(entity);
}
public static T SetSubsequentOnRemoval <T>(this T entity, ConditionDefinition value)
where T : ConditionDefinition
{
entity.SetField("subsequentOnRemoval", value);
return(entity);
}
public void LoadUI()
{
mEntries.Clear();
ConditionsListBox.Items.Clear();
EffectsListBox.Items.Clear();
mTopVersion.Clear();
bool bHideObsolete = HideObsoleteCheckBox.Checked;
foreach (ConditionDefinition item in mTriggerDefinition.ConditionDefinitions)
{
string key = item.Type;
if (mEntries.ContainsKey(key) == false)
{
mEntries[key] = new List <object>();
//ConditionsListBox.Items.Add(key);
}
mEntries[key].Add(item);
if (mTopVersion.ContainsKey(key) == false)
{
mTopVersion[key] = item.Version;
}
if (item.Version > mTopVersion[key])
{
mTopVersion[key] = item.Version;
}
}
foreach (EffectDefinition item in mTriggerDefinition.EffectDefinitions)
{
string key = item.Type;
if (mEntries.ContainsKey(key) == false)
{
mEntries[key] = new List <object>();
//EffectsListBox.Items.Add(key);
}
mEntries[key].Add(item);
if (mTopVersion.ContainsKey(key) == false)
{
mTopVersion[key] = item.Version;
}
if (item.Version > mTopVersion[key])
{
mTopVersion[key] = item.Version;
}
}
Dictionary <string, int> .Enumerator it = mTopVersion.GetEnumerator();
while (it.MoveNext())
{
foreach (object entry in mEntries[it.Current.Key])
{
if (entry is ConditionDefinition)
{
ConditionDefinition def = entry as ConditionDefinition;
if (def.Version == it.Current.Value)
{
if (bHideObsolete && def.Obsolete == true)
{
continue;
}
else
{
ConditionsListBox.Items.Add(it.Current.Key);
}
}
}
else if (entry is EffectDefinition)
{
EffectDefinition def = entry as EffectDefinition;
if (def.Version == it.Current.Value)
{
if (bHideObsolete && def.Obsolete == true)
{
continue;
}
else
{
EffectsListBox.Items.Add(it.Current.Key);
}
}
}
}
}
ConditionsListBox.Sorted = true;
EffectsListBox.Sorted = true;
}
public static ExecutionRequestParameters Create(Guid processId, IEnumerable <ParameterDefinitionWithValue> parameters, ActivityDefinition activityToExecute, ConditionDefinition condition)
{
return(Create(processId, parameters, activityToExecute, condition, false));
}
public static T SetConditionDefinition <T>(this T entity, ConditionDefinition value)
where T : GuiActiveCondition
{
entity.SetField("conditionDefinition", value);
return(entity);
}
