Index: Application/Ringtoets/src/Application.Ringtoets.Storage/Update/CalculationGroupUpdateExtensions.cs
===================================================================
diff -u -ra5714fc0488030773fff50dfc82041c6cb9edc2f -r06e4debe3f4a9bdfb38c40b8c00ed013e8f7bb98
--- Application/Ringtoets/src/Application.Ringtoets.Storage/Update/CalculationGroupUpdateExtensions.cs	(.../CalculationGroupUpdateExtensions.cs)	(revision a5714fc0488030773fff50dfc82041c6cb9edc2f)
+++ Application/Ringtoets/src/Application.Ringtoets.Storage/Update/CalculationGroupUpdateExtensions.cs	(.../CalculationGroupUpdateExtensions.cs)	(revision 06e4debe3f4a9bdfb38c40b8c00ed013e8f7bb98)
@@ -23,14 +23,18 @@
 using System.Linq;
 
 using Application.Ringtoets.Storage.Create;
+using Application.Ringtoets.Storage.Create.GrassCoverErosionInwards;
 using Application.Ringtoets.Storage.Create.Piping;
 using Application.Ringtoets.Storage.DbContext;
 using Application.Ringtoets.Storage.Exceptions;
 using Application.Ringtoets.Storage.Update.Piping;
 
 using Ringtoets.Common.Data.Calculation;
+using Ringtoets.GrassCoverErosionInwards.Data;
 using Ringtoets.Piping.Data;
 
