public void RestoreConnectionsShouldConnectSourceToDestAndSinkToSourve()
        {
            var obj = new ExpressionNodeFactory();
            var connection = new Connection();
            connection.Source = new ConnectorOut(connection);
            connection.Sink = new ConnectorIn(connection);

            var destination = new DestinationFieldList { UniqueName = "Destination" };
            destination.Fields.Add(new DestinationField(destination));
            var source = new ConstantExpression();

            destination.Fields[0].ConnectorIn.Id = connection.Source.Id;
            source.ConnectorOut.Id = connection.Sink.Id;

            var objects = new List<IExpressionObjectBase>
                              {   
                                  source,
                                  destination,
                                  connection
                              };

            obj.RestoreConnections(objects);

            Assert.AreSame(destination.Fields[0].ConnectorIn, connection.Sink);
            Assert.AreSame(source.ConnectorOut, connection.Source);
        }
        private SourceFieldNode ToSourceExpressionNode(SourceFieldList expressionObject, Connection connection)
        {
            if (!expressionObject.IsValid)
                throw new IncompleteTreeException(expressionObject);


            var field = expressionObject.GetSourceFieldForConnection(connection.Source);

            var fieldName = field.GetName();

            if (_values.ContainsKey(fieldName))
            {
                var value = _values[fieldName];
                return new SourceFieldNode(field.DataType, fieldName, value, field.SetName, field.InnerName, field.SystemName);
            }

            return new SourceFieldNode(field.DataType, fieldName, null, field.SetName, field.InnerName, field.SystemName);
        }
        public void CreateDestinationNodeShouldReturnDestinationNode()
        {
            var obj = new ExpressionNodeFactory();

            var destination = new DestinationFieldList { UniqueName = "Destination" };
            destination.Fields.Add(new DestinationField(destination));
            var source = new ConstantExpression();
            var connection = new Connection { Source = source.ConnectorOut, Sink = destination.Fields[0].ConnectorIn };

            var objects = new List<IExpressionObjectBase>
                              {   
                                  source,
                                  destination,
                                  connection
                              };

            Assert.IsNotNull(obj.CreateDestinationNode(objects, "Destination"));
        }
        private ExpressionNode ToExpressionNode(ExpressionObjectBase expressionObject, Connection connection)
        {
            if (!expressionObject.IsValid)
                throw new IncompleteTreeException(expressionObject);

            if (expressionObject is SourceFieldList)
                return ToSourceExpressionNode((SourceFieldList)expressionObject, connection);

            switch (expressionObject.Type)
            {
                case ExpressionNodeType.CustomFunction:
                    return ToCustomFunctionNodeNode(expressionObject);
                case ExpressionNodeType.ToUpper:
                    return new ToUpperFunctionNode(ToExpressionNode(((OneInOneOutExpression)expressionObject).ConnectorIn.Connection.Source.Connection.Source.Owner,
                        ((OneInOneOutExpression)expressionObject).ConnectorIn.Connection.Source.Connection));

                case ExpressionNodeType.ToLower:
                    return new ToLowerFunctionNode(ToExpressionNode(((OneInOneOutExpression)expressionObject).ConnectorIn.Connection.Source.Connection.Source.Owner,
                        ((OneInOneOutExpression)expressionObject).ConnectorIn.Connection.Source.Connection));

                case ExpressionNodeType.Trim:
                    return new TrimFunctionNode(ToExpressionNode(((OneInOneOutExpression)expressionObject).ConnectorIn.Connection.Source.Connection.Source.Owner,
                        ((OneInOneOutExpression)expressionObject).ConnectorIn.Connection.Source.Connection));

                case ExpressionNodeType.Concat:
                    return new ConcatFunctionNode(ToExpressionNode(((TwoInOneOutExpression)expressionObject).Connector1In.Connection.Source.Connection.Source.Owner,
                            ((TwoInOneOutExpression)expressionObject).Connector1In.Connection.Source.Connection),
                        ToExpressionNode(((TwoInOneOutExpression)expressionObject).Connector2In.Connection.Source.Connection.Source.Owner,
                            ((TwoInOneOutExpression)expressionObject).Connector2In.Connection.Source.Connection));

                case ExpressionNodeType.Left:
                    return new LeftSubStringFunctionNode(ToExpressionNode(((TwoInOneOutExpression)expressionObject).Connector2In.Connection.Source.Connection.Source.Owner,
                            ((TwoInOneOutExpression)expressionObject).Connector2In.Connection.Source.Connection),
                        ToExpressionNode(((TwoInOneOutExpression)expressionObject).Connector1In.Connection.Source.Connection.Source.Owner,
                            ((TwoInOneOutExpression)expressionObject).Connector1In.Connection.Source.Connection));

                case ExpressionNodeType.Right:
                    return new RightSubStringFunctionNode(ToExpressionNode(((TwoInOneOutExpression)expressionObject).Connector1In.Connection.Source.Connection.Source.Owner,
                            ((TwoInOneOutExpression)expressionObject).Connector1In.Connection.Source.Connection),
                        ToExpressionNode(((TwoInOneOutExpression)expressionObject).Connector2In.Connection.Source.Connection.Source.Owner,
                            ((TwoInOneOutExpression)expressionObject).Connector2In.Connection.Source.Connection));

                case ExpressionNodeType.Add:
                    return new AddFunctionNode(ToExpressionNode(((TwoInOneOutExpression)expressionObject).Connector1In.Connection.Source.Connection.Source.Owner,
                            ((TwoInOneOutExpression)expressionObject).Connector1In.Connection.Source.Connection),
                        ToExpressionNode(((TwoInOneOutExpression)expressionObject).Connector2In.Connection.Source.Connection.Source.Owner,
                            ((TwoInOneOutExpression)expressionObject).Connector2In.Connection.Source.Connection));

                case ExpressionNodeType.Subtract:
                    return new SubtractFunctionNode(ToExpressionNode(((TwoInOneOutExpression)expressionObject).Connector1In.Connection.Source.Connection.Source.Owner,
                            ((TwoInOneOutExpression)expressionObject).Connector1In.Connection.Source.Connection),
                        ToExpressionNode(((TwoInOneOutExpression)expressionObject).Connector2In.Connection.Source.Connection.Source.Owner,
                            ((TwoInOneOutExpression)expressionObject).Connector2In.Connection.Source.Connection));

                case ExpressionNodeType.Divide:
                    return new DivideFunctionNode(ToExpressionNode(((TwoInOneOutExpression)expressionObject).Connector1In.Connection.Source.Connection.Source.Owner,
                            ((TwoInOneOutExpression)expressionObject).Connector1In.Connection.Source.Connection),
                        ToExpressionNode(((TwoInOneOutExpression)expressionObject).Connector2In.Connection.Source.Connection.Source.Owner,
                            ((TwoInOneOutExpression)expressionObject).Connector2In.Connection.Source.Connection));

                case ExpressionNodeType.Multiply:
                    return new MultiplyFunctionNode(ToExpressionNode(((TwoInOneOutExpression)expressionObject).Connector1In.Connection.Source.Connection.Source.Owner,
                            ((TwoInOneOutExpression)expressionObject).Connector1In.Connection.Source.Connection),
                        ToExpressionNode(((TwoInOneOutExpression)expressionObject).Connector2In.Connection.Source.Connection.Source.Owner,
                            ((TwoInOneOutExpression)expressionObject).Connector2In.Connection.Source.Connection));

                case ExpressionNodeType.Constant:
                    return new ConstantNode(((ConstantExpression)expressionObject).ConnectorOut.Connection.Source.Connection.Source.DataType,
                        ((ConstantExpression)expressionObject).Value);

                case ExpressionNodeType.IsLess:
                    return new IsLessFunctionNode(ToExpressionNode(((TwoInOneOutExpression)expressionObject).Connector1In.Connection.Source.Connection.Source.Owner,
                            ((TwoInOneOutExpression)expressionObject).Connector1In.Connection.Source.Connection),
                        ToExpressionNode(((TwoInOneOutExpression)expressionObject).Connector2In.Connection.Source.Connection.Source.Owner,
                            ((TwoInOneOutExpression)expressionObject).Connector2In.Connection.Source.Connection));

                case ExpressionNodeType.IsGreater:
                    return new IsGreaterFunctionNode(ToExpressionNode(((TwoInOneOutExpression)expressionObject).Connector1In.Connection.Source.Connection.Source.Owner,
                            ((TwoInOneOutExpression)expressionObject).Connector1In.Connection.Source.Connection),
                        ToExpressionNode(((TwoInOneOutExpression)expressionObject).Connector2In.Connection.Source.Connection.Source.Owner,
                            ((TwoInOneOutExpression)expressionObject).Connector2In.Connection.Source.Connection));

                case ExpressionNodeType.If:
                    if (((ThreeInOneOutExpression)expressionObject).Connector1In.Connection == null
                        || ((ThreeInOneOutExpression)expressionObject).Connector2In.Connection == null
                        || ((ThreeInOneOutExpression)expressionObject).Connector3In.Connection == null)
                        throw new IncompleteTreeException(expressionObject);

                    return new IfStatementNode(ToExpressionNode(((ThreeInOneOutExpression)expressionObject).Connector1In.Connection.Source.Connection.Source.Owner,
                            ((ThreeInOneOutExpression)expressionObject).Connector1In.Connection.Source.Connection),
                        ToExpressionNode(((ThreeInOneOutExpression)expressionObject).Connector2In.Connection.Source.Connection.Source.Owner,
                            ((ThreeInOneOutExpression)expressionObject).Connector2In.Connection.Source.Connection),
                        ToExpressionNode(((ThreeInOneOutExpression)expressionObject).Connector3In.Connection.Source.Connection.Source.Owner,
                            ((ThreeInOneOutExpression)expressionObject).Connector3In.Connection.Source.Connection));

                case ExpressionNodeType.AddDays:
                    return new AddDaysFunctionNode(ToExpressionNode(((TwoInOneOutExpression)expressionObject).Connector1In.Connection.Source.Connection.Source.Owner,
                            ((TwoInOneOutExpression)expressionObject).Connector1In.Connection.Source.Connection),
                        ToExpressionNode(((TwoInOneOutExpression)expressionObject).Connector2In.Connection.Source.Connection.Source.Owner,
                            ((TwoInOneOutExpression)expressionObject).Connector2In.Connection.Source.Connection));

                case ExpressionNodeType.DateDiffDays:
                    return new DateDiffDaysFunctionNode(ToExpressionNode(((TwoInOneOutExpression)expressionObject).Connector1In.Connection.Source.Connection.Source.Owner,
                            ((TwoInOneOutExpression)expressionObject).Connector1In.Connection.Source.Connection),
                        ToExpressionNode(((TwoInOneOutExpression)expressionObject).Connector2In.Connection.Source.Connection.Source.Owner,
                            ((TwoInOneOutExpression)expressionObject).Connector2In.Connection.Source.Connection));

            }

            return null;
        }
