Index: Ringtoets/Piping/src/Ringtoets.Piping.Forms/NodePresenters/PipingCalculationGroupContextNodePresenter.cs
===================================================================
diff -u -r528577e7cac9c86626794fafc6c6c147146c5e84 -rc92d66879011422e6339c218502fb0489aa27119
--- Ringtoets/Piping/src/Ringtoets.Piping.Forms/NodePresenters/PipingCalculationGroupContextNodePresenter.cs	(.../PipingCalculationGroupContextNodePresenter.cs)	(revision 528577e7cac9c86626794fafc6c6c147146c5e84)
+++ Ringtoets/Piping/src/Ringtoets.Piping.Forms/NodePresenters/PipingCalculationGroupContextNodePresenter.cs	(.../PipingCalculationGroupContextNodePresenter.cs)	(revision c92d66879011422e6339c218502fb0489aa27119)
@@ -42,15 +42,14 @@
 
         public override DragOperations CanDrop(object item, ITreeNode sourceNode, ITreeNode targetNode, DragOperations validOperations)
         {
-            var calculation = item as PipingCalculationContext;
-            if (calculation != null)
+            var targetGroup = ((PipingCalculationGroupContext)targetNode.Tag).WrappedData;
+
+            IPipingCalculationItem pipingCalculationItem = GetAsIPipingCalculationItem(item);
+            if (pipingCalculationItem != null && !targetGroup.Children.Contains(pipingCalculationItem))
             {
-                var group = ((PipingCalculationGroupContext)targetNode.Tag).WrappedData;
-                if (!group.Children.Contains(calculation.WrappedData))
-                {
-                    return validOperations;
-                }
+                return validOperations;
             }
+
             return base.CanDrop(item, sourceNode, targetNode, validOperations);
         }
 
@@ -202,14 +201,20 @@
             }
         }
 
+        protected override DragOperations CanDrag(PipingCalculationGroupContext nodeData)
+        {
+            return DragOperations.Move;
+        }
+
         protected override void OnDragDrop(object item, object itemParent, PipingCalculationGroupContext target, DragOperations operation, int position)
         {
-            var calculationContext = item as PipingCalculationContext;
+            IPipingCalculationItem pipingCalculationItem = GetAsIPipingCalculationItem(item);
             var originalOwnerContext = itemParent as PipingCalculationGroupContext;
-            if (calculationContext != null && originalOwnerContext != null)
+            if (pipingCalculationItem != null && originalOwnerContext != null)
             {
-                originalOwnerContext.WrappedData.Children.Remove(calculationContext.WrappedData);
-                target.WrappedData.Children.Add(calculationContext.WrappedData);
+                
+                originalOwnerContext.WrappedData.Children.Remove(pipingCalculationItem);
+                target.WrappedData.Children.Add(pipingCalculationItem);
 
                 originalOwnerContext.NotifyObservers();
                 target.NotifyObservers();
@@ -219,5 +224,22 @@
                 base.OnDragDrop(item, itemParent, target, operation, position);
             }
         }
+
+        private static IPipingCalculationItem GetAsIPipingCalculationItem(object item)
+        {
+            var calculationContext = item as PipingCalculationContext;
+            if (calculationContext != null)
+            {
+                return calculationContext.WrappedData;
+            }
+
+            var groupContext = item as PipingCalculationGroupContext;
+            if (groupContext != null)
+            {
+                return groupContext.WrappedData;
+            }
+
+            return null;
+        }
     }
 }
\ No newline at end of file
Index: Ringtoets/Piping/test/Ringtoets.Piping.Forms.Test/NodePresenters/PipingCalculationGroupContextNodePresenterTest.cs
===================================================================
diff -u -r528577e7cac9c86626794fafc6c6c147146c5e84 -rc92d66879011422e6339c218502fb0489aa27119
--- Ringtoets/Piping/test/Ringtoets.Piping.Forms.Test/NodePresenters/PipingCalculationGroupContextNodePresenterTest.cs	(.../PipingCalculationGroupContextNodePresenterTest.cs)	(revision 528577e7cac9c86626794fafc6c6c147146c5e84)
+++ Ringtoets/Piping/test/Ringtoets.Piping.Forms.Test/NodePresenters/PipingCalculationGroupContextNodePresenterTest.cs	(.../PipingCalculationGroupContextNodePresenterTest.cs)	(revision c92d66879011422e6339c218502fb0489aa27119)
@@ -108,6 +108,27 @@
         }
 
         [Test]