+using Application.Ringtoets.Storage.Update.GrassCoverErosionInwards;
+
 namespace Application.Ringtoets.Storage.Update
 {
     /// <summary>
@@ -45,14 +49,16 @@
         /// <param name="calculationGroup">The calculation group to update the database entity for.</param>
         /// <param name="registry">The object keeping track of update operations.</param>
         /// <param name="context">The context to obtain the existing entity from.</param>
+        /// <param name="order">The index at which <paramref name="calculationGroup"/> resides
+        /// in the parent container.</param>
         /// <exception cref="ArgumentNullException">Thrown when either:
         /// <list type="bullet">
         /// <item><paramref name="registry"/> is <c>null</c></item>
         /// <item><paramref name="context"/> is <c>null</c></item>
         /// </list></exception>
         /// <exception cref="EntityNotFoundException">When <paramref name="calculationGroup"/>
         /// does not have a corresponding entity in the database.</exception>
-        internal static void Update(this CalculationGroup calculationGroup, PersistenceRegistry registry, IRingtoetsEntities context)
+        internal static void Update(this CalculationGroup calculationGroup, PersistenceRegistry registry, IRingtoetsEntities context, int order)
         {
             if (registry == null)
             {
@@ -65,6 +71,7 @@
 
             CalculationGroupEntity entity = calculationGroup.GetCorrespondingEntity(context.CalculationGroupEntities, o => o.CalculationGroupEntityId);
             entity.Name = calculationGroup.Name;
+            entity.Order = order;
 
             UpdateChildren(entity, calculationGroup, registry, context);
 
@@ -76,44 +83,88 @@
             for (int i = 0; i < calculationGroup.Children.Count; i++)
             {
                 ICalculationBase calculationBase = calculationGroup.Children[i];
-                var childGroup = calculationBase as CalculationGroup;
-                if (childGroup != null)
+                UpdateIfCalculationGroup(entity, registry, context, calculationBase, i);
+
+                UpdateIfPipingCalculation(entity, registry, context, calculationBase, i);
+
+                UpdateIfGrassCoverErosionInwardsCalculation(entity, registry, context, calculationBase, i);
+            }
+        }
+
+        private static void UpdateIfCalculationGroup(CalculationGroupEntity entity,
+                                                     PersistenceRegistry registry,
+                                                     IRingtoetsEntities context,
+                                                     ICalculationBase calculationBase,
+                                                     int order)
+        {
+            var childGroup = calculationBase as CalculationGroup;
+            if (childGroup != null)
+            {
+                if (childGroup.IsNew())
                 {
-                    if (childGroup.IsNew())
+                    entity.CalculationGroupEntity1.Add(childGroup.Create(registry, order));
+                }
+                else
+                {
+                    childGroup.Update(registry, context, order);
+                    CalculationGroupEntity childGroupEntity = context.CalculationGroupEntities.First(cge => cge.CalculationGroupEntityId == childGroup.StorageId);
+                    if (!entity.CalculationGroupEntity1.Contains(childGroupEntity))
                     {
-                        entity.CalculationGroupEntity1.Add(childGroup.Create(registry, i));
+                        childGroupEntity.CalculationGroupEntity2.CalculationGroupEntity1.Remove(childGroupEntity);
+                        entity.CalculationGroupEntity1.Add(childGroupEntity);
                     }
-                    else
+                }
+            }
+        }
+
+        private static void UpdateIfPipingCalculation(CalculationGroupEntity entity,
+                                                       PersistenceRegistry registry,
+                                                       IRingtoetsEntities context,
+                                                       ICalculationBase calculationBase,
+                                                       int order)
+        {
+            var childCalculation = calculationBase as PipingCalculationScenario;
+            if (childCalculation != null)
+            {
+                if (childCalculation.IsNew())
+                {
+                    entity.PipingCalculationEntities.Add(childCalculation.Create(registry, order));
+                }
+                else
+                {
+                    childCalculation.Update(registry, context, order);
+                    PipingCalculationEntity childCalculationEntity = context.PipingCalculationEntities.First(cge => cge.PipingCalculationEntityId == childCalculation.StorageId);
+                    if (!entity.PipingCalculationEntities.Contains(childCalculationEntity))
                     {
-                        childGroup.Update(registry, context);
-                        CalculationGroupEntity childGroupEntity = context.CalculationGroupEntities.First(cge => cge.CalculationGroupEntityId == childGroup.StorageId);
-                        childGroupEntity.Order = i;
-                        if (!entity.CalculationGroupEntity1.Contains(childGroupEntity))
-                        {
-                            childGroupEntity.CalculationGroupEntity2.CalculationGroupEntity1.Remove(childGroupEntity);
-                            entity.CalculationGroupEntity1.Add(childGroupEntity);
-                        }
+                        childCalculationEntity.CalculationGroupEntity.PipingCalculationEntities.Remove(childCalculationEntity);
+                        entity.PipingCalculationEntities.Add(childCalculationEntity);
                     }
                 }
+            }
+        }
 
-                var childCalculationScenario = calculationBase as PipingCalculationScenario;
-                if (childCalculationScenario != null)
+        private static void UpdateIfGrassCoverErosionInwardsCalculation(CalculationGroupEntity entity,
+                                                                         PersistenceRegistry registry,
+                                                                         IRingtoetsEntities context,
+                                                                         ICalculationBase calculationBase,
+                                                                         int order)
+        {
+            var childCalculation = calculationBase as GrassCoverErosionInwardsCalculation;
+            if (childCalculation != null)
+            {
+                if (childCalculation.IsNew())
                 {
-                    if (childCalculationScenario.IsNew())
+                    entity.GrassCoverErosionInwardsCalculationEntities.Add(childCalculation.Create(registry, order));
+                }
+                else
+                {
+                    childCalculation.Update(registry, context, order);
+                    GrassCoverErosionInwardsCalculationEntity childCalculationEntity = context.GrassCoverErosionInwardsCalculationEntities.First(cge => cge.GrassCoverErosionInwardsCalculationEntityId == childCalculation.StorageId);
+                    if (!entity.GrassCoverErosionInwardsCalculationEntities.Contains(childCalculationEntity))
                     {
-                        entity.PipingCalculationEntities.Add(childCalculationScenario.Create(registry, i));
+                        childCalculationEntity.CalculationGroupEntity.GrassCoverErosionInwardsCalculationEntities.Remove(childCalculationEntity);
+                        entity.GrassCoverErosionInwardsCalculationEntities.Add(childCalculationEntity);
                     }
-                    else
-                    {
-                        childCalculationScenario.Update(registry, context);
-                        PipingCalculationEntity childPipingCalculationEntity = context.PipingCalculationEntities.First(cge => cge.PipingCalculationEntityId == childCalculationScenario.StorageId);
-                        childPipingCalculationEntity.Order = i;
-                        if (!entity.PipingCalculationEntities.Contains(childPipingCalculationEntity))
-                        {
-                            childPipingCalculationEntity.CalculationGroupEntity.PipingCalculationEntities.Remove(childPipingCalculationEntity);
-                            entity.PipingCalculationEntities.Add(childPipingCalculationEntity);
-                        }
-                    }
                 }
             }
         }