private void zGroupSteps(List <Step> steps)
{
if (steps.Count > 0)
{
GroupStep groupStep = new GroupStep();
List <Step> container = AutomationUtils.GetStepParent(m_AutomationEngine.Sequence, steps.First());
int groupIndex = container.IndexOf(steps.First());
foreach (Step step in steps)
{
if (AutomationUtils.GetStepParent(m_AutomationEngine.Sequence, step) == container)
{
container.Remove(step);
groupStep.Steps.Add(step);
}
}
container.Insert(groupIndex, groupStep);
m_CurrentStep = steps.Last();
m_AutomationEngine.ResetSequence();
zFullRefreshSteps();
zOnSequenceChanged(EventArgs.Empty);
}
}
private void zPasteSteps(IEnumerable <Step> stepsToPaste, Step pasteTarget, int siblingOffset)
{
if (stepsToPaste != null && stepsToPaste.Count() > 0)
{
if (pasteTarget != null)
{
if (siblingOffset == -1)
{
GroupStep targetGroupStep = (GroupStep)pasteTarget;
targetGroupStep.Steps.AddRange(stepsToPaste);
}
else
{
List <Step> container = AutomationUtils.GetStepParent(m_AutomationEngine.Sequence, pasteTarget);
container.InsertRange(container.IndexOf(pasteTarget) + siblingOffset, stepsToPaste);
}
}
else
{
m_AutomationEngine.Sequence.AddRange(stepsToPaste);
}
m_CurrentStep = stepsToPaste.Last();
m_AutomationEngine.ResetSequence();
IList selectedObjects = tlvSequence.SelectedObjects;
zFullRefreshSteps();
tlvSequence.SelectedObjects = selectedObjects;
zOnSequenceChanged(EventArgs.Empty);
}
}
public GetValueSuggestor(StepEditContext stepEditContext, ElementIdentifier elementIdentifier, ElementValueMode elementValueMode, string attributeName)
: this()
{
m_StepEditContext = stepEditContext;
GroupStep parentGroupStep = AutomationUtils.GetParentGroupStep(m_StepEditContext.Sequence, m_StepEditContext.Step);
if (parentGroupStep != null && parentGroupStep.Iteration != null && parentGroupStep.Iteration is ElementSetIteration)
{
m_GroupStepEditContext = new StepEditContext(parentGroupStep, m_StepEditContext.Sequence, m_StepEditContext.StepIndex, m_StepEditContext.StateVariables);
}
m_ElementIdentifier = elementIdentifier;
m_ElementValueMode = elementValueMode;
m_AttributeName = attributeName;
}
private List <Step> zCopySteps(IEnumerable <Step> stepsToCopy, bool isCut)
{
List <Step> copiedSteps = new List <Step>();
if (stepsToCopy.Count() > 0)
{
//Copy operation
Dictionary <Guid, Step> steps = stepsToCopy.ToDictionary(s => Guid.NewGuid(), s => s);
byte[] stepsDeepCopyBytes = Converter.ToBinary(steps);
Dictionary <Guid, Step> stepsLookup = Converter.FromBinary <Dictionary <Guid, Step> >(stepsDeepCopyBytes);
foreach (KeyValuePair <Guid, Step> stepKVP in stepsLookup)
{
if (stepKVP.Value is GroupStep)
{
((GroupStep)stepKVP.Value).Steps.Clear();
}
Step originalStep = steps[stepKVP.Key];
GroupStep originalStepAncestor;
while (true)
{
originalStepAncestor = AutomationUtils.GetParentGroupStep(m_AutomationEngine.Sequence, originalStep);
if (originalStepAncestor == null)
{
copiedSteps.Add(stepKVP.Value);
break;
}
if (steps.ContainsValue(originalStepAncestor))
{
Guid originalStepAncestorKey = steps.First(kvp => kvp.Value == originalStepAncestor).Key;
GroupStep parentCopiedStep = (GroupStep)stepsLookup[originalStepAncestorKey];
parentCopiedStep.Steps.Add(stepKVP.Value);
break;
}
originalStep = originalStepAncestor;
}
}
//Cut operation
if (isCut)
{
zRemoveSteps(steps.Values);
}
//Cleanup & persist to clipboard
steps.Clear();
stepsLookup.Clear();
}
return(copiedSteps);
}
private void zTryAddPersistedVariableToScope(Step step, Dictionary <string, StepScope> scopeDictionaryAsOfTargetStep)
{
//Check if step sets a persisted variable
StateVariableInfo variableInfo = null;
if (step is GetValueStep)
{
GetValueStep getValueStep = (GetValueStep)step;
if (getValueStep.PersistenceMode == PersistenceMode.Persisted)
{
variableInfo = new StateVariableInfo(getValueStep.StateVariable, DataType.String, getValueStep.PersistenceMode); //TODO: get actual datatype
}
}
if (step is GroupStep)
{
GroupStep groupStep = (GroupStep)step;
if (groupStep.Iteration is ElementSetIteration)
{
ElementSetIteration elementSetIteration = (ElementSetIteration)groupStep.Iteration;
if (elementSetIteration.PersistenceMode == PersistenceMode.Persisted)
{
variableInfo = new StateVariableInfo(elementSetIteration.ObjectSetListName, DataType.List, elementSetIteration.PersistenceMode);
}
}
}
if (variableInfo != null)
{
//If step sets a persisted variable, check if it is within the target step's scope visbility
string scopeNamePart;
string variableNamePart;
DataUtils.ParseStateVariableName(m_CurrentScope.ScopeName, variableInfo.StateVariableName, out scopeNamePart, out variableNamePart);
variableInfo.StateVariableName = String.Format("{0}.{1}", scopeNamePart, variableNamePart);
StepScope scopeAsOfAnalyzer, scopeAsOfTargetStep;
if (m_ScopeDictionary.TryGetValue(scopeNamePart, out scopeAsOfAnalyzer) && scopeDictionaryAsOfTargetStep.TryGetValue(scopeNamePart, out scopeAsOfTargetStep))
{
if (scopeNamePart == DataScope.RootScopeName ||
(scopeAsOfTargetStep.CacheKey == scopeAsOfAnalyzer.CacheKey &&
(scopeAsOfTargetStep.ClassName == null || scopeAsOfTargetStep.ClassName == scopeAsOfAnalyzer.ClassName)))
{
//If step sets a persisted variable and it is within the target step's scope visbility, add it to the appropriate scope's variable list
if (!scopeAsOfTargetStep.VariableList.Contains(variableInfo))
{
scopeAsOfTargetStep.VariableList.Add(variableInfo);
}
}
}
}
}
public static GroupStep GetParentGroupStep(List <Step> container, Step step)
{
foreach (GroupStep iStep in container.OfType <GroupStep>())
{
if (iStep.Steps.Contains(step))
{
return(iStep);
}
GroupStep parentGroupStep = GetParentGroupStep(iStep.Steps, step);
if (parentGroupStep != null)
{
return(parentGroupStep);
}
}
return(null);
}
void m_AutomationEngine_ExecutionComplete(object sender, ExecutionCompleteEventArgs e)
{
m_AutomationEngine.ExecutionComplete -= m_AutomationEngine_ExecutionComplete;
ElementIdentifier containerIdentifier = null;
if (m_GroupStepEditContext != null)
{
GroupStep groupStep = (GroupStep)m_GroupStepEditContext.Step;
containerIdentifier = ((ElementSetIteration)groupStep.Iteration).ElementSetContainer;
}
ThreadingUtils.InvokeControlAction(this, ctl =>
{
zDetect(containerIdentifier);
});
}
void m_AutomationEngine_ExecutionComplete(object sender, ExecutionCompleteEventArgs e)
{
m_AutomationEngine.ExecutionComplete -= m_AutomationEngine_ExecutionComplete;
GroupStep groupStep = (GroupStep)m_StepEditContext.Step;
m_Pattern = groupStep.Steps.OfType <ElementStep>().Select(gvs => gvs.Element).ToList();
ThreadingUtils.InvokeControlAction(this, ctl =>
{
if (m_ContainerIdentifier != null)
{
zElementSelected();
}
zPreview();
pbLoading.Visible = false;
EditorPanel.Visible = true;
});
}
private void zRemoveSteps(IEnumerable <Step> steps)
{
if (steps.Count() > 0)
{
foreach (Step step in steps)
{
List <Step> stepContainer = AutomationUtils.GetStepParent(m_AutomationEngine.Sequence, step);
int containerIndex = stepContainer.IndexOf(step);
stepContainer.Remove(step);
containerIndex = stepContainer.Count > containerIndex ? containerIndex : stepContainer.Count - 1;
if (containerIndex > -1)
{
m_CurrentStep = stepContainer[containerIndex];
}
else
{
m_CurrentStep = null;
}
if (step is GroupStep)
{
GroupStep groupStep = (GroupStep)step;
if (groupStep.Steps.Count > 0)
{
stepContainer.AddRange(groupStep.Steps);
}
}
}
m_AutomationEngine.ResetSequence();
IList selectedObjects = tlvSequence.SelectedObjects;
zFullRefreshSteps();
tlvSequence.SelectedObjects = selectedObjects;
zOnSequenceChanged(EventArgs.Empty);
}
}
/// <summary>
/// Main sequence analysis loop, or an "Analysis Pass". This method "passes" through the sequence step by step,
/// keeps track of the sequence structurally (scope list, scope dictionary),
/// and fires delegates for each step and for completion.
/// </summary>
/// <param name="sequence"></param>
/// <param name="onStepScope"></param>
/// <param name="onSequenceComplete"></param>
private void zAnalyzeSequence(List <Step> sequence, Func <Step, bool> onStepScope, Action onSequenceComplete)
{
//Make sure this SequenceAnalyzer is not being used by another thread. It is not thread safe! All concurrent usage must be done on separate instances.
if (m_ExecutionStack != null)
{
throw new InvalidOperationException("A zAnalyzeSequence call is already in progress. If you need to use this method concurrently, use a separate SequenceAnalyzer instance for each concurrent call.");
}
try
{
if (sequence.Count > 0)
{
m_ExecutionStack = new ExecutionStack();
m_ExecutionStack.BranchEnded += m_ExecutionStack_BranchEnded;
m_ExecutionStack.SetSequence(sequence);
zSetCurrentScope(new StepScope(DataScope.RootScopeName,
DataScope.RootScopeName,
null,
m_ExecutionStack.CurrentBranch));
do
{
if (onStepScope != null && !onStepScope(m_ExecutionStack.CurrentStep))
{
break;
}
if (m_ExecutionStack.CurrentStep is GetValueStep)
{
GetValueStep getValueStep = (GetValueStep)m_ExecutionStack.CurrentStep;
zAddVariableToScopeFromGetValueStep(getValueStep);
}
if (m_ExecutionStack.CurrentStep is DatabaseStep)
{
DatabaseStep databaseStep = (DatabaseStep)m_ExecutionStack.CurrentStep;
zAddVariablesToScopeFromDatabaseStep(databaseStep);
}
if (m_ExecutionStack.CurrentStep is GroupStep)
{
GroupStep groupStep = (GroupStep)m_ExecutionStack.CurrentStep;
if (groupStep.Steps.Count > 0)
{
m_ExecutionStack.SetNewBranch(groupStep.Steps);
}
if (groupStep.Iteration is ObjectSetIteration && groupStep.Iteration.IsSetIteration)
{
ObjectSetIteration objectSetIteration = (ObjectSetIteration)groupStep.Iteration;
if (objectSetIteration is ElementSetIteration)
{
ElementSetIteration elementSetIteration = (ElementSetIteration)objectSetIteration;
zAddVariableToScopeFromElementSetIteration(elementSetIteration);
}
if (groupStep.Steps.Count > 0)
{
string newScopeCacheKey = zGetCacheKey(m_CurrentScope.ScopeName, objectSetIteration.ObjectSetListName);
StepScope newScope = new StepScope(objectSetIteration.ObjectSetScopeName,
objectSetIteration.ObjectSetClassName,
newScopeCacheKey,
m_ExecutionStack.PendingBranch);
if (objectSetIteration is DataSetIteration)
{
List <StateVariableInfo> cacheList;
if (newScope.CacheKey != null && m_ElementSetVariableListCache.TryGetValue(newScope.CacheKey, out cacheList))
{
foreach (StateVariableInfo cachedVariable in cacheList)
{
if (newScope.ClassName == null || DataUtils.GetVariableNameScope(cachedVariable.StateVariableName) == newScope.ClassName)
{
StateVariableInfo variableForNewScope = zRescopeVariable(cachedVariable, objectSetIteration.ObjectSetScopeName);
if (!newScope.VariableList.Contains(variableForNewScope))
{
newScope.VariableList.Add(variableForNewScope);
}
}
}
}
}
zSetCurrentScope(newScope);
}
}
}
} while (m_ExecutionStack.MoveNext());
}
if (onSequenceComplete != null)
{
onSequenceComplete();
}
}
catch (Exception ex)
{
throw ex;
}
finally
{
zCleanup();
}
}
