Index: Ringtoets/Integration/src/Ringtoets.Integration.Plugin/Merge/AssessmentSectionMerger.cs
===================================================================
diff -u -rd82ab38fadcd577385b43e5951c2f4ace3180275 -rc6a4d30d199c04d78fed44e0ab315f4a319d93b2
--- Ringtoets/Integration/src/Ringtoets.Integration.Plugin/Merge/AssessmentSectionMerger.cs	(.../AssessmentSectionMerger.cs)	(revision d82ab38fadcd577385b43e5951c2f4ace3180275)
+++ Ringtoets/Integration/src/Ringtoets.Integration.Plugin/Merge/AssessmentSectionMerger.cs	(.../AssessmentSectionMerger.cs)	(revision c6a4d30d199c04d78fed44e0ab315f4a319d93b2)
@@ -27,7 +27,6 @@
 using Ringtoets.Integration.Data;
 using Ringtoets.Integration.Data.Merge;
 using Ringtoets.Integration.Forms.Merge;
-using Ringtoets.Integration.Plugin.Handlers;
 using Ringtoets.Integration.Plugin.Properties;
 using Ringtoets.Integration.Service.Comparers;
 using CoreCommonGuiResources = Core.Common.Gui.Properties.Resources;
@@ -42,37 +41,36 @@
         private static readonly ILog log = LogManager.GetLogger(typeof(AssessmentSectionMerger));
 
         private readonly IAssessmentSectionMergeFilePathProvider filePathProvider;
-        private readonly Action<string, AssessmentSectionsOwner> getAssessmentSectionsAction;
-        private readonly IAssessmentSectionMergeComparer comparer;
-        private readonly IMergeDataProvider mergeDataProvider;
+        private readonly IAssessmentSectionProvider assessmentSectionProvider;
+        private readonly IAssessmentSectionMergeComparer mergeComparer;
+        private readonly IAssessmentSectionMergeDataProvider mergeDataProvider;
         private readonly IAssessmentSectionMergeHandler mergeHandler;
 
         /// <summary>
-        /// Creates a new instance of <see cref="AssessmentSectionMerger"/>,
+        /// Creates a new instance of <see cref="AssessmentSectionMerger"/>.
         /// </summary>
         /// <param name="filePathProvider">The provider to get the file path of the file to merge.</param>
-        /// <param name="getAssessmentSectionsAction">The action for getting the assessment sections
-        /// to merge.</param>
-        /// <param name="comparer">The comparer to compare the assessment sections with.</param>
+        /// <param name="assessmentSectionProvider">The provider to the assessment sections to merge.</param>
+        /// <param name="mergeComparer">The comparer to compare the assessment sections with.</param>
         /// <param name="mergeDataProvider">The provider to get the data to merge from.</param>
         /// <param name="mergeHandler">The handler to perform the merge.</param>
         /// <exception cref="ArgumentNullException">Thrown when any parameter is <c>null</c>.</exception>
-        public AssessmentSectionMerger(IAssessmentSectionMergeFilePathProvider filePathProvider, Action<string, AssessmentSectionsOwner> getAssessmentSectionsAction,
-                                       IAssessmentSectionMergeComparer comparer, IMergeDataProvider mergeDataProvider, IAssessmentSectionMergeHandler mergeHandler)
+        public AssessmentSectionMerger(IAssessmentSectionMergeFilePathProvider filePathProvider, IAssessmentSectionProvider assessmentSectionProvider,
+                                       IAssessmentSectionMergeComparer mergeComparer, IAssessmentSectionMergeDataProvider mergeDataProvider, IAssessmentSectionMergeHandler mergeHandler)
         {
             if (filePathProvider == null)
             {
                 throw new ArgumentNullException(nameof(filePathProvider));
             }
 
-            if (getAssessmentSectionsAction == null)
+            if (assessmentSectionProvider == null)
             {
-                throw new ArgumentNullException(nameof(getAssessmentSectionsAction));
+                throw new ArgumentNullException(nameof(assessmentSectionProvider));
             }
 
-            if (comparer == null)
+            if (mergeComparer == null)
             {
-                throw new ArgumentNullException(nameof(comparer));
+                throw new ArgumentNullException(nameof(mergeComparer));
             }
 
             if (mergeDataProvider == null)
@@ -86,8 +84,8 @@
             }
 
             this.filePathProvider = filePathProvider;
-            this.getAssessmentSectionsAction = getAssessmentSectionsAction;
-            this.comparer = comparer;
+            this.assessmentSectionProvider = assessmentSectionProvider;
+            this.mergeComparer = mergeComparer;
             this.mergeDataProvider = mergeDataProvider;
             this.mergeHandler = mergeHandler;
         }
