DYN-10235: Allow copy/paste of pinned wire connections (DynamoDS#16944)

Author: ivaylo-matov

src/DynamoCore/Models/DynamoModel.cs

@@ -3186,6 +3186,15 @@ var el in
 
                 ClipBoard.AddRange(connectors);
             }
+
+            var connectorPins = ClipBoard
+                    .OfType<ConnectorModel>()
+                    .SelectMany(connector => connector.ConnectorPinModels)
+                    .Where(pin => !ClipBoard.Contains(pin))
+                    .Cast<ModelBase>()
+                    .ToList();
+
+            ClipBoard.AddRange(connectorPins);
         }
 
         /// <summary>
@@ -3235,6 +3244,7 @@ public void Paste(Point2D targetPoint, bool useOffset = true)
 
             var nodes = ClipBoard.OfType<NodeModel>();
             var connectors = ClipBoard.OfType<ConnectorModel>();
+            var connectorPins = ClipBoard.OfType<ConnectorPinModel>();
             var notes = ClipBoard.OfType<NoteModel>();
             // we only want to get groups that either has nested groups
             // or does not belong to a group here.
@@ -3329,27 +3339,59 @@ public void Paste(Point2D targetPoint, bool useOffset = true)
 
                 ModelBase start;
                 ModelBase end;
-                var newConnectors =
-                    from c in connectors
 
-                        // If the guid is in nodeLookup, then we connect to the new pasted node. Otherwise we
-                        // re-connect to the original.
-                    let startNode =
+                var newConnectors = new List<ConnectorModel>();
+                var connectorLookup = new Dictionary<Guid, ConnectorModel>();
+                foreach (var c in connectors)
+                {
+                    // If the guid is in nodeLookup, then we connect to the new pasted node. Otherwise we
+                    // re-connect to the original.
+                    var startNode =
                             modelLookup.TryGetValue(c.Start.Owner.GUID, out start)
                                 ? start as NodeModel
-                                : CurrentWorkspace.Nodes.FirstOrDefault(x => x.GUID == c.Start.Owner.GUID)
-                    let endNode =
+                                : CurrentWorkspace.Nodes.FirstOrDefault(x => x.GUID == c.Start.Owner.GUID);
+                    var endNode =
                         modelLookup.TryGetValue(c.End.Owner.GUID, out end)
                             ? end as NodeModel
-                            : CurrentWorkspace.Nodes.FirstOrDefault(x => x.GUID == c.End.Owner.GUID)
+                            : CurrentWorkspace.Nodes.FirstOrDefault(x => x.GUID == c.End.Owner.GUID);
 
                     // Don't make a connector if either end is null.
-                    where startNode != null && endNode != null
-                    select
-                        ConnectorModel.Make(startNode, endNode, c.Start.Index, c.End.Index);
+                    if (startNode == null || endNode == null)
+                    {
+                        continue;
+                    }
+                    var newConnector = ConnectorModel.Make(startNode, endNode, c.Start.Index, c.End.Index);
+                    if (newConnector != null)
+                    {
+                        newConnectors.Add(newConnector);
+                        connectorLookup.Add(c.GUID, newConnector);
+                    }
+                }
 
                 createdModels.AddRange(newConnectors);
 
+                var newConnectorPins = new List<ConnectorPinModel>();
+                foreach (var pin in connectorPins)
+                {
+                    if (!connectorLookup.TryGetValue(pin.ConnectorId, out var connector))
+                    {
+                        continue;
+                    }
+
+                    var copiedPin = new ConnectorPinModel
+                        (
+                        pin.Position.X + shiftX + offset,
+                        pin.Position.Y + shiftY + offset,
+                        Guid.NewGuid(),
+                        connector.GUID
+                        );
+
+                    connector.AddPin(copiedPin);
+                    newConnectorPins.Add(copiedPin);
+                }
+
+                createdModels.AddRange(newConnectorPins);
+
                 //Grouping depends on the selected node models.
                 //so adding the group after nodes / notes are added to workspace.
                 //select only those nodes that are part of a group.
@@ -3399,6 +3441,12 @@ from c in connectors
                     AddToSelection(item);
                 }
 
+                // Keep connector pins selected together with the pasted graph chunk
+                foreach (var connectorPin in newConnectorPins)
+                {
+                    AddToSelection(connectorPin);
+                }
+
                 DynamoSelection.Instance.ClearSelectionDisabled = false;
 
                 // Record models that are created as part of the command.

test/DynamoCoreTests/CoreTests.cs

@@ -575,6 +575,58 @@ public void CanCopyAndPaste2NodesWithRightOffset()
             Assert.AreEqual(27, CurrentDynamoModel.CurrentWorkspace.Nodes.ElementAt(3).Y);
         }
 
+        [Test]
+        [Category("UnitTests")]
+        public void CanCopyAndPasteConnectorPinsWithConnectors()
+        {
+            var numberNode = new DoubleInput();
+            numberNode.Height = 2;
+            numberNode.Width = 2;
+            numberNode.CenterX = 100;
+            numberNode.CenterY = 100;
+
+            var watchNode = new Watch();
+            watchNode.Height = 2;
+            watchNode.Width = 2;
+            watchNode.CenterX = 350;
+            watchNode.CenterY = 100;
+
+            CurrentDynamoModel.CurrentWorkspace.AddAndRegisterNode(numberNode, false);
+            CurrentDynamoModel.CurrentWorkspace.AddAndRegisterNode(watchNode, false);
+
+            var connector = ConnectorModel.Make(numberNode, watchNode, 0, 0);
+            Assert.IsNotNull(connector);
+
+            var originalPin = new ConnectorPinModel(225, 100, Guid.NewGuid(), connector.GUID);
+            connector.ConnectorPinModels.Add(originalPin);
+
+            CurrentDynamoModel.AddToSelection(numberNode);
+            CurrentDynamoModel.AddToSelection(watchNode);
+            CurrentDynamoModel.AddToSelection(connector);
+            CurrentDynamoModel.AddToSelection(originalPin);
+
+            CurrentDynamoModel.Copy();
+
+            Assert.AreEqual(1, CurrentDynamoModel.ClipBoard.OfType<ConnectorModel>().Count());
+            Assert.AreEqual(1, CurrentDynamoModel.ClipBoard.OfType<ConnectorPinModel>().Count());
+
+            var originalConnectorCount = CurrentDynamoModel.CurrentWorkspace.Connectors.Count();
+
+            CurrentDynamoModel.Paste();
+
+            Assert.AreEqual(4, CurrentDynamoModel.CurrentWorkspace.Nodes.Count());
+            Assert.AreEqual(originalConnectorCount + 1, CurrentDynamoModel.CurrentWorkspace.Connectors.Count());
+            Assert.AreEqual(1, DynamoSelection.Instance.Selection.OfType<ConnectorPinModel>().Count());
+
+            var copiedConnector = CurrentDynamoModel.CurrentWorkspace.Connectors
+                .First(c => c.GUID != connector.GUID);
+            Assert.AreEqual(1, copiedConnector.ConnectorPinModels.Count);
+
+            var copiedPin = copiedConnector.ConnectorPinModels.Single();
+            Assert.AreEqual(copiedConnector.GUID, copiedPin.ConnectorId);
+            Assert.That(copiedPin.GUID, Is.Not.EqualTo(originalPin.GUID));
+        }
+
         [Test]
         [Category("UnitTests"), Category("Slow")]
         public void CanAdd100NodesToClipboardAndPaste3Times()