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;
}
}