+        public void CanDrag_Always_ReturnMove()
+        {
+            // Setup
+            var builderProvider = mockRepository.Stub<IContextMenuBuilderProvider>();
+            mockRepository.ReplayAll();
+
+            var group = new PipingCalculationGroup();
+            var groupContext = new PipingCalculationGroupContext(group,
+                                                                 Enumerable.Empty<RingtoetsPipingSurfaceLine>(),
+                                                                 Enumerable.Empty<PipingSoilProfile>());
+
+            var nodePresenter = new PipingCalculationGroupContextNodePresenter(builderProvider);
+
+            // Call
+            DragOperations supportedOperation = nodePresenter.CanDrag(groupContext);
+
+            // Assert
+            Assert.AreEqual(DragOperations.Move, supportedOperation);
+        }
+
+        [Test]
         public void CanDrop_DraggingPipingCalculationContextOntoGroupNotContainingCalculation_ReturnMove()
         {
             // Setup
@@ -183,9 +204,84 @@
         }
 
         [Test]
-        public void OnDragDrop_DragginPipingCalculationContextOntoGroup_MoveCalculationInstanceToNewGroup()
+        public void CanDrop_DraggingPipingCalculationGroupContextOntoGroupNotContainingGroup_ReturnMove()
         {
             // Setup
+            var group = new PipingCalculationGroup();
+            var groupContext = new PipingCalculationGroupContext(group,
+                                                                 Enumerable.Empty<RingtoetsPipingSurfaceLine>(),
+                                                                 Enumerable.Empty<PipingSoilProfile>());
+            var targetGroup = new PipingCalculationGroup();
+            var targetGroupContext = new PipingCalculationGroupContext(targetGroup,
+                                                                       Enumerable.Empty<RingtoetsPipingSurfaceLine>(),
+                                                                       Enumerable.Empty<PipingSoilProfile>());
+
+            var groupNode = mockRepository.Stub<ITreeNode>();
+            groupNode.Tag = group;
+
+            var targetGroupNode = mockRepository.Stub<ITreeNode>();
+            targetGroupNode.Tag = targetGroupContext;
+
+            var contextMenuBuilderProviderMock = mockRepository.StrictMock<IContextMenuBuilderProvider>();
+
+            mockRepository.ReplayAll();
+
+            // Precondition:
+            CollectionAssert.DoesNotContain(targetGroup.Children, group,
+                "It doesn't make sense to allow dragging onto a group that already contains that node as direct child.");
+
+            var nodePresenter = new PipingCalculationGroupContextNodePresenter(contextMenuBuilderProviderMock);
+
+            // Call
+            DragOperations supportedOperations = nodePresenter.CanDrop(groupContext, groupNode, targetGroupNode, DragOperations.Move);
+
+            // Assert
+            Assert.AreEqual(DragOperations.Move, supportedOperations);
+            mockRepository.ReplayAll();
+        }
+
+        [Test]
+        public void CanDrop_DraggingPipingCalculationGroupContextOntoGroupContainingGroup_ReturnNone()
+        {
+            // Setup
+            var group = new PipingCalculation();
+            var groupContext = new PipingCalculationContext(group,
+                                                            Enumerable.Empty<RingtoetsPipingSurfaceLine>(),
+                                                            Enumerable.Empty<PipingSoilProfile>());
+            var targetGroup = new PipingCalculationGroup();
+            targetGroup.Children.Add(group);
+            var targetGroupContext = new PipingCalculationGroupContext(targetGroup,
+                                                                       Enumerable.Empty<RingtoetsPipingSurfaceLine>(),
+                                                                       Enumerable.Empty<PipingSoilProfile>());
+
+            var groupNode = mockRepository.Stub<ITreeNode>();
+            groupNode.Tag = groupContext;
+
+            var targetGroupNode = mockRepository.Stub<ITreeNode>();
+            targetGroupNode.Tag = targetGroupContext;
+
+            var contextMenuBuilderProviderMock = mockRepository.StrictMock<IContextMenuBuilderProvider>();
+
+            mockRepository.ReplayAll();
+
+            // Precondition:
+            CollectionAssert.Contains(targetGroup.Children, group,
+                "It doesn't make sense to allow dragging onto a group that already contains that node as direct child.");
+
+            var nodePresenter = new PipingCalculationGroupContextNodePresenter(contextMenuBuilderProviderMock);
+
+            // Call
+            DragOperations supportedOperations = nodePresenter.CanDrop(groupContext, groupNode, targetGroupNode, DragOperations.Move);
+
+            // Assert
+            Assert.AreEqual(DragOperations.None, supportedOperations);
+            mockRepository.ReplayAll();
+        }
+
+        [Test]
+        public void OnDragDrop_DraggingPipingCalculationContextOntoGroup_MoveCalculationInstanceToNewGroup()
+        {
+            // Setup
             var originalOwnerObserver = mockRepository.StrictMock<IObserver>();
             originalOwnerObserver.Expect(o => o.UpdateObserver());
 
@@ -230,6 +326,53 @@
         }
 
         [Test]
