private XElement zGetNormalizedDataSelector(GetValueStep getValueStep, ElementIdentifier templateSelectorIdentifier) { string selectPath = zGetSelectPathForGetValueStep(getValueStep, templateSelectorIdentifier); XElement defaultSelector = getValueStep.UseNormalizationDefault ? new XElement(xsl + "text", getValueStep.NormalizationDefault) : new XElement(xsl + "value-of", new XAttribute("select", selectPath)); if (getValueStep.NormalizationRules.Count > 0) { XElement choose = new XElement(xsl + "choose"); foreach (GetValueNormalizationRule normalizationRule in getValueStep.NormalizationRules) { choose.Add(new XElement(xsl + "when", new XAttribute("test", zGetNormalizationRuleTestCondition(normalizationRule, selectPath)), new XElement(xsl + "text", normalizationRule.ReplacementValue))); } choose.Add(new XElement(xsl + "otherwise", defaultSelector)); return(choose); } else { return(defaultSelector); } }
private string zGetSelectPathForGetValueStep(GetValueStep getValueStep, ElementIdentifier templateSelectorIdentifier) { string selectPath = zGetRelativeSelectorPathForXSLT(templateSelectorIdentifier, getValueStep.Element); if (getValueStep.Mode == ElementValueMode.Attribute && !String.IsNullOrEmpty(getValueStep.AttributeName)) { selectPath = String.Format("{0}/@{1}", selectPath, getValueStep.AttributeName); } return(selectPath); }
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); } } } } }
void m_ElementSelector_ElementSelected(object sender, ElementSelectorEventArgs e) { if (e.FromUserAction) { //TODO: refactor this so that code is not repeated. if (m_ElementSelectMode == ElementSelectMode.Get) { GetValueStep getValueStep = new GetValueStep() { StateVariable = zGenerateVariableName(), Element = ElementIdentifier.FromHtmlElement(e.Element), XMLFieldOutputMode = XMLFieldOutputMode.Attribute, PersistenceMode = PersistenceMode.None }; //Default mode & attribute based on tag type if (e.Element.TagName.ToLower() == "input") { getValueStep.Mode = ElementValueMode.Attribute; getValueStep.AttributeName = "value"; } else { getValueStep.Mode = ElementValueMode.InnerText; } zAddStep(getValueStep); } else { SetValueStep setValueStep = new SetValueStep() { Element = ElementIdentifier.FromHtmlElement(e.Element) }; //Default mode & attribute based on tag type if (e.Element.TagName.ToLower() == "input") { setValueStep.Mode = ElementValueMode.Attribute; setValueStep.AttributeName = "value"; } else { setValueStep.Mode = ElementValueMode.InnerText; } zAddStep(setValueStep); } } }
private void zAddVariableToScopeFromGetValueStep(GetValueStep getValueStep) { zAddVariableToScope(m_CurrentScope.ScopeName, new StateVariableInfo(getValueStep.StateVariable, DataType.String, getValueStep.PersistenceMode)); //TODO: get actual datatype }
/// <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(); } }