public static SequenceContainerWrapper CreateSequenceContainer(SequenceContainer sequenceContainer, ProjectWrapper projectWrapper, PackageWrapper packageWrapper, ContainerWrapper containerWrapper, List <ScriptProject> globalScriptProjects) { SequenceContainerWrapper sequenceContainerWrapper = new SequenceContainerWrapper(containerWrapper) { Name = sequenceContainer.Name, DelayValidation = sequenceContainer.DelayValidation, ForceExecutionResult = sequenceContainer.ForceExecutionResult.ToString() }; AddExpressions(sequenceContainerWrapper, sequenceContainer.PropertyExpressions); CreateTasks(projectWrapper, packageWrapper, sequenceContainerWrapper, sequenceContainer.Tasks, globalScriptProjects); return(sequenceContainerWrapper); }
public override void Initialize(Invert.IOC.UFrameContainer container) { container.AddItem <RequireReference>(); container.AddTypeItem <OutputsChildItem>(); container.AddTypeItem <InputsChildItem>(); container.AddTypeItem <VariablesChildItem>(); container.AddTypeItem <PropertiesChildItem>(); container.AddTypeItem <CollectionsChildItem>(); container.AddItem <BranchesChildItem>(); CustomAction = container.AddNode <CustomActionNode, CustomActionNodeViewModel, CustomActionNodeDrawer>("CustomAction"); CustomAction.Color(NodeColor.Gray); Data = container.AddGraph <DataGraph, DataNode>("DataGraph"); Data.Color(NodeColor.Yellow); Data.HasSubNode <GroupNode>(); Data.HasSubNode <EventNode>(); Data.HasSubNode <ComponentNode>(); Library = container.AddGraph <LibraryGraph, LibraryNode>("LibraryGraph"); Library.Color(NodeColor.Yellow); Library.HasSubNode <GroupNode>(); Library.HasSubNode <EventNode>(); Library.HasSubNode <CustomActionNode>(); Library.HasSubNode <ComponentNode>(); Null = container.AddNode <NullNode, NullNodeViewModel, NullNodeDrawer>("Null"); Null.Color(NodeColor.Purple); StringLiteral = container.AddNode <StringLiteralNode, StringLiteralNodeViewModel, StringLiteralNodeDrawer>("StringLiteral"); StringLiteral.Color(NodeColor.Gray); Property = container.AddNode <PropertyNode, PropertyNodeViewModel, PropertyNodeDrawer>("Property"); Property.Color(NodeColor.Blue); String = container.AddNode <StringNode, StringNodeViewModel, StringNodeDrawer>("String"); String.Color(NodeColor.Purple); ActionGroup = container.AddNode <ActionGroupNode, ActionGroupNodeViewModel, ActionGroupNodeDrawer>("ActionGroup"); ActionGroup.Color(NodeColor.Red); Function = container.AddNode <FunctionNode, FunctionNodeViewModel, FunctionNodeDrawer>("Function"); Function.Color(NodeColor.Lightgoldenrod4); Bool = container.AddNode <BoolNode, BoolNodeViewModel, BoolNodeDrawer>("Bool"); Bool.Color(NodeColor.Purple); Module = container.AddGraph <ModuleGraph, ModuleNode>("ModuleGraph"); Module.Color(NodeColor.Black); Module.HasSubNode <EventNode>(); Module.HasSubNode <ComponentNode>(); Module.HasSubNode <CustomActionNode>(); Module.HasSubNode <SystemNode>(); Module.HasSubNode <GroupNode>(); StopTimer = container.AddNode <StopTimerNode, StopTimerNodeViewModel, StopTimerNodeDrawer>("StopTimer"); StopTimer.Color(NodeColor.Gray); AllFalse = container.AddNode <AllFalseNode, AllFalseNodeViewModel, AllFalseNodeDrawer>("AllFalse"); AllFalse.Color(NodeColor.Orange); CodeAction = container.AddNode <CodeActionNode, CodeActionNodeViewModel, CodeActionNodeDrawer>("CodeAction"); CodeAction.Color(NodeColor.Green); BoolExpression = container.AddNode <BoolExpressionNode, BoolExpressionNodeViewModel, BoolExpressionNodeDrawer>("BoolExpression"); BoolExpression.Color(NodeColor.Gray); Float = container.AddNode <FloatNode, FloatNodeViewModel, FloatNodeDrawer>("Float"); Float.Color(NodeColor.Purple); UserMethod = container.AddNode <UserMethodNode, UserMethodNodeViewModel, UserMethodNodeDrawer>("UserMethod"); UserMethod.Color(NodeColor.Blue); LoopCollection = container.AddNode <LoopCollectionNode, LoopCollectionNodeViewModel, LoopCollectionNodeDrawer>("LoopCollection"); LoopCollection.Color(NodeColor.LightGray); AnyFalse = container.AddNode <AnyFalseNode, AnyFalseNodeViewModel, AnyFalseNodeDrawer>("AnyFalse"); AnyFalse.Color(NodeColor.Orange); ComponentCreated = container.AddNode <ComponentCreatedNode, ComponentCreatedNodeViewModel, ComponentCreatedNodeDrawer>("ComponentCreated"); ComponentCreated.Color(NodeColor.Indianred4); SetVariable = container.AddNode <SetVariableNode, SetVariableNodeViewModel, SetVariableNodeDrawer>("SetVariable"); SetVariable.Color(NodeColor.Gray); CollectionItemRemoved = container.AddNode <CollectionItemRemovedNode, CollectionItemRemovedNodeViewModel, CollectionItemRemovedNodeDrawer>("CollectionItemRemoved"); CollectionItemRemoved.Color(NodeColor.Indianred4); CollectionModifiedHandler = container.AddNode <CollectionModifiedHandlerNode, CollectionModifiedHandlerNodeViewModel, CollectionModifiedHandlerNodeDrawer>("CollectionModifiedHandler"); CollectionModifiedHandler.Color(NodeColor.Red); Object = container.AddNode <ObjectNode, ObjectNodeViewModel, ObjectNodeDrawer>("Object"); Object.Color(NodeColor.Purple); PropertyChanged = container.AddNode <PropertyChangedNode, PropertyChangedNodeViewModel, PropertyChangedNodeDrawer>("PropertyChanged"); PropertyChanged.Color(NodeColor.Indianred4); Variable = container.AddNode <VariableNode, VariableNodeViewModel, VariableNodeDrawer>("Variable"); Variable.Color(NodeColor.Gray); Group = container.AddNode <GroupNode, GroupNodeViewModel, GroupNodeDrawer>("Group"); Group.Color(NodeColor.SgiLightBlue); Group.HasSubNode <Vector3Node>(); Group.HasSubNode <Vector2Node>(); Group.HasSubNode <ConditionNode>(); Group.HasSubNode <AnyFalseNode>(); Group.HasSubNode <AnyTrueNode>(); Group.HasSubNode <BoolExpressionNode>(); Group.HasSubNode <PropertyNode>(); Group.HasSubNode <AllTrueNode>(); Group.HasSubNode <AllFalseNode>(); Group.HasSubNode <FloatNode>(); Group.HasSubNode <StringNode>(); Group.HasSubNode <IntNode>(); Group.HasSubNode <BoolNode>(); Descriptor = container.AddNode <DescriptorNode, DescriptorNodeViewModel, DescriptorNodeDrawer>("Descriptor"); Descriptor.Color(NodeColor.Indianred2); Vector3 = container.AddNode <Vector3Node, Vector3NodeViewModel, Vector3NodeDrawer>("Vector3"); Vector3.Color(NodeColor.Purple); Event = container.AddNode <EventNode, EventNodeViewModel, EventNodeDrawer>("Event"); Event.Inheritable(); Event.Color(NodeColor.Gold3); Literal = container.AddNode <LiteralNode, LiteralNodeViewModel, LiteralNodeDrawer>("Literal"); Literal.Color(NodeColor.Purple); Component = container.AddNode <ComponentNode, ComponentNodeViewModel, ComponentNodeDrawer>("Component"); Component.Inheritable(); Component.Color(NodeColor.Darkolivegreen4); Int = container.AddNode <IntNode, IntNodeViewModel, IntNodeDrawer>("Int"); Int.Color(NodeColor.Purple); CollectionItemAdded = container.AddNode <CollectionItemAddedNode, CollectionItemAddedNodeViewModel, CollectionItemAddedNodeDrawer>("CollectionItemAdded"); CollectionItemAdded.Color(NodeColor.Indianred4); ComponentDestroyed = container.AddNode <ComponentDestroyedNode, ComponentDestroyedNodeViewModel, ComponentDestroyedNodeDrawer>("ComponentDestroyed"); ComponentDestroyed.Color(NodeColor.Indianred4); Vector2 = container.AddNode <Vector2Node, Vector2NodeViewModel, Vector2NodeDrawer>("Vector2"); Vector2.Color(NodeColor.Purple); SequenceContainer = container.AddNode <SequenceContainerNode, SequenceContainerNodeViewModel, SequenceContainerNodeDrawer>("SequenceContainer"); SequenceContainer.Color(NodeColor.Red); AllTrue = container.AddNode <AllTrueNode, AllTrueNodeViewModel, AllTrueNodeDrawer>("AllTrue"); AllTrue.Color(NodeColor.Orange); StartTimer = container.AddNode <StartTimerNode, StartTimerNodeViewModel, StartTimerNodeDrawer>("StartTimer"); StartTimer.Color(NodeColor.Gray); Condition = container.AddNode <ConditionNode, ConditionNodeViewModel, ConditionNodeDrawer>("Condition"); Condition.Color(NodeColor.Orange); Action = container.AddNode <ActionNode, ActionNodeViewModel, ActionNodeDrawer>("Action"); Action.Color(NodeColor.Green); Handler = container.AddGraph <HandlerGraph, HandlerNode>("HandlerGraph"); Handler.Color(NodeColor.Indianred4); Handler.HasSubNode <SetVariableNode>(); Handler.HasSubNode <ActionGroupNode>(); Handler.HasSubNode <ActionNode>(); Handler.HasSubNode <ComponentNode>(); Handler.HasSubNode <ObjectNode>(); Handler.HasSubNode <LoopCollectionNode>(); Handler.HasSubNode <IntNode>(); Handler.HasSubNode <PropertyNode>(); Handler.HasSubNode <EnumValueNode>(); Handler.HasSubNode <Vector2Node>(); Handler.HasSubNode <FloatNode>(); Handler.HasSubNode <NullNode>(); Handler.HasSubNode <BoolNode>(); Handler.HasSubNode <SequenceItemNode>(); Handler.HasSubNode <Vector3Node>(); Handler.HasSubNode <StringNode>(); System = container.AddGraph <SystemGraph, SystemNode>("SystemGraph"); System.Color(NodeColor.Blue); System.HasSubNode <CollectionItemAddedNode>(); System.HasSubNode <ComponentNode>(); System.HasSubNode <PropertyChangedNode>(); System.HasSubNode <ComponentCreatedNode>(); System.HasSubNode <CustomActionNode>(); System.HasSubNode <HandlerNode>(); System.HasSubNode <DescriptorNode>(); System.HasSubNode <EventNode>(); System.HasSubNode <GroupNode>(); System.HasSubNode <ComponentDestroyedNode>(); System.HasSubNode <CollectionItemRemovedNode>(); Entity = container.AddNode <EntityNode, EntityNodeViewModel, EntityNodeDrawer>("Entity"); Entity.Color(NodeColor.Gray); Color = container.AddNode <ColorNode, ColorNodeViewModel, ColorNodeDrawer>("Color"); Color.Color(NodeColor.Purple); EnumValue = container.AddNode <EnumValueNode, EnumValueNodeViewModel, EnumValueNodeDrawer>("EnumValue"); EnumValue.Color(NodeColor.Purple); AnyTrue = container.AddNode <AnyTrueNode, AnyTrueNodeViewModel, AnyTrueNodeDrawer>("AnyTrue"); AnyTrue.Color(NodeColor.Orange); SequenceItem = container.AddNode <SequenceItemNode, SequenceItemNodeViewModel, SequenceItemNodeDrawer>("SequenceItem"); SequenceItem.Color(NodeColor.Green); container.Connectable <BoolExpressionNode, Expressions>(); container.Connectable <BoolExpressionNode, GroupNode>(); container.Connectable <ComponentNode, RequireReference>(); container.Connectable <ActionNode, ActionNode>(); container.Connectable <HandlerNode, SequenceItemNode>(); container.Connectable <SequenceItemNode, SequenceItemNode>(); }
/// <summary> /// Adds a set of object definitions to the schema. The format of the schema /// is a sequence of lines where objects are separated by empty lines. /// Each line of an object definition is a pair of an attribute display name and an /// attribute value, separated by ':'. Takes care of "bootstrapping" the contents of /// the schema, resolving cyclic dependencies between attribute definitions and objects. /// </summary> /// <param name="schema">The schema, represented as explained above.</param> /// <param name="valueSubstitution">A substitution of strings which should be applied to each value in the /// schema. For example, may map '<rootdomaindn>' as used in schemas to represent the root name of the /// current DC to an actual value</param> /// <param name="serverVersion">Specify the OS version of the server</param> /// <returns>Result of the Load Schema method.</returns> public ModelResult LoadSchema(IEnumerable<string> schema, Map<string, string> valueSubstitution, OSVersion serverVersion) { SequenceContainer<ModelObject> newObjects = new SequenceContainer<ModelObject>(); UnresolvedSyntax unresolvedSyntax = new UnresolvedSyntax(); #region Pass 1: read in objects resolving only builtin attributes // We need this phase for bootstrapping, as we don't have the // attributes available which are used in the objects. Thus // in this phase, we just parse attribute values of a certain set // of builting attributes which are required to get attribute syntax // definitions. InitializeBuiltinAttributes(); ModelObject tempobj = null; ModelObject obj = null; foreach (string rawLine in schema) { string line = (rawLine == null)?null:rawLine.Trim(); if (String.IsNullOrEmpty(line)) { // Object ends here if (obj != null) { if (obj[StandardNames.attributeID] == null && obj[StandardNames.governsId] == null) { if (obj.attributes.Count == 1) { // If the server is Windows 2000 if (serverVersion == OSVersion.WinSvr2000) { string attr = obj.attributes.Keys.ElementAt(0); if (tempobj.attributes.Keys.Contains(attr)) { tempobj.attributes.Keys.Remove(attr); tempobj.attributes.Add(obj.attributes.ElementAt(0)); } else { tempobj.attributes.Add(obj.attributes.ElementAt(0)); } newObjects.RemoveAt(newObjects.Count - 1); newObjects.Add(tempobj); } } else { Checks.Fail("attributeId/governsId is mandatory for each object {0}.", obj[StandardNames.cn]); } } else if (obj[StandardNames.attributeID] != null) { AddAttribute(obj); newObjects.Add(obj); } else if (obj[StandardNames.governsId] != null) { // This is a class definition. Fill in class map. AddClass(obj); newObjects.Add(obj); } tempobj = obj; obj = null; } } else { if (obj == null) { obj = new ModelObject(); } obj.dc = this; string attr, valueString; string[] splits = line.Split(new char[] { ':' }, 2); if (splits == null || splits.Length != 2) { Checks.Fail("invalid schema line '{0}'", line); continue; } attr = splits[0].Trim().ToLower(); valueString = Substitute(valueSubstitution, splits[1].Trim()); AttributeContext parsingContext; if (!builtinAttributeSyntax.TryGetValue(attr, out parsingContext)) { parsingContext = new AttributeContext(this, attr, unresolvedSyntax); } obj[attr] = parsingContext.Parse(valueString); } } #endregion #region Pass 2: resolve syntax of all new objects // As we have now attribute definitions which map to the syntax, we can parse // All values in the new objects. foreach (ModelObject newObj in newObjects) { foreach (string attr in newObj.attributes.Keys) { AttributeContext parsingContext = GetAttributeContext(attr); Value value = newObj[attr]; if (value.Syntax is UnresolvedSyntax) { newObj[attr] = parsingContext.Parse((string)value); } else { Checks.IsTrue( parsingContext.syntax == value.Syntax, "bultin syntax assignment of '{0}' must match syntax declared in schema", attr); } } } #endregion #region Pass 3: add objects // Now all definitions are complete. Add them to schema replica root. foreach (ModelObject newObj in newObjects) { AddChild(schemaReplica.root, newObj); } #endregion #region Pass 4: check consistency // The tree is finally setup. Now check for consistency Consistency.Check(newObjects.ToSequence()); #endregion if (Checks.HasDiagnostics) { return new ModelResult(ResultCode.ConstraintViolation, Checks.GetAndClearLog(), Checks.GetAndClearDiagnostics()); } else { //return Result.Success; ModelResult tempRes = new ModelResult(ResultCode.Success); tempRes.logMessage = Checks.GetAndClearLog(); return tempRes; } }