Example #5
0
        private static void SetupExpressionsDiagram(DiagramViewModel vm)
        {
            vm.Palette.Add(new NodeGroup("String Functions",
                                            new INodeViewModel[]
                                                {
                                                    new NodeViewModel<OneInOneOutExpressionNode, ExpressionConnection>(
                                                        new OneInOneOutExpressionNode(vm, new OneInOneOutExpression(ExpressionNodeType.ToUpper)
                                                        {
                                                            ExpressionName = "Uppercase",
                                                            ConnectorIn =  { DataType = NodeDataType.String, Name = "String" },
                                                            ConnectorOut = { DataType = NodeDataType.String, Name = "Result" }
                                                        }),
                                                        vm
                                                    ),
                                                    new NodeViewModel<OneInOneOutExpressionNode, ExpressionConnection>(
                                                        new OneInOneOutExpressionNode(vm, new OneInOneOutExpression(ExpressionNodeType.ToLower)
                                                        {
                                                            ExpressionName = "Lowercase",
                                                            ConnectorIn =  { DataType = NodeDataType.String, Name = "String" },
                                                            ConnectorOut = { DataType = NodeDataType.String, Name = "Result" }
                                                        }),
                                                        vm
                                                    ),
                                                    new NodeViewModel<OneInOneOutExpressionNode, ExpressionConnection>(
                                                        new OneInOneOutExpressionNode(vm, new OneInOneOutExpression(ExpressionNodeType.Trim)
                                                        {
                                                            ExpressionName = "Trim",
                                                            ConnectorIn =  { DataType = NodeDataType.String, Name = "String" },
                                                            ConnectorOut = { DataType = NodeDataType.String, Name = "Result" }
                                                        }),
                                                        vm
                                                    ),
                                                    new NodeViewModel<TwoInOneOutExpressionNode, ExpressionConnection>(
                                                        new TwoInOneOutExpressionNode(vm, new TwoInOneOutExpression(ExpressionNodeType.Concat)
                                                        {
                                                            ExpressionName = "Concat",
                                                            Connector1In = { DataType = NodeDataType.String, Name = "String 1" },
                                                            Connector2In = { DataType = NodeDataType.String, Name = "String 2" },
                                                            ConnectorOut = { DataType = NodeDataType.String, Name = "Result" }
                                                        }),
                                                        vm
                                                    ),
                                                    new NodeViewModel<TwoInOneOutExpressionNode, ExpressionConnection>(
                                                        new TwoInOneOutExpressionNode(vm, new TwoInOneOutExpression(ExpressionNodeType.Left)
                                                        {
                                                            ExpressionName = "Left",
                                                            Connector1In = { DataType = NodeDataType.String, Name = "String 1" },
                                                            Connector2In = { DataType = NodeDataType.String, Name = "String 2" },
                                                            ConnectorOut = { DataType = NodeDataType.String, Name = "Result" } 
                                                        }),
                                                        vm
                                                    ),
                                                    new NodeViewModel<TwoInOneOutExpressionNode, ExpressionConnection>(
                                                        new TwoInOneOutExpressionNode(vm, new TwoInOneOutExpression(ExpressionNodeType.Right)
                                                        {
                                                            ExpressionName = "Right",
                                                            Connector1In = { DataType = NodeDataType.String, Name = "String 1" },
                                                            Connector2In = { DataType = NodeDataType.String, Name = "String 2" },
                                                            ConnectorOut = { DataType = NodeDataType.String, Name = "Result" }
                                                        }),
                                                        vm
                                                    )
                                                }));

            vm.Palette.Add(new NodeGroup("Date Functions",
                                            new INodeViewModel[]
                                                {
                                                    new NodeViewModel<TwoInOneOutExpressionNode, ExpressionConnection>(
                                                        new TwoInOneOutExpressionNode(vm, new TwoInOneOutExpression(ExpressionNodeType.AddDays)
                                                        {
                                                            ExpressionName = "Add Days",
                                                            Connector1In = { DataType = NodeDataType.DateTime, Name = "Date" },
                                                            Connector2In = { DataType = NodeDataType.Int, Name = "Days Count" },
                                                            ConnectorOut = { DataType = NodeDataType.DateTime, Name = "Result" }
                                                        }),
                                                        vm
                                                    ),
                                                    new NodeViewModel<TwoInOneOutExpressionNode, ExpressionConnection>(
                                                        new TwoInOneOutExpressionNode(vm, new TwoInOneOutExpression(ExpressionNodeType.DateDiffDays)
                                                        {
                                                            ExpressionName = "DateDiff Days",
                                                            Connector1In = { DataType = NodeDataType.DateTime, Name = "Date 1" },
                                                            Connector2In = { DataType = NodeDataType.DateTime, Name = "Date 2" },
                                                            ConnectorOut = { DataType = NodeDataType.Int, Name = "Result" }
                                                        }),
                                                        vm
                                                    ),
                                                    new NodeViewModel<TwoInOneOutExpressionNode, ExpressionConnection>(
                                                        new TwoInOneOutExpressionNode(vm, new TwoInOneOutExpression(ExpressionNodeType.DateDiffHours)
                                                        {
                                                            ExpressionName = "DateDiff Hours",
                                                            Connector1In = { DataType = NodeDataType.DateTime, Name = "Date 1" },
                                                            Connector2In = { DataType = NodeDataType.DateTime, Name = "Date 2" },
                                                            ConnectorOut = { DataType = NodeDataType.Double, Name = "Result" }
                                                        }),
                                                        vm
                                                    ),
                                                    new NodeViewModel<FunctionExpressionNode, ExpressionConnection>(
                                                        new FunctionExpressionNode(vm, new FunctionExpression(ExpressionNodeType.CustomFunction)
                                                        {
                                                            ExpressionName = "Current Date",
                                                            FunctionName = "DateTime.Now",
                                                            ConnectorOut = { DataType = NodeDataType.DateTime, Name = "Result" }
                                                        }),
                                                        vm
                                                    ),
                                                    new NodeViewModel<OneInOneOutExpressionNode, ExpressionConnection>(
                                                        new OneInOneOutExpressionNode(vm, new OneInOneOutExpression(ExpressionNodeType.DateYear)
                                                        {
                                                            ExpressionName = "Date Year",
                                                            ConnectorIn =  { DataType = NodeDataType.DateTime, Name = "Date" },
                                                            ConnectorOut = { DataType = NodeDataType.Int, Name = "Year" }
                                                        }),
                                                        vm
                                                    ),
                                                    new NodeViewModel<OneInOneOutExpressionNode, ExpressionConnection>(
                                                        new OneInOneOutExpressionNode(vm, new OneInOneOutExpression(ExpressionNodeType.DateQuarter)
                                                        {
                                                            ExpressionName = "Date Quarter",
                                                            ConnectorIn =  { DataType = NodeDataType.DateTime, Name = "Date" },
                                                            ConnectorOut = { DataType = NodeDataType.Int, Name = "Quarter" }
                                                        }),
                                                        vm
                                                    ),
                                                    new NodeViewModel<OneInOneOutExpressionNode, ExpressionConnection>(
                                                        new OneInOneOutExpressionNode(vm, new OneInOneOutExpression(ExpressionNodeType.DateMonth)
                                                        {
                                                            ExpressionName = "Date Month",
                                                            ConnectorIn =  { DataType = NodeDataType.DateTime, Name = "Date" },
                                                            ConnectorOut = { DataType = NodeDataType.Int, Name = "Month" }
                                                        }),
                                                        vm
                                                    ),
                                                    new NodeViewModel<OneInOneOutExpressionNode, ExpressionConnection>(
                                                        new OneInOneOutExpressionNode(vm, new OneInOneOutExpression(ExpressionNodeType.DateMonthName)
                                                        {
                                                            ExpressionName = "Date Month Name",
                                                            ConnectorIn =  { DataType = NodeDataType.DateTime, Name = "Date" },
                                                            ConnectorOut = { DataType = NodeDataType.String, Name = "Month Name" }
                                                        }),
                                                        vm
                                                    ),
                                                    new NodeViewModel<OneInOneOutExpressionNode, ExpressionConnection>(
                                                        new OneInOneOutExpressionNode(vm, new OneInOneOutExpression(ExpressionNodeType.DateWeek)
                                                        {
                                                            ExpressionName = "Date Week",
                                                            ConnectorIn =  { DataType = NodeDataType.DateTime, Name = "Date" },
                                                            ConnectorOut = { DataType = NodeDataType.Int, Name = "Week" }
                                                        }),
                                                        vm
                                                    ),

                                                }));

            vm.Palette.Add(new NodeGroup("Logical Functions",
                                            new INodeViewModel[]
                                                {
                                                    new NodeViewModel<TwoInOneOutExpressionNode, ExpressionConnection>(
                                                        new TwoInOneOutExpressionNode(vm, new TwoInOneOutExpression(ExpressionNodeType.IsLess)
                                                        {
                                                            ExpressionName = "Less",
                                                            Connector1In = { DataType = NodeDataType.Double, Name = "a" },
                                                            Connector2In = { DataType = NodeDataType.Double, Name = "b" },
                                                            ConnectorOut = { DataType = NodeDataType.Boolean, Name = "Result" }
                                                        }),
                                                        vm
                                                    ),
                                                    new NodeViewModel<TwoInOneOutExpressionNode, ExpressionConnection>(
                                                        new TwoInOneOutExpressionNode(vm, new TwoInOneOutExpression(ExpressionNodeType.IsGreater)
                                                        {
                                                            ExpressionName = "Greater",
                                                            Connector1In = { DataType = NodeDataType.Double, Name = "a" },
                                                            Connector2In = { DataType = NodeDataType.Double, Name = "b" },
                                                            ConnectorOut = { DataType = NodeDataType.Boolean, Name = "Result" }
                                                        }),
                                                        vm
                                                    ),
                                                    new NodeViewModel<TwoInOneOutExpressionNode, ExpressionConnection>(
                                                        new TwoInOneOutExpressionNode(vm, new TwoInOneOutExpression(ExpressionNodeType.AreEqual)
                                                        {
                                                            ExpressionName = "Equals",
                                                            Connector1In = { DataType = NodeDataType.String, Name = "a" },
                                                            Connector2In = { DataType = NodeDataType.String, Name = "b" },
                                                            ConnectorOut = { DataType = NodeDataType.Boolean, Name = "Result" }
                                                        }),
                                                        vm
                                                    ),
                                                    new NodeViewModel<ThreeInOneOutExpressionNode, ExpressionConnection>(
                                                        new ThreeInOneOutExpressionNode(vm, new ThreeInOneOutExpression(ExpressionNodeType.If)
                                                        {
                                                            ExpressionName = "Condition",
                                                            Connector1In = { DataType = NodeDataType.Boolean, Name = "Condition" },
                                                            Connector2In = { DataType = NodeDataType.String, Name = "When True"  },
                                                            Connector3In = { DataType = NodeDataType.String, Name = "When False" },
                                                            ConnectorOut = { DataType = NodeDataType.String, Name = "Result" }
                                                        }),
                                                        vm
                                                    ),
                                                }));

            vm.Palette.Add(new NodeGroup("Aggregate Functions",
                                            new INodeViewModel[]
                                                {
                                                    new NodeViewModel<TwoInOneOutExpressionNode, ExpressionConnection>(
                                                        new TwoInOneOutExpressionNode(vm, new TwoInOneOutExpression(ExpressionNodeType.Add)
                                                        {
                                                            ExpressionName = "Add", 
                                                            Connector1In = { DataType = NodeDataType.Double, Name = "Value1"},
                                                            Connector2In = { DataType = NodeDataType.Double, Name = "Value2"},
                                                            ConnectorOut = { DataType = NodeDataType.Double, Name = "Result"}
                                                        }),
                                                        vm
                                                    ),
                                                    new NodeViewModel<TwoInOneOutExpressionNode, ExpressionConnection>(
                                                        new TwoInOneOutExpressionNode(vm, new TwoInOneOutExpression(ExpressionNodeType.Subtract)
                                                        { 
                                                            ExpressionName = "Subtract",
                                                            Connector1In = { DataType = NodeDataType.Double, Name = "Value1" },
                                                            Connector2In = { DataType = NodeDataType.Double, Name = "Value2" },
                                                            ConnectorOut = { DataType = NodeDataType.Double, Name = "Result" }
                                                        }),
                                                        vm
                                                    ),
                                                    new NodeViewModel<TwoInOneOutExpressionNode, ExpressionConnection>(
                                                        new TwoInOneOutExpressionNode(vm, new TwoInOneOutExpression(ExpressionNodeType.Multiply)
                                                        {
                                                            ExpressionName = "Multiply",
                                                            Connector1In = { DataType = NodeDataType.Double, Name = "Value1" },
                                                            Connector2In = { DataType = NodeDataType.Double, Name = "Value2" },
                                                            ConnectorOut = { DataType = NodeDataType.Double, Name = "Result" }
                                                        }),
                                                        vm
                                                    ),
                                                    new NodeViewModel<TwoInOneOutExpressionNode, ExpressionConnection>(
                                                        new TwoInOneOutExpressionNode(vm, new TwoInOneOutExpression(ExpressionNodeType.Divide)
                                                        {
                                                            ExpressionName = "Divide",
                                                            Connector1In = { DataType = NodeDataType.Double, Name = "Value1" },
                                                            Connector2In = { DataType = NodeDataType.Double, Name = "Value2" },
                                                            ConnectorOut = { DataType = NodeDataType.Double, Name = "Result" }
                                                        }),
                                                        vm
                                                    ),
                                                    new NodeViewModel<TwoInOneOutExpressionNode, ExpressionConnection>(
                                                        new TwoInOneOutExpressionNode(vm, new TwoInOneOutExpression(ExpressionNodeType.CustomFunction)
                                                        {
                                                            ExpressionName = "Custom Multiply",
                                                            FunctionName = "?1 * ?2",
                                                            Connector1In = { DataType = NodeDataType.Double, Name = "Value1" },
                                                            Connector2In = { DataType = NodeDataType.Double, Name = "Value2" },
                                                            ConnectorOut = { DataType = NodeDataType.Double, Name = "Result" }
                                                        }),
                                                        vm
                                                    ),
                                                }));

            vm.Palette.Add(new NodeGroup("SPC Functions",
                                            new INodeViewModel[]
                                                {
                                                    new NodeViewModel<FourInOneOutExpressionNode, ExpressionConnection>(
                                                        new FourInOneOutExpressionNode(vm, new FourInOneOutExpression(ExpressionNodeType.AboveCenterLine)
                                                        {
                                                            ExpressionName = "Above Center Line", 
                                                            Connector1In = { DataType = NodeDataType.SPCChart, Name = "SPC Field"},
                                                            Connector2In = { DataType = NodeDataType.Int, Name = "Sub-group Size"},
                                                            Connector3In = { DataType = NodeDataType.Int, Name = "X Number"},
                                                            Connector4In = { DataType = NodeDataType.ChartType, Name = "Chart Type"},
                                                            ConnectorOut = { DataType = NodeDataType.Boolean, Name = "Result"}
                                                        }),
                                                        vm
                                                    ),
                                                    new NodeViewModel<FourInOneOutExpressionNode, ExpressionConnection>(
                                                        new FourInOneOutExpressionNode(vm, new FourInOneOutExpression(ExpressionNodeType.BelowCenterLine)
                                                        {
                                                            ExpressionName = "Below Center Line", 
                                                            Connector1In = { DataType = NodeDataType.SPCChart, Name = "SPC Field"},
                                                            Connector2In = { DataType = NodeDataType.Int, Name = "Sub-group Size"},
                                                            Connector3In = { DataType = NodeDataType.Int, Name = "X Number"},
                                                            Connector4In = { DataType = NodeDataType.ChartType, Name = "Chart Type"},
                                                            ConnectorOut = { DataType = NodeDataType.Boolean, Name = "Result"}
                                                        }),
                                                        vm
                                                    ),
                                                    new NodeViewModel<FourInOneOutExpressionNode, ExpressionConnection>(
                                                        new FourInOneOutExpressionNode(vm, new FourInOneOutExpression(ExpressionNodeType.GoingDown)
                                                        {
                                                            ExpressionName = "Going Down", 
                                                            Connector1In = { DataType = NodeDataType.SPCChart, Name = "SPC Field"},
                                                            Connector2In = { DataType = NodeDataType.Int, Name = "Sub-group Size"},
                                                            Connector3In = { DataType = NodeDataType.Int, Name = "X Number"},
                                                            Connector4In = { DataType = NodeDataType.ChartType, Name = "Chart Type"},
                                                            ConnectorOut = { DataType = NodeDataType.Boolean, Name = "Result"}
                                                        }),
                                                        vm
                                                    ),
                                                    new NodeViewModel<FourInOneOutExpressionNode, ExpressionConnection>(
                                                        new FourInOneOutExpressionNode(vm, new FourInOneOutExpression(ExpressionNodeType.GoingUp)
                                                        {
                                                            ExpressionName = "Going Up", 
                                                            Connector1In = { DataType = NodeDataType.SPCChart, Name = "SPC Field"},
                                                            Connector2In = { DataType = NodeDataType.Int, Name = "Sub-group Size"},
                                                            Connector3In = { DataType = NodeDataType.Int, Name = "X Number"},
                                                            Connector4In = { DataType = NodeDataType.ChartType, Name = "Chart Type"},
                                                            ConnectorOut = { DataType = NodeDataType.Boolean, Name = "Result"}
                                                        }),
                                                        vm
                                                    ),
                                                    new NodeViewModel<FourInOneOutExpressionNode, ExpressionConnection>(
                                                        new FourInOneOutExpressionNode(vm, new FourInOneOutExpression(ExpressionNodeType.AlternatingUpAndDown)
                                                        {
                                                            ExpressionName = "Alternating Up and Down", 
                                                            Connector1In = { DataType = NodeDataType.SPCChart, Name = "SPC Field"},
                                                            Connector2In = { DataType = NodeDataType.Int, Name = "Sub-group Size"},
                                                            Connector3In = { DataType = NodeDataType.Int, Name = "X Number"},
                                                            Connector4In = { DataType = NodeDataType.ChartType, Name = "Chart Type"},
                                                            ConnectorOut = { DataType = NodeDataType.Boolean, Name = "Result"}
                                                        }),
                                                        vm
                                                    ),
                                                    new NodeViewModel<SixInOneOutExpressionNode, ExpressionConnection>(
                                                        new SixInOneOutExpressionNode(vm, new SixInOneOutExpression(ExpressionNodeType.LessThanLowerLimits)
                                                        {
                                                            ExpressionName = "Less Than LCL/LSL", 
                                                            Connector1In = { DataType = NodeDataType.SPCChart, Name = "SPC Field"},
                                                            Connector2In = { DataType = NodeDataType.Int, Name = "Sub-group Size"},
                                                            Connector3In = { DataType = NodeDataType.Double, Name = "LCL/LSL"},
                                                            Connector4In = { DataType = NodeDataType.Int, Name = "X Number"},
                                                            Connector5In = { DataType = NodeDataType.Int, Name = "Y Number"},
                                                            Connector6In = { DataType = NodeDataType.ChartType, Name = "Chart Type"},
                                                            ConnectorOut = { DataType = NodeDataType.Boolean, Name = "Result"}
                                                        }),
                                                        vm
                                                    ),
                                                    new NodeViewModel<SixInOneOutExpressionNode, ExpressionConnection>(
                                                        new SixInOneOutExpressionNode(vm, new SixInOneOutExpression(ExpressionNodeType.GreaterThanUpperLimits)
                                                        {
                                                            ExpressionName = "Greater Than UCL/USL", 
                                                            Connector1In = { DataType = NodeDataType.SPCChart, Name = "SPC Field"},
                                                            Connector2In = { DataType = NodeDataType.Int, Name = "Sub-group Size"},
                                                            Connector3In = { DataType = NodeDataType.Double, Name = "UCL/USL"},
                                                            Connector4In = { DataType = NodeDataType.Int, Name = "X Number"},
                                                            Connector5In = { DataType = NodeDataType.Int, Name = "Y Number"},
                                                            Connector6In = { DataType = NodeDataType.ChartType, Name = "Chart Type"},
                                                            ConnectorOut = { DataType = NodeDataType.Boolean, Name = "Result"}
                                                        }),
                                                        vm
                                                    ),
                                                    new NodeViewModel<FourInOneOutExpressionNode, ExpressionConnection>(
                                                        new FourInOneOutExpressionNode(vm, new FourInOneOutExpression(ExpressionNodeType.Same)
                                                        {
                                                            ExpressionName = "Same", 
                                                            Connector1In = { DataType = NodeDataType.SPCChart, Name = "SPC Field"},
                                                            Connector2In = { DataType = NodeDataType.Int, Name = "Sub-group Size"},
                                                            Connector3In = { DataType = NodeDataType.Int, Name = "X Number"},
                                                            Connector4In = { DataType = NodeDataType.ChartType, Name = "Chart Type"},
                                                            ConnectorOut = { DataType = NodeDataType.Boolean, Name = "Result"}
                                                        }),
                                                        vm
                                                    ),
                                                    new NodeViewModel<SixInOneOutExpressionNode, ExpressionConnection>(
                                                        new SixInOneOutExpressionNode(vm, new SixInOneOutExpression(ExpressionNodeType.Between)
                                                        {
                                                            ExpressionName = "Between", 
                                                            Connector1In = { DataType = NodeDataType.SPCChart, Name = "SPC Field"},
                                                            Connector2In = { DataType = NodeDataType.Int, Name = "Sub-group Size"},
                                                            Connector3In = { DataType = NodeDataType.Int, Name = "X Number"},
                                                            Connector4In = { DataType = NodeDataType.Double, Name = "Low Value"},
                                                            Connector5In = { DataType = NodeDataType.Double, Name = "High Value"},
                                                            Connector6In = { DataType = NodeDataType.ChartType, Name = "Chart Type"},
                                                            ConnectorOut = { DataType = NodeDataType.Boolean, Name = "Result"}
                                                        }),
                                                        vm
                                                    ),
                                                    new NodeViewModel<FiveInOneOutExpressionNode, ExpressionConnection>(
                                                        new FiveInOneOutExpressionNode(vm, new FiveInOneOutExpression(ExpressionNodeType.ZoneAorBeyond)
                                                        {
                                                            ExpressionName = "Zone A or beyond", 
                                                            Connector1In = { DataType = NodeDataType.SPCChart, Name = "SPC Field"},
                                                            Connector2In = { DataType = NodeDataType.Int, Name = "Sub-group Size"},
                                                            Connector3In = { DataType = NodeDataType.Int, Name = "X Number"},
                                                            Connector4In = { DataType = NodeDataType.Int, Name = "Y Number"},
                                                            Connector5In = { DataType = NodeDataType.ChartType, Name = "Chart Type"},
                                                            ConnectorOut = { DataType = NodeDataType.Boolean, Name = "Result"}
                                                        }),
                                                        vm
                                                    ),
                                                    new NodeViewModel<FiveInOneOutExpressionNode, ExpressionConnection>(
                                                        new FiveInOneOutExpressionNode(vm, new FiveInOneOutExpression(ExpressionNodeType.ZoneBorBeyond)
                                                        {
                                                            ExpressionName = "Zone B or beyond", 
                                                            Connector1In = { DataType = NodeDataType.SPCChart, Name = "SPC Field"},
                                                            Connector2In = { DataType = NodeDataType.Int, Name = "Sub-group Size"},
                                                            Connector3In = { DataType = NodeDataType.Int, Name = "X Number"},
                                                            Connector4In = { DataType = NodeDataType.Int, Name = "Y Number"},
                                                            Connector5In = { DataType = NodeDataType.ChartType, Name = "Chart Type"},
                                                            ConnectorOut = { DataType = NodeDataType.Boolean, Name = "Result"}
                                                        }),
                                                        vm
                                                    ),
                                                    new NodeViewModel<FiveInOneOutExpressionNode, ExpressionConnection>(
                                                        new FiveInOneOutExpressionNode(vm, new FiveInOneOutExpression(ExpressionNodeType.ZoneCorBeyond)
                                                        {
                                                            ExpressionName = "Zone C or beyond", 
                                                            Connector1In = { DataType = NodeDataType.SPCChart, Name = "SPC Field"},
                                                            Connector2In = { DataType = NodeDataType.Int, Name = "Sub-group Size"},
                                                            Connector3In = { DataType = NodeDataType.Int, Name = "X Number"},
                                                            Connector4In = { DataType = NodeDataType.Int, Name = "Y Number"},
                                                            Connector5In = { DataType = NodeDataType.ChartType, Name = "Chart Type"},
                                                            ConnectorOut = { DataType = NodeDataType.Boolean, Name = "Result"}
                                                        }),
                                                        vm
                                                    ),
                                                    new NodeViewModel<FourInOneOutExpressionNode, ExpressionConnection>(
                                                        new FourInOneOutExpressionNode(vm, new FourInOneOutExpression(ExpressionNodeType.FailedNumber)
                                                        {
                                                            ExpressionName = "Failed Number (attribute)", 
                                                            Connector1In = { DataType = NodeDataType.SPCChart, Name = "SPC Field"},
                                                            Connector2In = { DataType = NodeDataType.Int, Name = "Number of samples"},
                                                            Connector3In = { DataType = NodeDataType.Int, Name = "X Number"},
                                                            Connector4In = { DataType = NodeDataType.ChartType, Name = "Chart Type"},
                                                            ConnectorOut = { DataType = NodeDataType.Boolean, Name = "Result"}
                                                        }),
                                                        vm
                                                    ),
                                                    new NodeViewModel<FourInOneOutExpressionNode, ExpressionConnection>(
                                                        new FourInOneOutExpressionNode(vm, new FourInOneOutExpression(ExpressionNodeType.FailedPercent)
                                                        {
                                                            ExpressionName = "Failed Percent (attribute)", 
                                                            Connector1In = { DataType = NodeDataType.SPCChart, Name = "SPC Field"},
                                                            Connector2In = { DataType = NodeDataType.Int, Name = "Number of samples"},
                                                            Connector3In = { DataType = NodeDataType.Double, Name = "X Number"},
                                                            Connector4In = { DataType = NodeDataType.ChartType, Name = "Chart Type"},
                                                            ConnectorOut = { DataType = NodeDataType.Boolean, Name = "Result"}
                                                        }),
                                                        vm
                                                    ),
                                                }));

            vm.Palette.Add(new NodeGroup("Constants",
                                            new INodeViewModel[]
                                                {
                                                    new NodeViewModel<ConstantExpressionNode, ExpressionConnection>(
                                                        new ConstantExpressionNode(vm, new ConstantExpression()
                                                        {
                                                            ExpressionName = "Constant",
                                                            ConnectorOut = { DataType = NodeDataType.String, Name = "Result" }
                                                        }),
                                                        vm
                                                    )
                                                }));


            var uis = new SourceFieldList {ExpressionName = "Current User Information", Left = 10, Top = 400};
            uis.Fields.Add(new SourceField(null) { DataType = NodeDataType.String, Name = "User Name", SetName = SourceFieldSetNames.CurrentUserInfo, SystemName = "Utils.CurrentUserName", ConnectorOut = { DataType = NodeDataType.String, Name = "User Name" } });
            uis.Fields.Add(new SourceField(null) { DataType = NodeDataType.String, Name = "Full Name", SetName = SourceFieldSetNames.CurrentUserInfo, SystemName = "Utils.CurrentUserFullName", ConnectorOut = { DataType = NodeDataType.String, Name = "Full Name" } });
            uis.Fields.Add(new SourceField(null) { DataType = NodeDataType.Int, Name = "Person ID", SetName = SourceFieldSetNames.CurrentUserInfo, SystemName = "Utils.CurrentUserPersonId", ConnectorOut = { DataType = NodeDataType.String, Name = "Person ID" } });
            uis.Fields.Add(new SourceField(null) { DataType = NodeDataType.String, Name = "Email Address", SetName = SourceFieldSetNames.CurrentUserInfo, SystemName = "Utils.CurrentUserEmailAddress", ConnectorOut = { DataType = NodeDataType.String, Name = "Email Address" } });
            uis.Fields.Add(new SourceField(null) { DataType = NodeDataType.String, Name = "Last Name", SetName = SourceFieldSetNames.CurrentUserInfo, SystemName = "Utils.CurrentUserLastName", ConnectorOut = { DataType = NodeDataType.String, Name = "Last Name" } });
            uis.Fields.Add(new SourceField(null) { DataType = NodeDataType.String, Name = "Business Unit", SetName = SourceFieldSetNames.CurrentUserInfo, SystemName = "Utils.CurrentUserBusinessUnitId", ConnectorOut = { DataType = NodeDataType.String, Name = "Business Unit" } });

            // source
            //var fieldList = new Dictionary<string, object>();
            //fieldList["Name"] = "Name";
            //fieldList["Title"] = "Title";
            //fieldList["PublishDate"] = DateTime.Now;
            //fieldList["Author"] = "Author";

            var sourceNodeList = new SourceFieldList();

            //Func<IExpressionField, ICollection<IExpressionField>> sfRetriever = f => GetCRFields(f, sourceNodeList);
            
            sourceNodeList.ExpressionName = "Album";
            sourceNodeList.Top = 10;
            sourceNodeList.Left = 10;
            sourceNodeList.Fields.Add(new SourceField(sourceNodeList) { DataType = NodeDataType.String, Name = "Name", SetName = SourceFieldSetNames.Item, SystemName = "Name", ConnectorOut = { DataType = NodeDataType.String, Name = "Name" } });
            sourceNodeList.Fields.Add(new SourceField(sourceNodeList) { DataType = NodeDataType.String, Name = "Title", SetName = SourceFieldSetNames.Item, SystemName = "Title", ConnectorOut = { DataType = NodeDataType.String, Name = "Title" } });
            sourceNodeList.Fields.Add(new SourceField(sourceNodeList) { DataType = NodeDataType.String, Name = "PublishDate", SetName = SourceFieldSetNames.Item, SystemName = "PublishDate", ConnectorOut = { DataType = NodeDataType.String, Name = "PublishDate" } });
            sourceNodeList.Fields.Add(new SourceField(sourceNodeList)
                                          {
                                              DataType = NodeDataType.String, 
                                              Name = "Author", 
                                              SetName = SourceFieldSetNames.Item, 
                                              SystemName = "Author", 
                                              ConnectorOut = { DataType = NodeDataType.String, Name = "Author" },
                                              SubfieldsRetriever = new CRSubfieldsRetriever()
                                          });



            //var sourceNodes = SourceNodeFactory.ConvertToSource("Album", fieldList, SourceFieldSetNames.Item);
            //sourceNodes.Top = 10;
            //sourceNodes.Left = 10;
            //sourceNodes.Width = 200;

            // destination
            var destinationNodes = DestinationNodeFactory.ConvertToSource(typeof(ExpressionResult));
            destinationNodes.Top = 200;
            destinationNodes.Left = 600 ;

            var expressions = new List<IExpressionObjectBase>();
            expressions.Add(sourceNodeList);
            //expressions.Add(uis);
            expressions.Add(destinationNodes);

            // connection
            var connection = new Connection
                                 {
                                     Id = Guid.NewGuid(),
                                     Source = new ConnectorOut(null) { Id = sourceNodeList.ConnectorsOut[0].Id },
                                     Sink = new ConnectorIn(null) { Id = destinationNodes.ConnectorsIn[0].Id }
                                 };
            //expressions.Add(connection);

            // constant
            var constantExpr = new ConstantExpression { ExpressionName = "Constant", Top = 10, Left = 250, Value = 10,
                                                        ConnectorOut = { DataType = NodeDataType.String, Name = "Result" }
            };
            //expressions.Add(constantExpr);

            // oneinoneout
            var oneinoneoutExpr = new OneInOneOutExpression(ExpressionNodeType.ToUpper)
                                      { ExpressionName = "Uppercase", Top = 60, Left = 250, 
                                        ConnectorIn = {DataType = NodeDataType.String, Name = "String"},
                                        ConnectorOut = { DataType = NodeDataType.String, Name = "Result" }
                                      };
            //expressions.Add(oneinoneoutExpr);

            // twoinoneout
            var twoinoneoutExpr = new TwoInOneOutExpression(ExpressionNodeType.Concat)
            {
                ExpressionName = "Concat",
                Top = 110,
                Left = 250,
                Connector1In = { DataType = NodeDataType.String, Name = "String" },
                Connector2In = { DataType = NodeDataType.String, Name = "String" },
                ConnectorOut = { DataType = NodeDataType.String, Name = "Result" }
            };
            //expressions.Add(twoinoneoutExpr);

            // threeinoneout
            var threeinoneoutExpr = new ThreeInOneOutExpression(ExpressionNodeType.If)
            {
                ExpressionName = "Condition",
                Top = 180,
                Left = 250,
                Connector1In = { DataType = NodeDataType.Boolean, Name = "Condition" },
                Connector2In = { DataType = NodeDataType.String, Name = "If True" },
                Connector3In = { DataType = NodeDataType.String, Name = "If False" },
                ConnectorOut = { DataType = NodeDataType.String, Name = "Result" }
            };
            expressions.Add(threeinoneoutExpr);

            // function
            var functionExpr = new FunctionExpression(ExpressionNodeType.CustomFunction) { ExpressionName = "Current Date", Top = 280, Left = 250, Width = 100, Height = 45, FunctionName = "DateTime.Now",
                                ConnectorOut = {DataType = NodeDataType.DateTime, Name="Result"}};
            //expressions.Add(functionExpr);

            ExpressionTranslator.TranslateToDiagram(expressions, vm);
        }
        private void ToExpressionNodeThreeInOneOutFunctionTest(ExpressionNodeType nodeType, Type functionNode)
        {
            var obj = new ExpressionNodeFactory();
            var connection1 = new Connection();
            connection1.Source = new ConnectorOut(connection1);
            connection1.Sink = new ConnectorIn(connection1);

            var connection2 = new Connection();
            connection2.Source = new ConnectorOut(connection2);
            connection2.Sink = new ConnectorIn(connection2);

            var connection3 = new Connection();
            connection3.Source = new ConnectorOut(connection3);
            connection3.Sink = new ConnectorIn(connection3);

            var connection4 = new Connection();
            connection4.Source = new ConnectorOut(connection4);
            connection4.Sink = new ConnectorIn(connection4);

            var destination = new DestinationFieldList { UniqueName = "Destination" };
            destination.Fields.Add(new DestinationField(destination));
            var source = new SourceFieldList();
            source.Fields.Add(new SourceField(source) { Name = "Field" });
            source.Fields.Add(new SourceField(source) { Name = "Field" });
            source.Fields.Add(new SourceField(source) { Name = "Field" });

            var func = new ThreeInOneOutExpression(nodeType) { UniqueName = "Function" };

            func.Connector1In.Id = connection1.Sink.Id;
            source.Fields[0].ConnectorOut.Id = connection1.Source.Id;
            func.Connector2In.Id = connection2.Sink.Id;
            source.Fields[1].ConnectorOut.Id = connection2.Source.Id;
            func.Connector3In.Id = connection3.Sink.Id;
            source.Fields[2].ConnectorOut.Id = connection3.Source.Id;

            destination.Fields[0].ConnectorIn.Id = connection4.Sink.Id;
            func.ConnectorOut.Id = connection4.Source.Id;

            var objects = new List<IExpressionObjectBase>
                              {   
                                  source,
                                  destination,
                                  func,
                                  connection1,
                                  connection2,
                                  connection3,
                                  connection4
                              };

            var destNode = obj.CreateExpressionNodes(objects);
            Assert.AreEqual(functionNode, destNode.ResultNodes.FirstOrDefault().Expression.GetType());
        }
        public void ToExpressionNode_SetChecklistData_Test()
        {
            // Arrange.
            var nodeFactory = new ExpressionNodeFactory();
            var connection1 = new Connection();
            connection1.Source = new ConnectorOut(connection1);
            connection1.Sink = new ConnectorIn(connection1);

            var connection2 = new Connection();
            connection2.Source = new ConnectorOut(connection2);
            connection2.Sink = new ConnectorIn(connection2);

            var connection3 = new Connection();
            connection3.Source = new ConnectorOut(connection3);
            connection3.Sink = new ConnectorIn(connection3);

            var destination = new DestinationFieldList { UniqueName = "Destination" };
            destination.Fields.Add(new DestinationField(destination));
            destination.Fields.Add(new DestinationField(destination));
            var source = new SourceFieldList();
            source.Fields.Add(new SourceField(source) { Name = "Field" });

            var func = new SetChecklistDataExpression { UniqueName = "Function" };

            func.ConnectorIn.Id = connection1.Sink.Id;
            source.Fields[0].ConnectorOut.Id = connection1.Source.Id;

            destination.Fields[0].ConnectorIn.Id = connection2.Sink.Id;
            func.Connector1Out.Id = connection2.Source.Id;

            destination.Fields[1].ConnectorIn.Id = connection3.Sink.Id;
            func.Connector2Out.Id = connection3.Source.Id;

            var objects = new List<IExpressionObjectBase> { source, destination, func, connection1, connection2, connection3 };

            // Act.
            var destNode = nodeFactory.CreateExpressionNodes(objects);

            // Assert.
            Assert.IsTrue(destNode.ResultNodes.ElementAt(0).Expression is SetChecklistDataFunctionNode);
            Assert.IsTrue(destNode.ResultNodes.ElementAt(1).Expression is GetContextValueFunctionNode);
        }
        public void CheckMultipleDestinationsInAddDestinationNode()
        {
            var obj = new ExpressionNodeFactory();
            var connection1 = new Connection();
            connection1.Source = new ConnectorOut(connection1);
            connection1.Sink = new ConnectorIn(connection1);

            var connection2 = new Connection();
            connection2.Source = new ConnectorOut(connection2);
            connection2.Sink = new ConnectorIn(connection2);

            var destination = new DestinationFieldList { UniqueName = "Destination" };
            destination.Fields.Add(new DestinationField(destination) { SystemName = "Field" });
            destination.Fields[0].Subfields.Add(new DestinationField(destination) { SystemName = "Subfield", ParentField = destination.Fields[0] });

            var source = new SourceFieldList();
            source.Fields.Add(new SourceField(source) { Name = "Field" });

            var func = new OneInOneOutExpression(ExpressionNodeType.Count) { UniqueName = "Function" };

            func.ConnectorIn.Id = connection1.Sink.Id;
            source.Fields[0].ConnectorOut.Id = connection1.Source.Id;

            ((DestinationField)destination.Fields[0].Subfields[0]).ConnectorIn.Id = connection2.Sink.Id;
            func.ConnectorOut.Id = connection2.Source.Id;

            var objects = new List<IExpressionObjectBase>
                              {   
                                  source,
                                  destination,
                                  func,
                                  connection1,
                                  connection2
                              };

            var destNode = obj.CreateExpressionNodes(objects);

            Assert.AreEqual("Field.Subfield", destNode.ResultNodes.ToArray()[0].FieldName);
        }
        public void ToExpressionNode_Constant_Test()
        {
            var obj = new ExpressionNodeFactory();

            var connection2 = new Connection();
            connection2.Source = new ConnectorOut(connection2);
            connection2.Sink = new ConnectorIn(connection2);

            var destination = new DestinationFieldList { UniqueName = "Destination" };
            destination.Fields.Add(new DestinationField(destination));
            var func = new ConstantExpression();
            destination.Fields[0].ConnectorIn.Id = connection2.Sink.Id;
            func.ConnectorOut.Id = connection2.Source.Id;

            var objects = new List<IExpressionObjectBase>
                              {   
                                  destination,
                                  func,
                                  connection2
                              };

            var destNode = obj.CreateExpressionNodes(objects);
            Assert.AreEqual(typeof(ConstantNode), destNode.ResultNodes.FirstOrDefault().Expression.GetType());
        }
        public void CustomFunctionNodeTest()
        {
            var obj = new ExpressionNodeFactory();
            var connection = new Connection();
            connection.Source = new ConnectorOut(connection);
            connection.Sink = new ConnectorIn(connection);

            var destination = new DestinationFieldList { UniqueName = "Destination" };
            destination.Fields.Add(new DestinationField(destination));
            var source = new FunctionExpression { FunctionName = "Function" };

            destination.Fields[0].ConnectorIn.Id = connection.Sink.Id;
            source.ConnectorOut.Id = connection.Source.Id;

            var objects = new List<IExpressionObjectBase>
                              {   
                                  source,
                                  destination,
                                  connection
                              };

            var destNode = obj.CreateExpressionNodes(objects);
            var sourceNode = destNode.ResultNodes.FirstOrDefault().Expression as CustomFunctionNode;

            Assert.AreEqual("Function", sourceNode.FunctionName);
        }
        public void ToSourceExpressionNodeShouldReturnFieldWithValue()
        {
            var obj = new ExpressionNodeFactory();
            var connection = new Connection();
            connection.Source = new ConnectorOut(connection);
            connection.Sink = new ConnectorIn(connection);

            var destination = new DestinationFieldList { UniqueName = "Destination" };
            destination.Fields.Add(new DestinationField(destination));
            var source = new SourceFieldList();
            source.Fields.Add(new SourceField(source) { Name = "Field" });

            destination.Fields[0].ConnectorIn.Id = connection.Sink.Id;
            source.Fields[0].ConnectorOut.Id = connection.Source.Id;

            var objects = new List<IExpressionObjectBase>
                              {   
                                  source,
                                  destination,
                                  connection
                              };

            var destNode = obj.CreateExpressionNodes(objects, new Dictionary<string, object> { { "Field", "Value" } });
            var sourceNode = destNode.ResultNodes.FirstOrDefault().Expression as SourceFieldNode;

            Assert.AreEqual("Field", sourceNode.FieldName);
            Assert.AreEqual("Value", sourceNode.Value);
        }
        public void ToSourceExpressionNodeShouldThrowExceptionIdSourceFieldListIsInvalid()
        {
            var obj = new ExpressionNodeFactory();
            var connection = new Connection();
            connection.Source = new ConnectorOut(connection);
            connection.Sink = new ConnectorIn(connection);

            var destination = new DestinationFieldList { UniqueName = "Destination" };
            destination.Fields.Add(new DestinationField(destination));
            var source = new SourceFieldList();
            source.Fields.Add(new SourceField(source) { Name = "Field" });

            destination.Fields[0].ConnectorIn.Id = connection.Sink.Id;
            source.Fields[0].ConnectorOut.Id = connection.Source.Id;

            Mock.Arrange(() => source.IsValid).Returns(true).InSequence().Returns(true).InSequence().Returns(false).InSequence();

            var objects = new List<IExpressionObjectBase>
                              {   
                                  source,
                                  destination,
                                  connection
                              };

            obj.CreateExpressionNodes(objects);
        }