@@ -113,77 +111,61 @@
                 return;
             }
 
-            IEnumerable<AssessmentSection> assessmentSections = GetAssessmentSections(filePath);
+            IEnumerable<AssessmentSection> assessmentSections;
 
-            if (assessmentSections == null)
+            try
             {
+                assessmentSections = assessmentSectionProvider.GetAssessmentSections(filePath);
+            }
+            catch (AssessmentSectionProviderException)
+            {
                 return;
             }
 
             if (!assessmentSections.Any())
             {
-                LogError(Resources.AssessmentSectionMerger_No_matching_AssessmentSections);
+                log.Error(Resources.AssessmentSectionMerger_No_matching_AssessmentSections);
                 return;
             }
 
-            IEnumerable<AssessmentSection> matchingAssessmentSections = assessmentSections.Where(section => comparer.Compare(assessmentSection, section));
+            IEnumerable<AssessmentSection> matchingAssessmentSections = assessmentSections.Where(section => mergeComparer.Compare(assessmentSection, section));
 
             if (!matchingAssessmentSections.Any())
             {
-                LogError(Resources.AssessmentSectionMerger_No_matching_AssessmentSections);
+                log.Error(Resources.AssessmentSectionMerger_No_matching_AssessmentSections);
                 return;
             }
 
-            if (!mergeDataProvider.SelectData(matchingAssessmentSections))
+            AssessmentSectionMergeData mergeData = mergeDataProvider.GetMergeData(matchingAssessmentSections);
+
+            if (mergeData == null)
             {
                 LogCancelMessage();
                 return;
             }
 
-            AssessmentSection assessmentSectionToMerge = mergeDataProvider.SelectedAssessmentSection;
-            IEnumerable<IFailureMechanism> failureMechanismToMerge = mergeDataProvider.SelectedFailureMechanisms;
-
-            if (assessmentSectionToMerge == null || failureMechanismToMerge == null)
-            {
-                LogError(Resources.AssessmentSectionMerger_No_AssessmentSection_selected);
-                return;
-            }
-
-            PerformMerge(assessmentSection, assessmentSectionToMerge, failureMechanismToMerge);
+            PerformMerge(assessmentSection, mergeData.AssessmentSection, mergeData.FailureMechanisms);
         }
 
-        private IEnumerable<AssessmentSection> GetAssessmentSections(string filePath)
-        {
-            var assessmentSectionsOwner = new AssessmentSectionsOwner();
-            getAssessmentSectionsAction(filePath, assessmentSectionsOwner);
-            return assessmentSectionsOwner.AssessmentSections;
-        }
-
         private void PerformMerge(AssessmentSection assessmentSection, AssessmentSection assessmentSectionToMerge, IEnumerable<IFailureMechanism> failureMechanismToMerge)
         {
-            log.InfoFormat(Resources.AssessmentSectionMerger_PerformMerge_Merging_AssessmentSection_0_with_AssessmentSection_1_started,
-                           assessmentSectionToMerge.Name, assessmentSection.Name);
+            log.Info(Resources.AssessmentSectionMerger_PerformMerge_Merging_AssessmentSections_started);
 
             try
             {
                 mergeHandler.PerformMerge(assessmentSection, assessmentSectionToMerge, failureMechanismToMerge);
-                log.Info(Resources.AssessmentSectionMerger_PerformMerge_Merging_assessmentSections_successful);
+                log.Info(Resources.AssessmentSectionMerger_PerformMerge_Merging_AssessmentSections_successful);
             }
             catch (Exception e)
             {
-                log.Error(Resources.AssessmentSectionMerger_PerformMerge_Unexpected_error_occurred_during_merging, e);
-                log.Info(Resources.AssessmentSectionMerger_PerformMerge_Merging_assessmentSections_failed);
+                log.Error(Resources.AssessmentSectionMerger_PerformMerge_Unexpected_error_occurred_during_merge, e);
+                log.Error(Resources.AssessmentSectionMerger_PerformMerge_Merging_AssessmentSections_failed);
             }
         }
 
         private static void LogCancelMessage()
         {
-            log.Info(CoreCommonGuiResources.GuiImportHandler_ImportItemsUsingDialog_Importing_cancelled);
+            log.Warn(CoreCommonGuiResources.GuiImportHandler_ImportItemsUsingDialog_Importing_cancelled);
         }
-
-        private static void LogError(string message)
-        {
-            log.Error(message);
-        }
     }
 }
\ No newline at end of file