///-------------------------------------------------------------------------------- /// <summary>Interpret this node to produce code, output, or model data..</summary> /// /// <param name="interpreterType">The type of interpretation to perform.</param> /// <param name="solutionContext">The associated solution.</param> /// <param name="templateContext">The associated template.</param> /// <param name="modelContext">The associated model context.</param> ///-------------------------------------------------------------------------------- public void InterpretNode(InterpreterTypeCode interpreterType, Solution solutionContext, ITemplate templateContext, IDomainEnterpriseObject modelContext) { try { StringBuilder output = null; if (interpreterType == InterpreterTypeCode.Output) { output = templateContext.OutputCodeBuilder; } else { output = templateContext.ContentCodeBuilder; } string propertyValue = GetStringValue(solutionContext, templateContext, modelContext, interpreterType); if (!String.IsNullOrEmpty(propertyValue)) { output.Append(propertyValue); } } catch (ApplicationAbortException) { throw; } catch (System.Exception ex) { LogException(solutionContext, templateContext, modelContext, ex, interpreterType); } }
///-------------------------------------------------------------------------------- /// <summary>Interpret this node to produce code, output, or model data..</summary> /// /// <param name="interpreterType">The type of interpretation to perform.</param> /// <param name="solutionContext">The associated solution.</param> /// <param name="templateContext">The associated template.</param> /// <param name="modelContext">The associated model context.</param> ///-------------------------------------------------------------------------------- public void InterpretNode(InterpreterTypeCode interpreterType, Solution solutionContext, ITemplate templateContext, IDomainEnterpriseObject modelContext) { try { if (GrammarHelper.IsReservedWord(VariableName) == true) { throw new System.Exception(String.Format(DisplayValues.Message_TemplateVariableConflict, VariableName)); } if (templateContext.Variables.HasKey(VariableName) == true) { throw new System.Exception(String.Format(DisplayValues.Message_TemplateVariableAlreadyDeclared, VariableName)); } if (Parameter != null) { templateContext.Variables[VariableName] = Parameter.GetObjectValue(solutionContext, templateContext, modelContext, interpreterType); } else { templateContext.Variables[VariableName] = String.Empty; } } catch (ApplicationAbortException) { throw; } catch (System.Exception ex) { LogException(solutionContext, templateContext, modelContext, ex, interpreterType); } }
///-------------------------------------------------------------------------------- /// <summary>Interpret this node to produce code, output, or model data..</summary> /// /// <param name="interpreterType">The type of interpretation to perform.</param> /// <param name="solutionContext">The associated solution.</param> /// <param name="templateContext">The associated template.</param> /// <param name="modelContext">The associated model context.</param> ///-------------------------------------------------------------------------------- public void InterpretNode(InterpreterTypeCode interpreterType, Solution solutionContext, ITemplate templateContext, IDomainEnterpriseObject modelContext) { try { string parameterValue = String.Empty; if (Text != null) { parameterValue = Text.GetStringValue(solutionContext, templateContext, modelContext, interpreterType); } string message = ShowDebugMessage(solutionContext, templateContext, modelContext, parameterValue, false); if (FilePath != null) { string path = FilePath.GetStringValue(solutionContext, templateContext, modelContext, interpreterType); FileHelper.AppendToFile(path, message); } MessageBox.Show(message, DisplayValues.Debug_Caption); } catch (ApplicationAbortException) { throw; } catch (System.Exception ex) { LogException(solutionContext, templateContext, modelContext, ex, interpreterType); } }
///-------------------------------------------------------------------------------- /// <summary>Interpret this node to produce code, output, or model data..</summary> /// /// <param name="interpreterType">The type of interpretation to perform.</param> /// <param name="solutionContext">The associated solution.</param> /// <param name="templateContext">The associated template.</param> /// <param name="modelContext">The associated model context.</param> ///-------------------------------------------------------------------------------- public void InterpretNode(InterpreterTypeCode interpreterType, Solution solutionContext, ITemplate templateContext, IDomainEnterpriseObject modelContext) { try { string parameterValue = Parameter.GetStringValue(solutionContext, templateContext, modelContext, interpreterType); if (TemplateProperty == LanguageTerms.TextProperty) { // reset content text templateContext.ContentCodeBuilder.Clear(); templateContext.ContentCodeBuilder.Append(parameterValue); } else if (TemplateProperty == LanguageTerms.PathProperty) { // reset output text templateContext.OutputCodeBuilder.Clear(); templateContext.OutputCodeBuilder.Append(parameterValue); } } catch (ApplicationAbortException) { throw; } catch (System.Exception ex) { LogException(solutionContext, templateContext, modelContext, ex, interpreterType); } }
///-------------------------------------------------------------------------------- /// <summary>Interpret this node to produce code, output, or model data..</summary> /// /// <param name="interpreterType">The type of interpretation to perform.</param> /// <param name="solutionContext">The associated solution.</param> /// <param name="templateContext">The associated template.</param> /// <param name="modelContext">The associated model context.</param> ///-------------------------------------------------------------------------------- public void InterpretNode(InterpreterTypeCode interpreterType, Solution solutionContext, ITemplate templateContext, IDomainEnterpriseObject modelContext) { try { string path = FilePath.GetStringValue(solutionContext, templateContext, modelContext, interpreterType); if (!String.IsNullOrEmpty(path)) { if (solutionContext.IsSampleMode == true) { // don't perform delete of output files, just indicate it would be deleted templateContext.MessageBuilder.Append("\r\nX "); templateContext.MessageBuilder.Append(path); } else if (solutionContext.LoggedErrors.Count == 0) { if (File.Exists(path) == true) { File.Delete(path); } } } } catch (ApplicationAbortException) { throw; } catch (System.Exception ex) { LogException(solutionContext, templateContext, modelContext, ex, interpreterType); } }
///-------------------------------------------------------------------------------- /// <summary>Create the instance with the designer view and other data.</summary> /// /// <param name="templateName">The template name.</param> /// <param name="templateType">The template type.</param> /// <param name="ast">The abstract syntax tree reults.</param> /// <param name="sampleCode">Sample code from interpreter.</param> ///-------------------------------------------------------------------------------- public CodeTemplateResultsViewModel(string templateName, InterpreterTypeCode templateType, TemplateNode ast, string sampleCode) { Name = templateName; TemplateType = templateType; ResultsAST = ast; SampleCode = sampleCode; WorkspaceID = Guid.NewGuid(); }
///-------------------------------------------------------------------------------- /// <summary>Interpret this node to produce code, output, or model data..</summary> /// /// <param name="interpreterType">The type of interpretation to perform.</param> /// <param name="solutionContext">The associated solution.</param> /// <param name="templateContext">The associated template.</param> /// <param name="modelContext">The associated model context.</param> ///-------------------------------------------------------------------------------- public void InterpretNode(InterpreterTypeCode interpreterType, Solution solutionContext, ITemplate templateContext, IDomainEnterpriseObject modelContext) { try { int itemIndex = 0; templateContext.ItemIndex = itemIndex; string directoryPath = DirectoryPath.GetStringValue(solutionContext, templateContext, modelContext, interpreterType); foreach (string filePath in GetFilePaths(directoryPath, Extensions)) { templateContext.IsBreaking = false; templateContext.IsContinuing = false; solutionContext.CurrentFilePath = filePath.Replace("\\\\", "\\"); solutionContext.CurrentFileText = FileHelper.GetText(filePath); foreach (IStatementNode node in Statements) { if (node.HandleDebug(interpreterType, solutionContext, templateContext, modelContext) == false) { return; } if (templateContext.IsContinuing == true) { break; } if (templateContext.IsBreaking == true || templateContext.IsReturning == true) { templateContext.IsBreaking = false; break; } if (node is BreakStatementNode) { templateContext.IsBreaking = true; break; } if (node is ContinueStatementNode) { break; } if (node is ReturnStatementNode) { templateContext.IsReturning = true; break; } node.InterpretNode(interpreterType, solutionContext, templateContext, modelContext); } itemIndex++; templateContext.ItemIndex = itemIndex; } templateContext.ItemIndex = 0; } catch (ApplicationAbortException) { throw; } catch (System.Exception ex) { LogException(solutionContext, templateContext, modelContext, ex, interpreterType); } }
///-------------------------------------------------------------------------------- /// <summary>Interpret this node to produce code, output, or model data..</summary> /// /// <param name="interpreterType">The type of interpretation to perform.</param> /// <param name="solutionContext">The associated solution.</param> /// <param name="templateContext">The associated template.</param> /// <param name="modelContext">The associated model context.</param> ///-------------------------------------------------------------------------------- public void InterpretNode(InterpreterTypeCode interpreterType, Solution solutionContext, ITemplate templateContext, IDomainEnterpriseObject modelContext) { try { templateContext.IsBreaking = false; while (Expression.EvaluateExpression(solutionContext, templateContext, modelContext, interpreterType) == true) { templateContext.IsContinuing = false; foreach (IStatementNode node in Statements) { if (node.HandleDebug(interpreterType, solutionContext, templateContext, modelContext) == false) { return; } if (templateContext.IsContinuing == true) { break; } if (templateContext.IsBreaking == true || templateContext.IsReturning == true) { templateContext.IsBreaking = false; break; } if (node is BreakStatementNode) { templateContext.IsBreaking = true; break; } if (node is ContinueStatementNode) { break; } if (node is ReturnStatementNode) { templateContext.IsReturning = true; break; } node.InterpretNode(interpreterType, solutionContext, templateContext, modelContext); } } } catch (ApplicationAbortException) { throw; } catch (System.Exception ex) { LogException(solutionContext, templateContext, modelContext, ex, interpreterType); } }
///-------------------------------------------------------------------------------- /// <summary>Interpret this node to produce code, output, or model data..</summary> /// /// <param name="interpreterType">The type of interpretation to perform.</param> /// <param name="solutionContext">The associated solution.</param> /// <param name="templateContext">The associated template.</param> /// <param name="modelContext">The associated model context.</param> ///-------------------------------------------------------------------------------- public void InterpretNode(InterpreterTypeCode interpreterType, Solution solutionContext, ITemplate templateContext, IDomainEnterpriseObject modelContext) { try { solutionContext.PutStringLoggedValue(Parameter1.GetStringValue(solutionContext, templateContext, modelContext, interpreterType), Parameter2.GetStringValue(solutionContext, templateContext, modelContext, interpreterType), Parameter3.GetStringValue(solutionContext, templateContext, modelContext, interpreterType)); } catch (ApplicationAbortException) { throw; } catch (System.Exception ex) { LogException(solutionContext, templateContext, modelContext, ex, interpreterType); } }
///-------------------------------------------------------------------------------- /// <summary>Interpret this node to produce code, output, or model data..</summary> /// /// <param name="interpreterType">The type of interpretation to perform.</param> /// <param name="solutionContext">The associated solution.</param> /// <param name="templateContext">The associated template.</param> /// <param name="modelContext">The associated model context.</param> ///-------------------------------------------------------------------------------- public void InterpretNode(InterpreterTypeCode interpreterType, Solution solutionContext, ITemplate templateContext, IDomainEnterpriseObject modelContext) { try { TemplateProperty.InterpretContentAndOutput(solutionContext, templateContext, modelContext, modelContext); } catch (ApplicationAbortException) { throw; } catch (System.Exception ex) { LogException(solutionContext, templateContext, modelContext, ex, interpreterType); } }
///-------------------------------------------------------------------------------- /// <summary>Interpret this node to produce code, output, or model data..</summary> /// /// <param name="interpreterType">The type of interpretation to perform.</param> /// <param name="solutionContext">The associated solution.</param> /// <param name="templateContext">The associated template.</param> /// <param name="modelContext">The associated model context.</param> ///-------------------------------------------------------------------------------- public void InterpretNode(InterpreterTypeCode interpreterType, Solution solutionContext, ITemplate templateContext, IDomainEnterpriseObject modelContext) { try { templateContext.OutputCodeBuilder.Clear(); } catch (ApplicationAbortException) { throw; } catch (System.Exception ex) { LogException(solutionContext, templateContext, modelContext, ex, interpreterType); } }
///-------------------------------------------------------------------------------- /// <summary>Interpret this node to produce code, output, or model data..</summary> /// /// <param name="interpreterType">The type of interpretation to perform.</param> /// <param name="solutionContext">The associated solution.</param> /// <param name="templateContext">The associated template.</param> /// <param name="modelContext">The associated model context.</param> ///-------------------------------------------------------------------------------- public void InterpretNode(InterpreterTypeCode interpreterType, Solution solutionContext, ITemplate templateContext, IDomainEnterpriseObject modelContext) { try { IDomainEnterpriseObject withModelContext = GetModelContext(solutionContext, templateContext, modelContext, interpreterType); templateContext.PushModelContext(withModelContext); templateContext.IsBreaking = false; if (withModelContext != null) { foreach (IStatementNode node in Statements) { if (node.HandleDebug(interpreterType, solutionContext, templateContext, withModelContext) == false) { return; } if (templateContext.IsBreaking == true || templateContext.IsReturning == true) { templateContext.IsBreaking = false; break; } if (node is BreakStatementNode) { templateContext.IsBreaking = true; break; } if (node is ContinueStatementNode) { templateContext.IsContinuing = true; } if (node is ReturnStatementNode) { templateContext.IsReturning = true; break; } node.InterpretNode(interpreterType, solutionContext, templateContext, withModelContext); } } templateContext.PopModelContext(); } catch (ApplicationAbortException) { throw; } catch (System.Exception ex) { LogException(solutionContext, templateContext, modelContext, ex, interpreterType); } }
///-------------------------------------------------------------------------------- /// <summary>Handle breakpoint.</summary> /// /// <param name="interpreterType">The type of interpretation to perform.</param> /// <param name="modelContext">The associated model context.</param> /// <param name="lineNumber">The associated line number.</param> ///-------------------------------------------------------------------------------- public void HandleBreakpoint(InterpreterTypeCode interpreterType, IDomainEnterpriseObject modelContext, int lineNumber) { SolutionDebugEventArgs args = new SolutionDebugEventArgs(); args.InterpreterType = interpreterType; args.Solution = Solution; args.TemplateContext = SpecTemplate; args.ModelContext = modelContext; args.LineNumber = lineNumber; if (interpreterType == InterpreterTypeCode.Content) { OnContentBreakpointReached(this, args); } else if (interpreterType == InterpreterTypeCode.Output) { OnOutputBreakpointReached(this, args); } }
///-------------------------------------------------------------------------------- /// <summary>Interpret this node to produce code, output, or model data..</summary> /// /// <param name="interpreterType">The type of interpretation to perform.</param> /// <param name="solutionContext">The associated solution.</param> /// <param name="templateContext">The associated template.</param> /// <param name="modelContext">The associated model context.</param> ///-------------------------------------------------------------------------------- public void InterpretNode(InterpreterTypeCode interpreterType, Solution solutionContext, ITemplate templateContext, IDomainEnterpriseObject modelContext) { try { if (templateContext.Variables.HasKey(VariableName) == false) { throw new System.Exception(String.Format("The variable {0} has not been declared, cannot be assigned to.", VariableName)); } templateContext.Variables[VariableName] = Parameter.GetObjectValue(solutionContext, templateContext, modelContext, interpreterType); } catch (ApplicationAbortException) { throw; } catch (System.Exception ex) { LogException(solutionContext, templateContext, modelContext, ex, interpreterType); } }
///-------------------------------------------------------------------------------- /// <summary>Interpret this node to produce code, output, or model data..</summary> /// /// <param name="interpreterType">The type of interpretation to perform.</param> /// <param name="solutionContext">The associated solution.</param> /// <param name="templateContext">The associated template.</param> /// <param name="modelContext">The associated model context.</param> ///-------------------------------------------------------------------------------- public void InterpretNode(InterpreterTypeCode interpreterType, Solution solutionContext, ITemplate templateContext, IDomainEnterpriseObject modelContext) { try { bool isCaseClauseExecuted = false; foreach (CaseClauseNode node in CaseClauses) { if (node.EvaluateConditions(solutionContext, ModelProperty.GetPropertyStringValue(solutionContext, templateContext, modelContext, modelContext, interpreterType)) == true) { isCaseClauseExecuted = true; foreach (IStatementNode statement in node.Statements) { if (statement is BreakStatementNode) { break; } statement.InterpretNode(interpreterType, solutionContext, templateContext, modelContext); } break; } } if (isCaseClauseExecuted == false) { foreach (IStatementNode statement in DefaultClause.Statements) { if (statement is BreakStatementNode) { break; } statement.InterpretNode(interpreterType, solutionContext, templateContext, modelContext); } } } catch (ApplicationAbortException) { throw; } catch (System.Exception ex) { LogException(solutionContext, templateContext, modelContext, ex, interpreterType); } }
///-------------------------------------------------------------------------------- /// <summary>Interpret this node to produce code, output, or model data..</summary> /// /// <param name="interpreterType">The type of interpretation to perform.</param> /// <param name="solutionContext">The associated solution.</param> /// <param name="templateContext">The associated template.</param> /// <param name="modelContext">The associated model context.</param> ///-------------------------------------------------------------------------------- public void InterpretNode(InterpreterTypeCode interpreterType, Solution solutionContext, ITemplate templateContext, IDomainEnterpriseObject modelContext) { // only perform progress operations if not in sample mode if (solutionContext.IsSampleMode == false) { if (templateContext is SpecTemplate) { if (Parameter != null) { // set build model work int work = 0; if (int.TryParse(Parameter.GetStringValue(solutionContext, templateContext, modelContext, interpreterType), out work) == true) { solutionContext.SetModelProgressWork(work); } } else { // increment build model progress solutionContext.IncrementModelProgress(); } } else if (templateContext is CodeTemplate) { if (Parameter != null) { // set build code work int work = 0; if (int.TryParse(Parameter.GetStringValue(solutionContext, templateContext, modelContext, interpreterType), out work) == true) { solutionContext.SetCodeProgressWork(work); } } else { // increment build code progress solutionContext.IncrementCodeProgress(); } } } }
///-------------------------------------------------------------------------------- /// <summary>Interpret this node to produce code, output, or model data..</summary> /// /// <param name="interpreterType">The type of interpretation to perform.</param> /// <param name="solutionContext">The associated solution.</param> /// <param name="templateContext">The associated template.</param> /// <param name="modelContext">The associated model context.</param> ///-------------------------------------------------------------------------------- public void InterpretNode(InterpreterTypeCode interpreterType, Solution solutionContext, ITemplate templateContext, IDomainEnterpriseObject modelContext) { try { StringBuilder output = null; if (interpreterType == InterpreterTypeCode.Output) { output = templateContext.OutputCodeBuilder; } else { output = templateContext.ContentCodeBuilder; } output.Clear(); } catch (ApplicationAbortException) { throw; } catch (System.Exception ex) { LogException(solutionContext, templateContext, modelContext, ex, interpreterType); } }
///-------------------------------------------------------------------------------- /// <summary>This method gets the collection context associated with this node.</summary> /// /// <param name="solutionContext">The associated solution.</param> /// <param name="templateContext">The associated template.</param> /// <param name="modelContext">The associated model context.</param> /// <param name="collectionType">The type of collection to get.</param> /// <param name="interpreterType">The type of interpretation to perform.</param> ///-------------------------------------------------------------------------------- public IEnterpriseEnumerable GetCollection(Solution solutionContext, ITemplate templateContext, IDomainEnterpriseObject modelContext, ModelContextNode collectionType, InterpreterTypeCode interpreterType) { IDomainEnterpriseObject collectionContext = modelContext; if (ModelContext != null) { bool isValidContext; collectionContext = ModelContext.GetModelContext(solutionContext, templateContext, modelContext, out isValidContext); } else if (CurrentItem != null) { collectionContext = CurrentItem.GetModelContext(solutionContext, templateContext, modelContext); } else if (SpecCurrentItem != null) { collectionContext = SpecCurrentItem.GetModelContext(solutionContext, templateContext, modelContext); } if (MethodName == LanguageTerms.FindAllMethod && ModelProperty != null) { IEnterpriseEnumerable collection = collectionType.GetCollection(solutionContext, templateContext, collectionContext); if (collection != null) { return(collection.FindItems(ModelProperty.ModelPropertyName, Parameter.GetObjectValue(solutionContext, templateContext, modelContext, interpreterType))); } } else if (MethodName == LanguageTerms.GetEntityAndBasesCollection) { // TODO: condense ability to get extended collections if (collectionType.ModelContextName == "Entity" && collectionContext is Entity) { EnterpriseDataObjectList <Entity> entities = new EnterpriseDataObjectList <Entity>(); Entity currentEntity = collectionContext as Entity; while (currentEntity != null) { entities.Add(currentEntity); currentEntity = currentEntity.BaseEntity; } return(entities); } else if (collectionType.ModelContextName == "Property") { EnterpriseDataObjectList <Property> items = new EnterpriseDataObjectList <Property>(); bool isValidContext; Entity currentEntity = Entity.GetModelContext(solutionContext, collectionContext, out isValidContext) as Entity; while (currentEntity != null) { foreach (Property loopItem in currentEntity.PropertyList) { items.Add(loopItem); } currentEntity = currentEntity.BaseEntity; } return(items); } else if (collectionType.ModelContextName == "PropertyReference") { EnterpriseDataObjectList <PropertyReference> items = new EnterpriseDataObjectList <PropertyReference>(); bool isValidContext; Entity currentEntity = Entity.GetModelContext(solutionContext, collectionContext, out isValidContext) as Entity; while (currentEntity != null) { foreach (PropertyReference loopItem in currentEntity.PropertyReferenceList) { items.Add(loopItem); } currentEntity = currentEntity.BaseEntity; } return(items); } else if (collectionType.ModelContextName == "EntityReference") { EnterpriseDataObjectList <EntityReference> items = new EnterpriseDataObjectList <EntityReference>(); bool isValidContext; Entity currentEntity = Entity.GetModelContext(solutionContext, collectionContext, out isValidContext) as Entity; while (currentEntity != null) { foreach (EntityReference loopItem in currentEntity.EntityReferenceList) { items.Add(loopItem); } currentEntity = currentEntity.BaseEntity; } return(items); } else if (collectionType.ModelContextName == "Collection") { EnterpriseDataObjectList <Collection> items = new EnterpriseDataObjectList <Collection>(); bool isValidContext; Entity currentEntity = Entity.GetModelContext(solutionContext, collectionContext, out isValidContext) as Entity; while (currentEntity != null) { foreach (Collection loopItem in currentEntity.CollectionList) { items.Add(loopItem); } currentEntity = currentEntity.BaseEntity; } return(items); } else if (collectionType.ModelContextName == "Relationship") { EnterpriseDataObjectList <Relationship> items = new EnterpriseDataObjectList <Relationship>(); bool isValidContext; Entity currentEntity = Entity.GetModelContext(solutionContext, collectionContext, out isValidContext) as Entity; while (currentEntity != null) { foreach (Relationship loopItem in currentEntity.RelationshipList) { items.Add(loopItem); } currentEntity = currentEntity.BaseEntity; } return(items); } else if (collectionType.ModelContextName == "Index") { EnterpriseDataObjectList <Index> items = new EnterpriseDataObjectList <Index>(); bool isValidContext; Entity currentEntity = Entity.GetModelContext(solutionContext, collectionContext, out isValidContext) as Entity; while (currentEntity != null) { foreach (Index loopItem in currentEntity.IndexList) { items.Add(loopItem); } currentEntity = currentEntity.BaseEntity; } return(items); } else if (collectionType.ModelContextName == "Method") { EnterpriseDataObjectList <Method> items = new EnterpriseDataObjectList <Method>(); bool isValidContext; Entity currentEntity = Entity.GetModelContext(solutionContext, collectionContext, out isValidContext) as Entity; while (currentEntity != null) { foreach (Method loopItem in currentEntity.MethodList) { items.Add(loopItem); } currentEntity = currentEntity.BaseEntity; } return(items); } } else if (MethodName == LanguageTerms.GetBaseAndEntitiesCollection) { // TODO: condense ability to get extended collections if (collectionType.ModelContextName == "Entity" && collectionContext is Entity) { EnterpriseDataObjectList <Entity> items = new EnterpriseDataObjectList <Entity>(); Entity currentEntity = collectionContext as Entity; while (currentEntity != null) { items.Insert(0, currentEntity); currentEntity = currentEntity.BaseEntity; } return(items); } else if (collectionType.ModelContextName == "Property") { EnterpriseDataObjectList <Property> items = new EnterpriseDataObjectList <Property>(); bool isValidContext; Entity currentEntity = Entity.GetModelContext(solutionContext, collectionContext, out isValidContext) as Entity; while (currentEntity != null) { foreach (Property loopItem in currentEntity.PropertyList) { items.Add(loopItem); } currentEntity = currentEntity.BaseEntity; } return(items); } else if (collectionType.ModelContextName == "PropertyReference") { EnterpriseDataObjectList <PropertyReference> items = new EnterpriseDataObjectList <PropertyReference>(); bool isValidContext; Entity currentEntity = Entity.GetModelContext(solutionContext, collectionContext, out isValidContext) as Entity; while (currentEntity != null) { foreach (PropertyReference loopItem in currentEntity.PropertyReferenceList) { items.Add(loopItem); } currentEntity = currentEntity.BaseEntity; } return(items); } else if (collectionType.ModelContextName == "EntityReference") { EnterpriseDataObjectList <EntityReference> items = new EnterpriseDataObjectList <EntityReference>(); bool isValidContext; Entity currentEntity = Entity.GetModelContext(solutionContext, collectionContext, out isValidContext) as Entity; while (currentEntity != null) { foreach (EntityReference loopItem in currentEntity.EntityReferenceList) { items.Add(loopItem); } currentEntity = currentEntity.BaseEntity; } return(items); } else if (collectionType.ModelContextName == "Collection") { EnterpriseDataObjectList <Collection> items = new EnterpriseDataObjectList <Collection>(); bool isValidContext; Entity currentEntity = Entity.GetModelContext(solutionContext, collectionContext, out isValidContext) as Entity; while (currentEntity != null) { foreach (Collection loopItem in currentEntity.CollectionList) { items.Add(loopItem); } currentEntity = currentEntity.BaseEntity; } return(items); } else if (collectionType.ModelContextName == "Relationship") { EnterpriseDataObjectList <Relationship> items = new EnterpriseDataObjectList <Relationship>(); bool isValidContext; Entity currentEntity = Entity.GetModelContext(solutionContext, collectionContext, out isValidContext) as Entity; while (currentEntity != null) { foreach (Relationship loopItem in currentEntity.RelationshipList) { items.Add(loopItem); } currentEntity = currentEntity.BaseEntity; } return(items); } else if (collectionType.ModelContextName == "Index") { EnterpriseDataObjectList <Index> items = new EnterpriseDataObjectList <Index>(); bool isValidContext; Entity currentEntity = Entity.GetModelContext(solutionContext, collectionContext, out isValidContext) as Entity; while (currentEntity != null) { foreach (Index loopItem in currentEntity.IndexList) { items.Add(loopItem); } currentEntity = currentEntity.BaseEntity; } return(items); } else if (collectionType.ModelContextName == "Method") { EnterpriseDataObjectList <Method> items = new EnterpriseDataObjectList <Method>(); bool isValidContext; Entity currentEntity = Entity.GetModelContext(solutionContext, collectionContext, out isValidContext) as Entity; while (currentEntity != null) { foreach (Method loopItem in currentEntity.MethodList) { items.Add(loopItem); } currentEntity = currentEntity.BaseEntity; } return(items); } } else if (MethodName == LanguageTerms.ExtendingEntitiesCollection) { if (collectionType.ModelContextName == "Entity" && collectionContext is Entity) { return((collectionContext as Entity).ExtendingEntites); } else if (collectionType.ModelContextName == "Property") { EnterpriseDataObjectList <Property> items = new EnterpriseDataObjectList <Property>(); bool isValidContext; Entity currentEntity = Entity.GetModelContext(solutionContext, collectionContext, out isValidContext) as Entity; if (currentEntity != null) { foreach (Entity loopEntity in currentEntity.ExtendingEntites) { foreach (Property loopItem in loopEntity.PropertyList) { items.Add(loopItem); } } } return(items); } else if (collectionType.ModelContextName == "PropertyReference") { EnterpriseDataObjectList <PropertyReference> items = new EnterpriseDataObjectList <PropertyReference>(); bool isValidContext; Entity currentEntity = Entity.GetModelContext(solutionContext, collectionContext, out isValidContext) as Entity; if (currentEntity != null) { foreach (Entity loopEntity in currentEntity.ExtendingEntites) { foreach (PropertyReference loopItem in loopEntity.PropertyReferenceList) { items.Add(loopItem); } } } return(items); } else if (collectionType.ModelContextName == "EntityReference") { EnterpriseDataObjectList <EntityReference> items = new EnterpriseDataObjectList <EntityReference>(); bool isValidContext; Entity currentEntity = Entity.GetModelContext(solutionContext, collectionContext, out isValidContext) as Entity; if (currentEntity != null) { foreach (Entity loopEntity in currentEntity.ExtendingEntites) { foreach (EntityReference loopItem in loopEntity.EntityReferenceList) { items.Add(loopItem); } } } return(items); } else if (collectionType.ModelContextName == "Collection") { EnterpriseDataObjectList <Collection> items = new EnterpriseDataObjectList <Collection>(); bool isValidContext; Entity currentEntity = Entity.GetModelContext(solutionContext, collectionContext, out isValidContext) as Entity; if (currentEntity != null) { foreach (Entity loopEntity in currentEntity.ExtendingEntites) { foreach (Collection loopItem in loopEntity.CollectionList) { items.Add(loopItem); } } } return(items); } else if (collectionType.ModelContextName == "Relationship") { EnterpriseDataObjectList <Relationship> items = new EnterpriseDataObjectList <Relationship>(); bool isValidContext; Entity currentEntity = Entity.GetModelContext(solutionContext, collectionContext, out isValidContext) as Entity; if (currentEntity != null) { foreach (Entity loopEntity in currentEntity.ExtendingEntites) { foreach (Relationship loopItem in loopEntity.RelationshipList) { items.Add(loopItem); } } } return(items); } else if (collectionType.ModelContextName == "Index") { EnterpriseDataObjectList <Index> items = new EnterpriseDataObjectList <Index>(); bool isValidContext; Entity currentEntity = Entity.GetModelContext(solutionContext, collectionContext, out isValidContext) as Entity; if (currentEntity != null) { foreach (Entity loopEntity in currentEntity.ExtendingEntites) { foreach (Index loopItem in loopEntity.IndexList) { items.Add(loopItem); } } } return(items); } else if (collectionType.ModelContextName == "Method") { EnterpriseDataObjectList <Method> items = new EnterpriseDataObjectList <Method>(); bool isValidContext; Entity currentEntity = Entity.GetModelContext(solutionContext, collectionContext, out isValidContext) as Entity; if (currentEntity != null) { foreach (Entity loopEntity in currentEntity.ExtendingEntites) { foreach (Method loopItem in loopEntity.MethodList) { items.Add(loopItem); } } } return(items); } } else if (MethodName == LanguageTerms.PathRelationships) { if (collectionType.ModelContextName == "Relationship" && collectionContext is Entity) { return((collectionContext as Entity).PathRelationships); } } return(null); }
///-------------------------------------------------------------------------------- /// <summary>Evaluate expression associated with this node.</summary> /// /// <param name="solutionContext">The associated solution.</param> /// <param name="templateContext">The associated template.</param> /// <param name="modelContext">The associated model context.</param> /// <param name="interpreterType">The type of interpretation to perform.</param> ///-------------------------------------------------------------------------------- public bool EvaluateExpression(Solution solutionContext, ITemplate templateContext, IDomainEnterpriseObject modelContext, InterpreterTypeCode interpreterType) { string value = GetExpressionValue(solutionContext, templateContext, modelContext, interpreterType); if (String.IsNullOrEmpty(value) || value == "false") { return(false); } return(true); }
///-------------------------------------------------------------------------------- /// <summary>Evaluate expression associated with this node.</summary> /// /// <param name="solutionContext">The associated solution.</param> /// <param name="templateContext">The associated template.</param> /// <param name="modelContext">The associated model context.</param> /// <param name="interpreterType">The type of interpretation to perform.</param> ///-------------------------------------------------------------------------------- public string GetExpressionValue(Solution solutionContext, ITemplate templateContext, IDomainEnterpriseObject modelContext, InterpreterTypeCode interpreterType) { string expression1Value = String.Empty; if (Expression1 != null) { expression1Value = Expression1.GetExpressionValue(solutionContext, templateContext, modelContext, interpreterType); } string expression2Value = String.Empty; if (Expression2 != null) { expression2Value = Expression2.GetExpressionValue(solutionContext, templateContext, modelContext, interpreterType); } if (String.IsNullOrEmpty(expression1Value)) { expression1Value = "null"; } if (String.IsNullOrEmpty(expression2Value)) { expression2Value = "null"; } long expression1Long; long expression2Long; double expression1Double; double expression2Double; if (Literal != null) { return(Literal.RawValue); } if (ModelProperty != null) { return(ModelProperty.GetPropertyStringValue(solutionContext, templateContext, modelContext, modelContext, interpreterType)); } if (ModelContext != null) { bool isValidContext; IDomainEnterpriseObject nodeContext = ModelContext.GetModelContext(solutionContext, templateContext, modelContext, out isValidContext); if (nodeContext == null) { return("null"); } else { if (nodeContext.ID == Guid.Empty || nodeContext.ID == null) { return("null"); } return(nodeContext.ID.ToString()); } } else if (CurrentItem != null) { IDomainEnterpriseObject nodeContext = CurrentItem.GetModelContext(solutionContext, templateContext, modelContext); if (nodeContext == null) { return("null"); } else { return(nodeContext.ID.ToString()); } } else if (SpecCurrentItem != null) { IDomainEnterpriseObject nodeContext = SpecCurrentItem.GetModelContext(solutionContext, templateContext, modelContext); if (nodeContext == null) { return("null"); } else { return(nodeContext.ID.ToString()); } } else if (Expression1 != null && Expression2 != null) { if (BinaryOperator != null) { switch (BinaryOperator.Operator) { case "||": if (Expression1.EvaluateExpression(solutionContext, templateContext, modelContext, interpreterType) || Expression2.EvaluateExpression(solutionContext, templateContext, modelContext, interpreterType)) { return("true"); } return("false"); case "&&": if (Expression1.EvaluateExpression(solutionContext, templateContext, modelContext, interpreterType) && Expression2.EvaluateExpression(solutionContext, templateContext, modelContext, interpreterType)) { return("true"); } return("false"); case "==": if (expression1Value == expression2Value) { return("true"); } return("false"); case "!=": if (expression1Value != expression2Value) { return("true"); } return("false"); case "<": if (long.TryParse(expression1Value, out expression1Long) == true && long.TryParse(expression2Value, out expression2Long) == true) { if (expression1Long < expression2Long) { return("true"); } } else if (double.TryParse(expression1Value, out expression1Double) == true && double.TryParse(expression2Value, out expression2Double) == true) { if (expression1Double < expression2Double) { return("true"); } } else { if (expression1Value.Length < expression2Value.Length) { return("true"); } } return("false"); case ">": if (long.TryParse(expression1Value, out expression1Long) == true && long.TryParse(expression2Value, out expression2Long) == true) { if (expression1Long > expression2Long) { return("true"); } } else if (double.TryParse(expression1Value, out expression1Double) == true && double.TryParse(expression2Value, out expression2Double) == true) { if (expression1Double > expression2Double) { return("true"); } } else { if (expression1Value.Length > expression2Value.Length) { return("true"); } } return("false"); case "<=": if (long.TryParse(expression1Value, out expression1Long) == true && long.TryParse(expression2Value, out expression2Long) == true) { if (expression1Long <= expression2Long) { return("true"); } } else if (double.TryParse(expression1Value, out expression1Double) == true && double.TryParse(expression2Value, out expression2Double) == true) { if (expression1Double <= expression2Double) { return("true"); } } else { if (expression1Value.Length <= expression2Value.Length) { return("true"); } } return("false"); case ">=": if (long.TryParse(expression1Value, out expression1Long) == true && long.TryParse(expression2Value, out expression2Long) == true) { if (expression1Long >= expression2Long) { return("true"); } } else if (double.TryParse(expression1Value, out expression1Double) == true && double.TryParse(expression2Value, out expression2Double) == true) { if (expression1Double >= expression2Double) { return("true"); } } else { if (expression1Value.Length >= expression2Value.Length) { return("true"); } } return("false"); default: return("false"); } } else if (MathOperator != null) { switch (MathOperator.Operator) { case "+": if (long.TryParse(expression1Value, out expression1Long) == true && long.TryParse(expression2Value, out expression2Long) == true) { return((expression1Long + expression2Long).ToString()); } else if (double.TryParse(expression1Value, out expression1Double) == true && double.TryParse(expression2Value, out expression2Double) == true) { return((expression1Double + expression2Double).ToString()); } else { return(expression1Value + expression2Value); } case "-": if (long.TryParse(expression1Value, out expression1Long) == true && long.TryParse(expression2Value, out expression2Long) == true) { return((expression1Long - expression2Long).ToString()); } else if (double.TryParse(expression1Value, out expression1Double) == true && double.TryParse(expression2Value, out expression2Double) == true) { return((expression1Double - expression2Double).ToString()); } else { return(expression1Value.Replace(expression2Value, "")); } case "*": if (long.TryParse(expression1Value, out expression1Long) == true && long.TryParse(expression2Value, out expression2Long) == true) { return((expression1Long * expression2Long).ToString()); } else if (double.TryParse(expression1Value, out expression1Double) == true && double.TryParse(expression2Value, out expression2Double) == true) { return((expression1Double * expression2Double).ToString()); } break; case "/": if (long.TryParse(expression1Value, out expression1Long) == true && long.TryParse(expression2Value, out expression2Long) == true && expression2Long != 0) { return((expression1Long / expression2Long).ToString()); } else if (double.TryParse(expression1Value, out expression1Double) == true && double.TryParse(expression2Value, out expression2Double) == true && expression2Double != 0.00) { return((expression1Double / expression2Double).ToString()); } break; default: break; } return("null"); } } else if (Expression1 != null) { return(Expression1.GetExpressionValue(solutionContext, templateContext, modelContext, interpreterType)); } return("null"); }
///-------------------------------------------------------------------------------- /// <summary>Handle debugging workflow.</summary> /// /// <param name="interpreterType">The type of interpretation to perform.</param> /// <param name="solutionContext">The associated solution.</param> /// <param name="templateContext">The associated template.</param> /// <param name="modelContext">The associated model context.</param> ///-------------------------------------------------------------------------------- public bool HandleDebug(InterpreterTypeCode interpreterType, Solution solutionContext, ITemplate templateContext, IDomainEnterpriseObject modelContext) { if (DebugHelper.DebugAction == DebugAction.Stop) { // cause subsequent statements to not execute return(false); } if (solutionContext.IsSampleMode == true) // only allow debugging from designer side using sample mode { if (interpreterType == InterpreterTypeCode.Content) { if (templateContext.ContentBreakpoints.Contains(LineNumber) == true && DebugHelper.DebugAction != DebugAction.Breaking) { // handle breakpoint lock (DebugHelper.DEBUG_OBJECT) { DebugHelper.DebugAction = DebugAction.Breaking; } // fire breaking event solutionContext.HandleBreakpoint(interpreterType, templateContext, modelContext, LineNumber); lock (DebugHelper.DEBUG_OBJECT) { while (DebugHelper.DebugAction == DebugAction.Breaking) { Monitor.Wait(DebugHelper.DEBUG_OBJECT); } } if (DebugHelper.DebugAction == DebugAction.Stop) { // cause subsequent statements to not execute return(false); } lock (DebugHelper.DEBUG_OBJECT) { DebugHelper.DebugAction = DebugAction.Continue; } } } else if (interpreterType == InterpreterTypeCode.Output) { if (templateContext.OutputBreakpoints.Contains(LineNumber) == true && DebugHelper.DebugAction != DebugAction.Breaking) { // handle breakpoint lock (DebugHelper.DEBUG_OBJECT) { DebugHelper.DebugAction = DebugAction.Breaking; } // fire breaking event solutionContext.HandleBreakpoint(interpreterType, templateContext, modelContext, LineNumber); lock (DebugHelper.DEBUG_OBJECT) { while (DebugHelper.DebugAction == DebugAction.Breaking) { Monitor.Wait(DebugHelper.DEBUG_OBJECT); } } if (DebugHelper.DebugAction == DebugAction.Stop) { // cause subsequent statements to not execute return(false); } lock (DebugHelper.DEBUG_OBJECT) { DebugHelper.DebugAction = DebugAction.Continue; } } } } return(true); }
///-------------------------------------------------------------------------------- /// <summary>Log an exception associated with this node.</summary> /// /// <param name="solutionContext">The associated solution.</param> /// <param name="templateContext">The associated template.</param> /// <param name="modelContext">The associated model context.</param> /// <param name="messageBody">The main body message to show.</param> /// <param name="interpreterType">The interpreter type, such as content or output.</param> ///-------------------------------------------------------------------------------- public string LogException(Solution solutionContext, ITemplate templateContext, IDomainEnterpriseObject modelContext, string messageBody, InterpreterTypeCode interpreterType = InterpreterTypeCode.None) { return(templateContext.LogException(solutionContext, modelContext, messageBody, LineNumber, interpreterType)); }
///-------------------------------------------------------------------------------- /// <summary>Log an exception associated with this node.</summary> /// /// <param name="solutionContext">The associated solution.</param> /// <param name="templateContext">The associated template.</param> /// <param name="modelContext">The associated model context.</param> /// <param name="ex">The exception to show.</param> /// <param name="interpreterType">The interpreter type, such as content or output.</param> ///-------------------------------------------------------------------------------- public string LogException(Solution solutionContext, ITemplate templateContext, IDomainEnterpriseObject modelContext, System.Exception ex, InterpreterTypeCode interpreterType = InterpreterTypeCode.None) { return(LogException(solutionContext, templateContext, modelContext, ex.Message + "\r\n" + ex.StackTrace, interpreterType)); }
///-------------------------------------------------------------------------------- /// <summary>Interpret this node to produce code, output, or model data..</summary> /// /// <param name="interpreterType">The type of interpretation to perform.</param> /// <param name="solutionContext">The associated solution.</param> /// <param name="templateContext">The associated template.</param> /// <param name="modelContext">The associated model context.</param> ///-------------------------------------------------------------------------------- public void InterpretNode(InterpreterTypeCode interpreterType, Solution solutionContext, ITemplate templateContext, IDomainEnterpriseObject modelContext) { }
///-------------------------------------------------------------------------------- /// <summary>Interpret this node to produce code, output, or model data..</summary> /// /// <param name="interpreterType">The type of interpretation to perform.</param> /// <param name="solutionContext">The associated solution.</param> /// <param name="templateContext">The associated template.</param> /// <param name="modelContext">The associated model context.</param> ///-------------------------------------------------------------------------------- public void InterpretNode(InterpreterTypeCode interpreterType, Solution solutionContext, ITemplate templateContext, IDomainEnterpriseObject modelContext) { try { if (CurrentItem != null) { if (CurrentItem.CurrentItemName == Enum.GetName(typeof(CurrentItemTypeCode), CurrentItemTypeCode.CurrentAuditProperty)) { if (solutionContext.CurrentAuditProperty != null) { AuditProperty.DeleteCurrentItemFromSolution(solutionContext); if (solutionContext.IsSampleMode == true) { templateContext.MessageBuilder.Append("\r\n- AuditProperty: ").Append(solutionContext.CurrentAuditProperty.InnerXmlData); } } } else if (CurrentItem.CurrentItemName == Enum.GetName(typeof(CurrentItemTypeCode), CurrentItemTypeCode.CurrentCollection)) { if (solutionContext.CurrentCollection != null) { Collection.DeleteCurrentItemFromSolution(solutionContext); if (solutionContext.IsSampleMode == true) { templateContext.MessageBuilder.Append("\r\n- Collection: ").Append(solutionContext.CurrentCollection.InnerXmlData); } } } else if (CurrentItem.CurrentItemName == Enum.GetName(typeof(CurrentItemTypeCode), CurrentItemTypeCode.CurrentEntity)) { if (solutionContext.CurrentEntity != null) { Entity.DeleteCurrentItemFromSolution(solutionContext); if (solutionContext.IsSampleMode == true) { templateContext.MessageBuilder.Append("\r\n- Entity: ").Append(solutionContext.CurrentEntity.InnerXmlData); } } } else if (CurrentItem.CurrentItemName == Enum.GetName(typeof(CurrentItemTypeCode), CurrentItemTypeCode.CurrentEntityReference)) { if (solutionContext.CurrentEntityReference != null) { EntityReference.DeleteCurrentItemFromSolution(solutionContext); if (solutionContext.IsSampleMode == true) { templateContext.MessageBuilder.Append("\r\n- EntityReference: ").Append(solutionContext.CurrentEntityReference.InnerXmlData); } } } else if (CurrentItem.CurrentItemName == Enum.GetName(typeof(CurrentItemTypeCode), CurrentItemTypeCode.CurrentEnumeration)) { if (solutionContext.CurrentEnumeration != null) { Enumeration.DeleteCurrentItemFromSolution(solutionContext); if (solutionContext.IsSampleMode == true) { templateContext.MessageBuilder.Append("\r\n- Enumeration: ").Append(solutionContext.CurrentEnumeration.InnerXmlData); } } } else if (CurrentItem.CurrentItemName == Enum.GetName(typeof(CurrentItemTypeCode), CurrentItemTypeCode.CurrentFeature)) { if (solutionContext.CurrentFeature != null) { Feature.DeleteCurrentItemFromSolution(solutionContext); if (solutionContext.IsSampleMode == true) { templateContext.MessageBuilder.Append("\r\n- Feature: ").Append(solutionContext.CurrentFeature.InnerXmlData); } } } else if (CurrentItem.CurrentItemName == Enum.GetName(typeof(CurrentItemTypeCode), CurrentItemTypeCode.CurrentIndex)) { if (solutionContext.CurrentIndex != null) { Index.DeleteCurrentItemFromSolution(solutionContext); if (solutionContext.IsSampleMode == true) { templateContext.MessageBuilder.Append("\r\n- Index: ").Append(solutionContext.CurrentIndex.InnerXmlData); } } } else if (CurrentItem.CurrentItemName == Enum.GetName(typeof(CurrentItemTypeCode), CurrentItemTypeCode.CurrentIndexProperty)) { if (solutionContext.CurrentIndexProperty != null) { IndexProperty.DeleteCurrentItemFromSolution(solutionContext); if (solutionContext.IsSampleMode == true) { templateContext.MessageBuilder.Append("\r\n- IndexProperty: ").Append(solutionContext.CurrentIndexProperty.InnerXmlData); } } } else if (CurrentItem.CurrentItemName == Enum.GetName(typeof(CurrentItemTypeCode), CurrentItemTypeCode.CurrentMethod)) { if (solutionContext.CurrentMethod != null) { Method.DeleteCurrentItemFromSolution(solutionContext); if (solutionContext.IsSampleMode == true) { templateContext.MessageBuilder.Append("\r\n- Method: ").Append(solutionContext.CurrentMethod.InnerXmlData); } } } else if (CurrentItem.CurrentItemName == Enum.GetName(typeof(CurrentItemTypeCode), CurrentItemTypeCode.CurrentMethodRelationship)) { if (solutionContext.CurrentMethodRelationship != null) { MethodRelationship.DeleteCurrentItemFromSolution(solutionContext); if (solutionContext.IsSampleMode == true) { templateContext.MessageBuilder.Append("\r\n- MethodRelationship: ").Append(solutionContext.CurrentMethodRelationship.InnerXmlData); } } } else if (CurrentItem.CurrentItemName == Enum.GetName(typeof(CurrentItemTypeCode), CurrentItemTypeCode.CurrentModel)) { if (solutionContext.CurrentModel != null) { Model.DeleteCurrentItemFromSolution(solutionContext); if (solutionContext.IsSampleMode == true) { templateContext.MessageBuilder.Append("\r\n- Model: ").Append(solutionContext.CurrentModel.InnerXmlData); } } } else if (CurrentItem.CurrentItemName == Enum.GetName(typeof(CurrentItemTypeCode), CurrentItemTypeCode.CurrentModelObject)) { if (solutionContext.CurrentModelObject != null) { ModelObject.DeleteCurrentItemFromSolution(solutionContext); if (solutionContext.IsSampleMode == true) { templateContext.MessageBuilder.Append("\r\n- ModelObject: ").Append(solutionContext.CurrentModelObject.InnerXmlData); } } } else if (CurrentItem.CurrentItemName == Enum.GetName(typeof(CurrentItemTypeCode), CurrentItemTypeCode.CurrentModelProperty)) { if (solutionContext.CurrentModelProperty != null) { ModelProperty.DeleteCurrentItemFromSolution(solutionContext); if (solutionContext.IsSampleMode == true) { templateContext.MessageBuilder.Append("\r\n- ModelProperty: ").Append(solutionContext.CurrentModelProperty.InnerXmlData); } } } else if (CurrentItem.CurrentItemName == Enum.GetName(typeof(CurrentItemTypeCode), CurrentItemTypeCode.CurrentObjectInstance)) { if (solutionContext.CurrentObjectInstance != null) { ObjectInstance.DeleteCurrentItemFromSolution(solutionContext); if (solutionContext.IsSampleMode == true) { templateContext.MessageBuilder.Append("\r\n- ObjectInstance: ").Append(solutionContext.CurrentObjectInstance.InnerXmlData); } } } else if (CurrentItem.CurrentItemName == Enum.GetName(typeof(CurrentItemTypeCode), CurrentItemTypeCode.CurrentParameter)) { if (solutionContext.CurrentParameter != null) { Parameter.DeleteCurrentItemFromSolution(solutionContext); if (solutionContext.IsSampleMode == true) { templateContext.MessageBuilder.Append("\r\n- Parameter: ").Append(solutionContext.CurrentParameter.InnerXmlData); } } } else if (CurrentItem.CurrentItemName == Enum.GetName(typeof(CurrentItemTypeCode), CurrentItemTypeCode.CurrentProject)) { if (solutionContext.CurrentProject != null) { Project.DeleteCurrentItemFromSolution(solutionContext); if (solutionContext.IsSampleMode == true) { templateContext.MessageBuilder.Append("\r\n- Project: ").Append(solutionContext.CurrentProject.InnerXmlData); } } } else if (CurrentItem.CurrentItemName == Enum.GetName(typeof(CurrentItemTypeCode), CurrentItemTypeCode.CurrentProperty)) { if (solutionContext.CurrentProperty != null) { Property.DeleteCurrentItemFromSolution(solutionContext); if (solutionContext.IsSampleMode == true) { templateContext.MessageBuilder.Append("\r\n- Property: ").Append(solutionContext.CurrentProperty.InnerXmlData); } } } else if (CurrentItem.CurrentItemName == Enum.GetName(typeof(CurrentItemTypeCode), CurrentItemTypeCode.CurrentPropertyInstance)) { if (solutionContext.CurrentPropertyInstance != null) { PropertyInstance.DeleteCurrentItemFromSolution(solutionContext); if (solutionContext.IsSampleMode == true) { templateContext.MessageBuilder.Append("\r\n- PropertyInstance: ").Append(solutionContext.CurrentPropertyInstance.InnerXmlData); } } } else if (CurrentItem.CurrentItemName == Enum.GetName(typeof(CurrentItemTypeCode), CurrentItemTypeCode.CurrentPropertyReference)) { if (solutionContext.CurrentPropertyReference != null) { PropertyReference.DeleteCurrentItemFromSolution(solutionContext); if (solutionContext.IsSampleMode == true) { templateContext.MessageBuilder.Append("\r\n- PropertyReference: ").Append(solutionContext.CurrentPropertyReference.InnerXmlData); } } } else if (CurrentItem.CurrentItemName == Enum.GetName(typeof(CurrentItemTypeCode), CurrentItemTypeCode.CurrentPropertyRelationship)) { if (solutionContext.CurrentPropertyRelationship != null) { PropertyRelationship.DeleteCurrentItemFromSolution(solutionContext); if (solutionContext.IsSampleMode == true) { templateContext.MessageBuilder.Append("\r\n- PropertyRelationship: ").Append(solutionContext.CurrentPropertyRelationship.InnerXmlData); } } } else if (CurrentItem.CurrentItemName == Enum.GetName(typeof(CurrentItemTypeCode), CurrentItemTypeCode.CurrentRelationship)) { if (solutionContext.CurrentRelationship != null) { Relationship.DeleteCurrentItemFromSolution(solutionContext); if (solutionContext.IsSampleMode == true) { templateContext.MessageBuilder.Append("\r\n- Relationship: ").Append(solutionContext.CurrentRelationship.InnerXmlData); } } } else if (CurrentItem.CurrentItemName == Enum.GetName(typeof(CurrentItemTypeCode), CurrentItemTypeCode.CurrentRelationshipProperty)) { if (solutionContext.CurrentRelationshipProperty != null) { RelationshipProperty.DeleteCurrentItemFromSolution(solutionContext); if (solutionContext.IsSampleMode == true) { templateContext.MessageBuilder.Append("\r\n- RelationshipProperty: ").Append(solutionContext.CurrentRelationshipProperty.InnerXmlData); } } } else if (CurrentItem.CurrentItemName == Enum.GetName(typeof(CurrentItemTypeCode), CurrentItemTypeCode.CurrentStage)) { if (solutionContext.CurrentStage != null) { Stage.DeleteCurrentItemFromSolution(solutionContext); if (solutionContext.IsSampleMode == true) { templateContext.MessageBuilder.Append("\r\n- Stage: ").Append(solutionContext.CurrentStage.InnerXmlData); } } } else if (CurrentItem.CurrentItemName == Enum.GetName(typeof(CurrentItemTypeCode), CurrentItemTypeCode.CurrentStageTransition)) { if (solutionContext.CurrentStageTransition != null) { StageTransition.DeleteCurrentItemFromSolution(solutionContext); if (solutionContext.IsSampleMode == true) { templateContext.MessageBuilder.Append("\r\n- StageTransition: ").Append(solutionContext.CurrentStageTransition.InnerXmlData); } } } else if (CurrentItem.CurrentItemName == Enum.GetName(typeof(CurrentItemTypeCode), CurrentItemTypeCode.CurrentState)) { if (solutionContext.CurrentState != null) { State.DeleteCurrentItemFromSolution(solutionContext); if (solutionContext.IsSampleMode == true) { templateContext.MessageBuilder.Append("\r\n- State: ").Append(solutionContext.CurrentState.InnerXmlData); } } } else if (CurrentItem.CurrentItemName == Enum.GetName(typeof(CurrentItemTypeCode), CurrentItemTypeCode.CurrentStateModel)) { if (solutionContext.CurrentStateModel != null) { StateModel.DeleteCurrentItemFromSolution(solutionContext); if (solutionContext.IsSampleMode == true) { templateContext.MessageBuilder.Append("\r\n- StateModel: ").Append(solutionContext.CurrentStateModel.InnerXmlData); } } } else if (CurrentItem.CurrentItemName == Enum.GetName(typeof(CurrentItemTypeCode), CurrentItemTypeCode.CurrentStateTransition)) { if (solutionContext.CurrentStateTransition != null) { StateTransition.DeleteCurrentItemFromSolution(solutionContext); if (solutionContext.IsSampleMode == true) { templateContext.MessageBuilder.Append("\r\n- StateTransition: ").Append(solutionContext.CurrentStateTransition.InnerXmlData); } } } else if (CurrentItem.CurrentItemName == Enum.GetName(typeof(CurrentItemTypeCode), CurrentItemTypeCode.CurrentStep)) { if (solutionContext.CurrentStep != null) { Step.DeleteCurrentItemFromSolution(solutionContext); if (solutionContext.IsSampleMode == true) { templateContext.MessageBuilder.Append("\r\n- Step: ").Append(solutionContext.CurrentStep.InnerXmlData); } } } else if (CurrentItem.CurrentItemName == Enum.GetName(typeof(CurrentItemTypeCode), CurrentItemTypeCode.CurrentStepTransition)) { if (solutionContext.CurrentStepTransition != null) { StepTransition.DeleteCurrentItemFromSolution(solutionContext); if (solutionContext.IsSampleMode == true) { templateContext.MessageBuilder.Append("\r\n- StepTransition: ").Append(solutionContext.CurrentStepTransition.InnerXmlData); } } } else if (CurrentItem.CurrentItemName == Enum.GetName(typeof(CurrentItemTypeCode), CurrentItemTypeCode.CurrentValue)) { if (solutionContext.CurrentValue != null) { Value.DeleteCurrentItemFromSolution(solutionContext); if (solutionContext.IsSampleMode == true) { templateContext.MessageBuilder.Append("\r\n- Value: ").Append(solutionContext.CurrentValue.InnerXmlData); } } } else if (CurrentItem.CurrentItemName == Enum.GetName(typeof(CurrentItemTypeCode), CurrentItemTypeCode.CurrentView)) { if (solutionContext.CurrentView != null) { View.DeleteCurrentItemFromSolution(solutionContext); if (solutionContext.IsSampleMode == true) { templateContext.MessageBuilder.Append("\r\n- View: ").Append(solutionContext.CurrentView.InnerXmlData); } } } else if (CurrentItem.CurrentItemName == Enum.GetName(typeof(CurrentItemTypeCode), CurrentItemTypeCode.CurrentViewProperty)) { if (solutionContext.CurrentViewProperty != null) { ViewProperty.DeleteCurrentItemFromSolution(solutionContext); if (solutionContext.IsSampleMode == true) { templateContext.MessageBuilder.Append("\r\n- ViewProperty: ").Append(solutionContext.CurrentViewProperty.InnerXmlData); } } } else if (CurrentItem.CurrentItemName == Enum.GetName(typeof(CurrentItemTypeCode), CurrentItemTypeCode.CurrentWorkflow)) { if (solutionContext.CurrentWorkflow != null) { Workflow.DeleteCurrentItemFromSolution(solutionContext); if (solutionContext.IsSampleMode == true) { templateContext.MessageBuilder.Append("\r\n- Workflow: ").Append(solutionContext.CurrentWorkflow.InnerXmlData); } } } #region protected #endregion protected else { LogException(solutionContext, templateContext, modelContext, String.Format(DisplayValues.Exception_CouldNotDeleteItem, CurrentItem.CurrentItemName), interpreterType); } } } catch (ApplicationAbortException) { throw; } catch (System.Exception ex) { LogException(solutionContext, templateContext, modelContext, ex, interpreterType); } }
///-------------------------------------------------------------------------------- /// <summary>This method gets the model context associated with this node.</summary> /// /// <param name="solutionContext">The associated solution.</param> /// <param name="templateContext">The associated template.</param> /// <param name="modelContext">The associated model context.</param> /// <param name="helperModelContext">The associated helper model context node.</param> /// <param name="interpreterType">The type of interpretation to perform.</param> ///-------------------------------------------------------------------------------- public IDomainEnterpriseObject GetModelContext(Solution solutionContext, ITemplate templateContext, IDomainEnterpriseObject modelContext, ModelContextNode helperModelContext, InterpreterTypeCode interpreterType) { IDomainEnterpriseObject parentContext = modelContext; if (ModelContext != null) { bool isValidContext; parentContext = ModelContext.GetModelContext(solutionContext, templateContext, modelContext, out isValidContext); } else if (CurrentItem != null) { parentContext = CurrentItem.GetModelContext(solutionContext, templateContext, modelContext); } if (MethodName == LanguageTerms.FindMethod) { IEnterpriseEnumerable collection = helperModelContext.GetCollection(solutionContext, templateContext, parentContext); if (collection != null) { if (ModelProperty != null) { object paramValue = Parameter.GetObjectValue(solutionContext, templateContext, modelContext, interpreterType); IDomainEnterpriseObject item = collection.FindItem(ModelProperty.ModelPropertyName, paramValue) as IDomainEnterpriseObject; if (item != null) { return(item); } if (modelContext is ObjectInstance) { // get item by specified model property foreach (ObjectInstance instance in collection) { foreach (PropertyInstance property in instance.PropertyInstanceList) { if (property.ModelPropertyName == ModelProperty.ModelPropertyName && property.PropertyValue == paramValue.ToString()) { return(instance); } } } } return(null); } else { string parameterValue = Parameter.GetStringValue(solutionContext, templateContext, modelContext, interpreterType); Guid parameterID = Guid.Empty; if (Guid.TryParse(parameterValue, out parameterID)) { return(collection.FindItemByID(parameterID) as IDomainEnterpriseObject); } else { LogException(solutionContext, templateContext, modelContext, DisplayValues.Message_InterpreterBadFindParameter, interpreterType); } } } return(null); } return(modelContext); }
///-------------------------------------------------------------------------------- /// <summary>Interpret this node to produce code, output, or model data..</summary> /// /// <param name="interpreterType">The type of interpretation to perform.</param> /// <param name="solutionContext">The associated solution.</param> /// <param name="templateContext">The associated template.</param> /// <param name="modelContext">The associated model context.</param> ///-------------------------------------------------------------------------------- public void InterpretNode(InterpreterTypeCode interpreterType, Solution solutionContext, ITemplate templateContext, IDomainEnterpriseObject modelContext) { try { string text; if (CustomText != null) { text = CustomText.GetStringValue(solutionContext, templateContext, modelContext, interpreterType); } else { text = templateContext.ContentCodeBuilder.ToString(); } string path = FilePath.GetStringValue(solutionContext, templateContext, modelContext, interpreterType); if (!String.IsNullOrEmpty(text) && !String.IsNullOrEmpty(path)) { if (solutionContext.IsSampleMode == true) { // don't perform replacement of output files, just indicate it would be output templateContext.MessageBuilder.Append("\r\n> "); templateContext.MessageBuilder.Append(path); } else if (solutionContext.LoggedErrors.Count == 0) { if (File.Exists(path) == true) { if (solutionContext.UseProtectedAreas == true && String.IsNullOrEmpty(solutionContext.ProtectedAreaStart) == false && String.IsNullOrEmpty(solutionContext.ProtectedAreaEnd) == false) { // preserve protected areas in output file string originalText = FileHelper.GetText(path); if (originalText.Contains(solutionContext.ProtectedAreaStart) && originalText.Contains(solutionContext.ProtectedAreaEnd)) { int currentTextIndex = 0; int currentOriginalTextIndex = 0; bool hasProtectedText = false; StringBuilder updatedText = new StringBuilder(); while (currentTextIndex < (text.Length - 1)) { if (text.IndexOf(solutionContext.ProtectedAreaStart, currentTextIndex) >= 0 && text.IndexOf(solutionContext.ProtectedAreaEnd, text.IndexOf(solutionContext.ProtectedAreaStart, currentTextIndex)) >= 0) { // append text to next protected block updatedText.Append(text.Substring(currentTextIndex, text.IndexOf(solutionContext.ProtectedAreaStart, currentTextIndex) - currentTextIndex)); currentTextIndex = text.IndexOf(solutionContext.ProtectedAreaStart, currentTextIndex); if (originalText.IndexOf(solutionContext.ProtectedAreaStart, currentOriginalTextIndex) >= 0 && originalText.IndexOf(solutionContext.ProtectedAreaEnd, originalText.IndexOf(solutionContext.ProtectedAreaStart, currentOriginalTextIndex)) >= 0) { hasProtectedText = true; currentOriginalTextIndex = originalText.IndexOf(solutionContext.ProtectedAreaStart, currentOriginalTextIndex); if (String.IsNullOrWhiteSpace(originalText.Substring(currentOriginalTextIndex + solutionContext.ProtectedAreaStart.Length, originalText.IndexOf(solutionContext.ProtectedAreaEnd, currentOriginalTextIndex) - currentOriginalTextIndex - solutionContext.ProtectedAreaStart.Length))) { hasProtectedText = false; } if (hasProtectedText == true) { // append protected block in original text updatedText.Append(originalText.Substring(currentOriginalTextIndex, originalText.IndexOf(solutionContext.ProtectedAreaEnd, currentOriginalTextIndex) - currentOriginalTextIndex + solutionContext.ProtectedAreaEnd.Length)); } else { // append protected block in generated text updatedText.Append(text.Substring(currentTextIndex, text.IndexOf(solutionContext.ProtectedAreaEnd, currentTextIndex) - currentTextIndex + solutionContext.ProtectedAreaEnd.Length)); } currentOriginalTextIndex = originalText.IndexOf(solutionContext.ProtectedAreaEnd, currentOriginalTextIndex) + solutionContext.ProtectedAreaEnd.Length; // skip protected block in text currentTextIndex = text.IndexOf(solutionContext.ProtectedAreaEnd, currentTextIndex) + solutionContext.ProtectedAreaEnd.Length; } else { // append remainder of text to updated text updatedText.Append(text.Substring(currentTextIndex)); currentTextIndex = text.Length - 1; } } else { // append remainder of text to updated text updatedText.Append(text.Substring(currentTextIndex)); currentTextIndex = text.Length - 1; // append remainder of protected blocks in original text (if any, user will have to move/replace these blocks) while (originalText.IndexOf(solutionContext.ProtectedAreaStart, currentOriginalTextIndex) >= 0 && originalText.IndexOf(solutionContext.ProtectedAreaEnd, originalText.IndexOf(solutionContext.ProtectedAreaStart, currentOriginalTextIndex)) >= 0) { hasProtectedText = true; currentOriginalTextIndex = originalText.IndexOf(solutionContext.ProtectedAreaStart, currentOriginalTextIndex); if (String.IsNullOrWhiteSpace(originalText.Substring(currentOriginalTextIndex + solutionContext.ProtectedAreaStart.Length, originalText.IndexOf(solutionContext.ProtectedAreaEnd, currentOriginalTextIndex) - currentOriginalTextIndex - solutionContext.ProtectedAreaStart.Length))) { hasProtectedText = false; } if (hasProtectedText == true) { updatedText.Append(originalText.Substring(currentOriginalTextIndex, originalText.IndexOf(solutionContext.ProtectedAreaEnd, currentOriginalTextIndex) - currentOriginalTextIndex + solutionContext.ProtectedAreaEnd.Length)); } currentOriginalTextIndex = originalText.IndexOf(solutionContext.ProtectedAreaEnd, currentOriginalTextIndex) + solutionContext.ProtectedAreaEnd.Length; } } } FileHelper.ReplaceFile(path, updatedText.ToString()); } else { // replace file if protected tags not found FileHelper.ReplaceFile(path, text); } } else { // replace file wholesale FileHelper.ReplaceFile(path, text); } } else { string directory = Directory.GetParent(path).FullName; if (!Directory.Exists(directory)) { Directory.CreateDirectory(directory); } FileHelper.CreateFile(path, text); } } } } catch (ApplicationAbortException) { throw; } catch (System.Exception ex) { LogException(solutionContext, templateContext, modelContext, ex, interpreterType); } }
///-------------------------------------------------------------------------------- /// <summary>This method updates visibility based on current debug state.</summary> /// /// <param name="solution">The corresponding solution.</param> ///-------------------------------------------------------------------------------- public void SetDebugVisibility(DebugAction debugAction, InterpreterTypeCode debugType, Guid templateID) { switch (debugAction) { case DebugAction.Breaking: case DebugAction.Continue: IsDebuggerRunning = true; break; default: IsDebuggerRunning = false; break; } switch (debugType) { case InterpreterTypeCode.Content: if (TemplateID != templateID) { // make everything invisible ContentDebugGoVisibility = "Collapsed"; ContentDebugStopVisibility = "Collapsed"; ContentWatchesVisibility = "Collapsed"; OutputDebugGoVisibility = "Collapsed"; OutputDebugStopVisibility = "Collapsed"; OutputWatchesVisibility = "Collapsed"; IsContentWatchReadOnly = true; IsOutputWatchReadOnly = true; } else { OutputDebugGoVisibility = "Collapsed"; OutputDebugStopVisibility = "Collapsed"; OutputWatchesVisibility = "Collapsed"; IsOutputWatchReadOnly = true; switch (debugAction) { case DebugAction.Breaking: ContentDebugGoVisibility = "Visible"; ContentDebugStopVisibility = "Visible"; ContentWatchesVisibility = "Visible"; IsContentWatchReadOnly = false; break; case DebugAction.Continue: ContentDebugGoVisibility = "Collapsed"; ContentDebugStopVisibility = "Visible"; ContentWatchesVisibility = "Visible"; IsContentWatchReadOnly = true; break; default: OutputDebugGoVisibility = "Visible"; ContentDebugGoVisibility = "Visible"; ContentDebugStopVisibility = "Collapsed"; ContentWatchesVisibility = "Collapsed"; IsContentWatchReadOnly = true; break; } } break; case InterpreterTypeCode.Output: if (TemplateID != templateID) { // make everything invisible ContentDebugGoVisibility = "Collapsed"; ContentDebugStopVisibility = "Collapsed"; ContentWatchesVisibility = "Collapsed"; OutputDebugGoVisibility = "Collapsed"; OutputDebugStopVisibility = "Collapsed"; OutputWatchesVisibility = "Collapsed"; IsContentWatchReadOnly = true; IsOutputWatchReadOnly = true; } else { ContentDebugGoVisibility = "Collapsed"; ContentDebugStopVisibility = "Collapsed"; ContentWatchesVisibility = "Collapsed"; IsContentWatchReadOnly = true; switch (debugAction) { case DebugAction.Breaking: OutputDebugGoVisibility = "Visible"; OutputDebugStopVisibility = "Visible"; OutputWatchesVisibility = "Visible"; IsOutputWatchReadOnly = false; break; case DebugAction.Continue: OutputDebugGoVisibility = "Collapsed"; OutputDebugStopVisibility = "Visible"; OutputWatchesVisibility = "Visible"; IsOutputWatchReadOnly = true; break; default: ContentDebugGoVisibility = "Visible"; OutputDebugGoVisibility = "Visible"; OutputDebugStopVisibility = "Collapsed"; OutputWatchesVisibility = "Collapsed"; IsOutputWatchReadOnly = true; break; } } break; default: // assume debugging is done, set to initial state ContentDebugGoVisibility = "Visible"; ContentDebugStopVisibility = "Collapsed"; ContentWatchesVisibility = "Collapsed"; OutputDebugGoVisibility = "Visible"; OutputDebugStopVisibility = "Collapsed"; OutputWatchesVisibility = "Collapsed"; break; } }
///-------------------------------------------------------------------------------- /// <summary>Interpret this node to produce code, output, or model data..</summary> /// /// <param name="interpreterType">The type of interpretation to perform.</param> /// <param name="solutionContext">The associated solution.</param> /// <param name="templateContext">The associated template.</param> /// <param name="modelContext">The associated model context.</param> ///-------------------------------------------------------------------------------- public void InterpretNode(InterpreterTypeCode interpreterType, Solution solutionContext, ITemplate templateContext, IDomainEnterpriseObject modelContext) { try { int itemIndex = 0; templateContext.ItemIndex = itemIndex; if (ForeachClause.ForeachHelperName == LanguageTerms.RecordItem) { bool isValidContext; Entity entityContext = Entity.GetModelContext(solutionContext, modelContext, out isValidContext) as Entity; if (entityContext != null) { templateContext.PushModelContext(entityContext); SqlDbManager manager = new SqlDbManager(new DatabaseOptions(solutionContext.SourceDbServerName, solutionContext.SourceDbName)); string sqlStatement = "SELECT * FROM " + entityContext.DBTableName; templateContext.DbReader = manager.ExecuteRawSqlReader(sqlStatement); while (templateContext.DbReader.Read()) { if (ForeachClause.LimitClause == null || ForeachClause.LimitClause.Limit >= itemIndex + 1) { templateContext.IsBreaking = false; templateContext.IsContinuing = false; foreach (IStatementNode node in Statements) { if (node.HandleDebug(interpreterType, solutionContext, templateContext, entityContext) == false) { return; } if (templateContext.IsContinuing == true) { break; } if (templateContext.IsBreaking == true || templateContext.IsReturning == true) { templateContext.IsBreaking = false; break; } if (node is BreakStatementNode) { templateContext.IsBreaking = true; break; } if (node is ContinueStatementNode) { break; } if (node is ReturnStatementNode) { templateContext.IsReturning = true; break; } node.InterpretNode(interpreterType, solutionContext, templateContext, modelContext); } itemIndex++; templateContext.ItemIndex = itemIndex; } } manager.Close(); manager = null; templateContext.DbReader = null; templateContext.PopModelContext(); } } else { IEnterpriseEnumerable collection = GetCollection(solutionContext, templateContext, modelContext, interpreterType); if (collection != null) { foreach (IDomainEnterpriseObject itemContext in collection) { templateContext.PushModelContext(itemContext); if (templateContext.IsBreaking == true || templateContext.IsReturning == true) { templateContext.IsBreaking = false; break; } if (ForeachClause.WhereClause == null || ForeachClause.WhereClause.Expression.EvaluateExpression(solutionContext, templateContext, itemContext, interpreterType) == true) { if (ForeachClause.LimitClause == null || ForeachClause.LimitClause.Limit >= itemIndex + 1) { templateContext.IsBreaking = false; templateContext.IsContinuing = false; foreach (IStatementNode node in Statements) { if (node.HandleDebug(interpreterType, solutionContext, templateContext, itemContext) == false) { return; } if (templateContext.IsContinuing == true) { break; } if (templateContext.IsBreaking == true || templateContext.IsReturning == true) { templateContext.IsBreaking = false; break; } if (node is BreakStatementNode) { templateContext.IsBreaking = true; break; } if (node is ContinueStatementNode) { break; } if (node is ReturnStatementNode) { templateContext.IsReturning = true; break; } node.InterpretNode(interpreterType, solutionContext, templateContext, itemContext); } } itemIndex++; templateContext.ItemIndex = itemIndex; } templateContext.PopModelContext(); } } templateContext.IsBreaking = false; } templateContext.ItemIndex = 0; } catch (ApplicationAbortException) { throw; } catch (System.Exception ex) { LogException(solutionContext, templateContext, modelContext, ex, interpreterType); } }
///-------------------------------------------------------------------------------- /// <summary>This method gets the collection context associated with this node.</summary> /// /// <param name="solutionContext">The associated solution.</param> /// <param name="templateContext">The associated template.</param> /// <param name="modelContext">The associated model context.</param> ///-------------------------------------------------------------------------------- public IEnterpriseEnumerable GetCollection(Solution solutionContext, ITemplate templateContext, IDomainEnterpriseObject modelContext, InterpreterTypeCode interpreterType) { IEnterpriseEnumerable collection = null; if (ForeachClause.ModelContext != null) { if (ForeachClause.InClause != null) { collection = ForeachClause.InClause.InClauselItem.GetCollection(solutionContext, templateContext, modelContext, ForeachClause.ModelContext, interpreterType); } else { collection = ForeachClause.ModelContext.GetCollection(solutionContext, templateContext, modelContext); } if (ForeachClause.SortClause != null) { if (ForeachClause.SortClause.SortDirectionClause != null && ForeachClause.SortClause.SortDirectionClause.AscendingSort == false) { collection.Sort(ForeachClause.SortClause.ModelProperty.ModelPropertyName, SortDirection.Descending); } else { collection.Sort(ForeachClause.SortClause.ModelProperty.ModelPropertyName, SortDirection.Ascending); } } } return(collection); }