Example #13
0
        /// <summary>
        /// Translates to expression objects.
        /// </summary>
        /// <param name="expressionObjects">The expression objects.</param>
        /// <param name="diagramViewModel">The diagram view model.</param>
        /// <exception cref="System.ArgumentNullException">
        /// diagramViewModel
        /// or
        /// expressionObjects
        /// </exception>
        public static void TranslateToExpressionObjects(IList<IExpressionObjectBase> expressionObjects, IDiagramViewModel diagramViewModel)
        {
            if (diagramViewModel == null) throw new ArgumentNullException("diagramViewModel");
            if (expressionObjects == null) throw new ArgumentNullException("expressionObjects");

            foreach (var diagramItem in diagramViewModel.Items)
            {
                if (diagramItem is INodeViewModel)
                {
                    var exprObj = diagramItem.Item as ExpressionNodeBase;
                    if (exprObj != null)
                    {
                        var obj = exprObj.ExpressionObject;
                        expressionObjects.Add(obj);
                    }
                }

                var connectionViewModel = diagramItem as IConnectionViewModel;
                if (connectionViewModel != null)
                {
                    var obj = new Connection();
                    obj.Source = new ConnectorOut(obj) { Id = connectionViewModel.Source.Item.Id };
                    obj.Sink = new ConnectorIn(obj) { Id = connectionViewModel.Destination.Item.Id };

                    expressionObjects.Add(obj);
                }
            }
        }
Example #14
0
        /// <summary>
        /// Adds the connection.
        /// </summary>
        /// <param name="connection">The connection.</param>
        /// <param name="diagramViewModel">The diagram view model.</param>
        private static void AddConnection(Connection connection, IDiagramViewModel diagramViewModel)
        {
            var source = (from i in diagramViewModel.Items
                         from c in i.GetConnectors()
                         where c.Item.Id == connection.Source.Id
                         select c).FirstOrDefault();

            if (source != null)
            {
                var destination = (from i in diagramViewModel.Items
                              from c in i.GetConnectors()
                              where c.Item.Id == connection.Sink.Id
                              select c).FirstOrDefault();

                if (destination != null)
                {
                    var cn = new ExpressionConnection {SourceItem = source.Item, DestinationItem = destination.Item};
                    diagramViewModel.Items.Add(new ConnectionViewModel<ExpressionConnection>(cn, source, destination, diagramViewModel));
                }
            }
        }