+        public void OnDragDrop_DraggingPipingCalculationGroupContextOntoGroup_MoveGroupInstanceToNewGroup()
+        {
+            // Setup
+            var originalOwnerObserver = mockRepository.StrictMock<IObserver>();
+            originalOwnerObserver.Expect(o => o.UpdateObserver());
+
+            var newOwnerObserver = mockRepository.StrictMock<IObserver>();
+            newOwnerObserver.Expect(o => o.UpdateObserver());
+
+            var contextMenuBuilderProviderMock = mockRepository.StrictMock<IContextMenuBuilderProvider>();
+
+            mockRepository.ReplayAll();
+
+            var group = new PipingCalculationGroup();
+            var groupContext = new PipingCalculationGroupContext(group,
+                                                                 Enumerable.Empty<RingtoetsPipingSurfaceLine>(),
+                                                                 Enumerable.Empty<PipingSoilProfile>());
+            var originalOwnerGroup = new PipingCalculationGroup();
+            originalOwnerGroup.Children.Add(group);
+            originalOwnerGroup.Attach(originalOwnerObserver);
+            var originalOwnerGroupContext = new PipingCalculationGroupContext(originalOwnerGroup,
+                                                                              Enumerable.Empty<RingtoetsPipingSurfaceLine>(),
+                                                                              Enumerable.Empty<PipingSoilProfile>());
+
+            var newOwnerGroup = new PipingCalculationGroup();
+            newOwnerGroup.Attach(newOwnerObserver);
+            var newOwnerGroupContext = new PipingCalculationGroupContext(newOwnerGroup,
+                                                                 Enumerable.Empty<RingtoetsPipingSurfaceLine>(),
+                                                                 Enumerable.Empty<PipingSoilProfile>());
+
+            // Precondition:
+            CollectionAssert.Contains(originalOwnerGroup.Children, group);
+            CollectionAssert.DoesNotContain(newOwnerGroup.Children, group);
+
+            var nodePresenter = new PipingCalculationGroupContextNodePresenter(contextMenuBuilderProviderMock);
+
+            // Call
+            nodePresenter.OnDragDrop(groupContext, originalOwnerGroupContext, newOwnerGroupContext, DragOperations.Move, int.MaxValue);
+
+            // Assert
+            CollectionAssert.DoesNotContain(originalOwnerGroup.Children, group);
+            CollectionAssert.Contains(newOwnerGroup.Children, group);
+            Assert.AreSame(group, newOwnerGroup.Children.Last());
+            mockRepository.VerifyAll();
+        }
+
+        [Test]
         public void CanRenameNode_ParentIsPipingFailureMechanismNode_ReturnFalse()
         {
             // Setup