[chore:] logging for CombineAddresses.cs

Tasks/CombineAddresses.cs

@@ -26,28 +26,48 @@ public class CombineAddresses
     public async Task<(KasAddressList, KasAddressList)> Perform(List<KasAddressList> address_lists, string type, CombineType comb_type,
         bool? exportUnused, bool? deleteOld)
     {
-        var result = await Execute(address_lists,type,comb_type,exportUnused);
+        try
-
-        if (deleteOld == true)
         {
-            foreach (var list in address_lists)
+            var result = await Execute(address_lists,type,comb_type,exportUnused);
-            {
+            
-                Settings._instance.addressSets.addresses.Remove(list);
+                    if (deleteOld == true)
-            }
+                    {
+                        foreach (var list in address_lists)
+                        {
+                            Settings._instance.addressSets.addresses.Remove(list);
+                        }
+                    }
+            
+                    return result;
+        }
+        catch (Exception ex)
+        {
+            Logger.Log($"Error while performing address combining: {ex.Message}", Logger.LogType.Error);
         }
 
-        return result;
+        return (null,null);
+        
 
     }
 
     private async Task<(KasAddressList, KasAddressList)> Execute(List<KasAddressList> address_lists, string type, CombineType comb_type,
         bool? exportUnused)
     {
-        if (type == "difference") return await Difference(address_lists, comb_type, exportUnused);
+        try
-        if (type == "union") return await Union(address_lists, comb_type, exportUnused);
+        {
-        if (type == "intersection") return await Intersection(address_lists, comb_type, exportUnused);
+            if (type == "difference") return await Difference(address_lists, comb_type, exportUnused);
-        if (type == "symdiff") return await SymmetricDifference(address_lists, comb_type, exportUnused);
+            if (type == "union") return await Union(address_lists, comb_type, exportUnused);
-        return (null, null);
+            if (type == "intersection") return await Intersection(address_lists, comb_type, exportUnused);
+            if (type == "symdiff") return await SymmetricDifference(address_lists, comb_type, exportUnused);
+            return (null, null);
+        }
+        catch (Exception ex)
+        {
+            Logger.Log($"Error while executing address combining: {ex.Message}", Logger.LogType.Error);
+        }
+
+        return (null,null);
+        
     }
 
 
@@ -60,6 +80,7 @@ public class CombineAddresses
     /// <returns></returns>
     public bool CompareAddresses(KasPerson first, KasPerson second, CombineType comb_type)
     {
+        
         // A refsid of 0 means "missing", so it must not collapse unrelated entries.
         if(comb_type == CombineType.refsid)
             if (first.refsid != 0 && second.refsid != 0 && first.refsid == second.refsid) return true;
@@ -96,81 +117,101 @@ public class CombineAddresses
         bool? return_unused,
         Progress? progress = null)
     {
-        if (address_lists == null || address_lists.Count == 0)
+        try
-            return (new KasAddressList(await KasAddressList.GenerateName("difference")), null);
-
-        progress ??= new Progress
         {
-            TotalPersons = address_lists.Sum(l => l.KasPersons.Count),
+            if (address_lists == null || address_lists.Count == 0)
-            ComparedPersons = 0
+                return (new KasAddressList(await KasAddressList.GenerateName("difference")), null);
-        };
     
-        // Vereinigung aller Listen außer der ersten
+            progress ??= new Progress
-        var restUnion = new List<KasPerson>();
+            {
-        for (var i = 1; i < address_lists.Count; i++)
+                TotalPersons = address_lists.Sum(l => l.KasPersons.Count),
-            restUnion.AddRange(address_lists[i].KasPersons);
+                ComparedPersons = 0
-        var result = new KasAddressList(await KasAddressList.GenerateName("difference"));
+            };
-        var second_result = new KasAddressList("none");
-        if(return_unused == true)
-            second_result = new KasAddressList(await KasAddressList.GenerateName("difference_rest", false));
     
-        foreach (var person in address_lists[0].KasPersons)
+            // Vereinigung aller Listen außer der ersten
+            var restUnion = new List<KasPerson>();
+            for (var i = 1; i < address_lists.Count; i++)
+                restUnion.AddRange(address_lists[i].KasPersons);
+            var result = new KasAddressList(await KasAddressList.GenerateName("difference"));
+            var second_result = new KasAddressList("none");
+            if(return_unused == true)
+                second_result = new KasAddressList(await KasAddressList.GenerateName("difference_rest", false));
+    
+            foreach (var person in address_lists[0].KasPersons)
+            {
+                var isDouble = restUnion.Any(p => CompareAddresses(person, p, comb_type));
+                if (!isDouble)
+                    result.KasPersons.Add(person);
+                else
+                    second_result.KasPersons.Add(person);
+    
+    
+                progress.Increment();
+                if (progress.LogAction == null) continue;
+                var logMessage =
+                    $"Person mit id {person.id} verglichen mit {restUnion.Count} Personen des Restes.";
+                await Dispatcher.UIThread.InvokeAsync(() => progress.LogAction?.Invoke(logMessage));
+            }
+    
+            if (return_unused == true) return (result, second_result);
+            return (result, null);
+        }
+        catch (Exception ex)
         {
-            var isDouble = restUnion.Any(p => CompareAddresses(person, p, comb_type));
+            Logger.Log($"Error while performing difference-combining: {ex.Message}", Logger.LogType.Error);
-            if (!isDouble)
-                result.KasPersons.Add(person);
-            else
-                second_result.KasPersons.Add(person);
-
-
-            progress.Increment();
-            if (progress.LogAction == null) continue;
-            var logMessage =
-                $"Person mit id {person.id} verglichen mit {restUnion.Count} Personen des Restes.";
-            await Dispatcher.UIThread.InvokeAsync(() => progress.LogAction?.Invoke(logMessage));
         }
 
-        if (return_unused == true) return (result, second_result);
+        return (null,null);
-        return (result, null);
+        
     }
 
 
     public async Task<(KasAddressList, KasAddressList)> Union(List<KasAddressList> address_lists, CombineType comb_type, bool? return_unused,
         Progress progress = null)
     {
-        var result = new KasAddressList(await KasAddressList.GenerateName("union"));
+        try
-        var second_result = new KasAddressList("none");
-        if(return_unused == true)
-            second_result = new KasAddressList(await KasAddressList.GenerateName("union_rest", false));
-
-        if (address_lists == null || address_lists.Count == 0)
-            return (result, null);
-
-        var total = address_lists.Sum(l => l.KasPersons.Count);
-        var processed = 0;
-
-        foreach (var list in address_lists)
-        foreach (var person in list.KasPersons)
         {
-            if (!result.KasPersons.Any(existing => CompareAddresses(existing, person, comb_type)))
+            var result = new KasAddressList(await KasAddressList.GenerateName("union"));
-                result.KasPersons.Add(person);
+            var second_result = new KasAddressList("none");
-            else
+            if(return_unused == true)
-                second_result.KasPersons.Add(person);
+                second_result = new KasAddressList(await KasAddressList.GenerateName("union_rest", false));
     
-            processed++;
+            if (address_lists == null || address_lists.Count == 0)
-            var percent = processed / (double)total * 100;
+                return (result, null);
-            var logMessage =
-                $"{percent:F1}%: Person mit {person.id} hinzugefügt (aktuell {result.KasPersons.Count} Einträge)";
     
-            if (progress == null) continue;
+            var total = address_lists.Sum(l => l.KasPersons.Count);
-            if (Dispatcher.UIThread.CheckAccess())
+            var processed = 0;
-                progress.LogAction?.Invoke(logMessage);
+    
-            else
+            foreach (var list in address_lists)
-                Dispatcher.UIThread.Post(() => progress.LogAction?.Invoke(logMessage));
+            foreach (var person in list.KasPersons)
+            {
+                if (!result.KasPersons.Any(existing => CompareAddresses(existing, person, comb_type)))
+                    result.KasPersons.Add(person);
+                else
+                    second_result.KasPersons.Add(person);
+    
+                processed++;
+                var percent = processed / (double)total * 100;
+                var logMessage =
+                    $"{percent:F1}%: Person mit {person.id} hinzugefügt (aktuell {result.KasPersons.Count} Einträge)";
+    
+                if (progress == null) continue;
+                if (Dispatcher.UIThread.CheckAccess())
+                    progress.LogAction?.Invoke(logMessage);
+                else
+                    Dispatcher.UIThread.Post(() => progress.LogAction?.Invoke(logMessage));
+            }
+    
+            if (return_unused == true) return (result, second_result);
+            return (result, null);
+        }
+        catch (Exception ex)
+        {
+            Logger.Log($"Error while performing union-combining: {ex.Message}", Logger.LogType.Error);
         }
 
-        if (return_unused == true) return (result, second_result);
+        return (null,null);
-        return (result, null);
+        
     }
 
 
@@ -182,107 +223,127 @@ public class CombineAddresses
     public async Task<(KasAddressList, KasAddressList)> Intersection(List<KasAddressList> address_lists, CombineType comb_type,
         bool? return_unused, Progress progress = null)
     {
-        var result = new KasAddressList(await KasAddressList.GenerateName("intersection"));
+        try
-        var second_result = new KasAddressList("none");
-        if(return_unused == true) second_result = new KasAddressList(await KasAddressList.GenerateName("intersection_rest", false));
-
-        if (address_lists == null || address_lists.Count == 0)
-            return (result, null);
-
-        // Nur die erste Liste als Ausgangspunkt verwenden
-        var baseList = address_lists[0];
-        var otherLists = address_lists.Skip(1).ToList();
-
-        var total = baseList.KasPersons.Count;
-        var processed = 0;
-
-        foreach (var person in baseList.KasPersons)
         {
-            // Prüfen, ob Person in *allen* anderen Listen vorkommt
+            var result = new KasAddressList(await KasAddressList.GenerateName("intersection"));
-            var isInAll = otherLists.All(list =>
+            var second_result = new KasAddressList("none");
-                list.KasPersons.Any(existing => CompareAddresses(existing, person, comb_type)));
+            if(return_unused == true) second_result = new KasAddressList(await KasAddressList.GenerateName("intersection_rest", false));
     
-            if (isInAll)
+            if (address_lists == null || address_lists.Count == 0)
-                result.KasPersons.Add(person);
+                return (result, null);
-            else
-                second_result.KasPersons.Add(person);
     
-            processed++;
+            // Nur die erste Liste als Ausgangspunkt verwenden
-            var percent = processed / (double)total * 100;
+            var baseList = address_lists[0];
-            var logMessage =
+            var otherLists = address_lists.Skip(1).ToList();
-                $"{percent:F1}%: Person mit {person.id} geprüft – {(isInAll ? "in allen enthalten" : "nicht überall vorhanden")}";
     
-            // Sicher und nicht blockierend loggen
+            var total = baseList.KasPersons.Count;
-            if (progress != null)
+            var processed = 0;
+    
+            foreach (var person in baseList.KasPersons)
             {
-                if (Dispatcher.UIThread.CheckAccess())
+                // Prüfen, ob Person in *allen* anderen Listen vorkommt
-                    progress.LogAction?.Invoke(logMessage);
+                var isInAll = otherLists.All(list =>
+                    list.KasPersons.Any(existing => CompareAddresses(existing, person, comb_type)));
+    
+                if (isInAll)
+                    result.KasPersons.Add(person);
                 else
-                    Dispatcher.UIThread.Post(() => progress.LogAction?.Invoke(logMessage));
+                    second_result.KasPersons.Add(person);
+    
+                processed++;
+                var percent = processed / (double)total * 100;
+                var logMessage =
+                    $"{percent:F1}%: Person mit {person.id} geprüft – {(isInAll ? "in allen enthalten" : "nicht überall vorhanden")}";
+    
+                // Sicher und nicht blockierend loggen
+                if (progress != null)
+                {
+                    if (Dispatcher.UIThread.CheckAccess())
+                        progress.LogAction?.Invoke(logMessage);
+                    else
+                        Dispatcher.UIThread.Post(() => progress.LogAction?.Invoke(logMessage));
+                }
             }
+    
+            if (return_unused == true) return (result, second_result);
+            return (result, null);
+        }
+        catch (Exception ex)
+        {
+            Logger.Log($"Error while performing intersection-combining: {ex.Message}", Logger.LogType.Error);
         }
 
-        if (return_unused == true) return (result, second_result);
+        return (null,null);
-        return (result, null);
+        
     }
 
 
     public async Task<(KasAddressList, KasAddressList)> SymmetricDifference(List<KasAddressList> address_lists, CombineType comb_type,
         bool? return_unused, Progress progress = null)
     {
-        var result = new KasAddressList(await KasAddressList.GenerateName("symmetric_difference"));
+        try
-        var second_result = new KasAddressList("none");
-        if(return_unused == true) second_result = new KasAddressList(await KasAddressList.GenerateName("symmetric_rest", false));
-
-        if (address_lists == null || address_lists.Count == 0)
-            return (result, null);
-
-        var total = address_lists.Sum(l => l.KasPersons.Count);
-        var processed = 0;
-
-        // Wir sammeln alle Personen + zählen, wie oft sie vorkommen
-        var allPersons = new List<(KasPerson person, int count)>();
-
-        foreach (var list in address_lists)
-        foreach (var person in list.KasPersons)
         {
-            // Prüfen, ob schon vorhanden
+            var result = new KasAddressList(await KasAddressList.GenerateName("symmetric_difference"));
-            var existing = allPersons.FirstOrDefault(p => CompareAddresses(p.person, person, comb_type));
+            var second_result = new KasAddressList("none");
-            if (existing.person != null)
+            if(return_unused == true) second_result = new KasAddressList(await KasAddressList.GenerateName("symmetric_rest", false));
-            {
-                // Falls schon drin → Vorkommen erhöhen
-                var index = allPersons.IndexOf(existing);
-                allPersons[index] = (existing.person, existing.count + 1);
-            }
-            else
-            {
-                // Neu hinzufügen
-                allPersons.Add((person, 1));
-            }
     
-            processed++;
+            if (address_lists == null || address_lists.Count == 0)
-            var percent = processed / (double)total * 100;
+                return (result, null);
-            var logMessage =
-                $"{percent:F1}%: Person mit {person.id} verarbeitet (Zwischengröße {allPersons.Count})";
     
-            if (progress != null)
+            var total = address_lists.Sum(l => l.KasPersons.Count);
+            var processed = 0;
+    
+            // Wir sammeln alle Personen + zählen, wie oft sie vorkommen
+            var allPersons = new List<(KasPerson person, int count)>();
+    
+            foreach (var list in address_lists)
+            foreach (var person in list.KasPersons)
             {
-                if (Dispatcher.UIThread.CheckAccess())
+                // Prüfen, ob schon vorhanden
-                    progress.LogAction?.Invoke(logMessage);
+                var existing = allPersons.FirstOrDefault(p => CompareAddresses(p.person, person, comb_type));
+                if (existing.person != null)
+                {
+                    // Falls schon drin → Vorkommen erhöhen
+                    var index = allPersons.IndexOf(existing);
+                    allPersons[index] = (existing.person, existing.count + 1);
+                }
                 else
-                    Dispatcher.UIThread.Post(() => progress.LogAction?.Invoke(logMessage));
+                {
+                    // Neu hinzufügen
+                    allPersons.Add((person, 1));
+                }
+    
+                processed++;
+                var percent = processed / (double)total * 100;
+                var logMessage =
+                    $"{percent:F1}%: Person mit {person.id} verarbeitet (Zwischengröße {allPersons.Count})";
+    
+                if (progress != null)
+                {
+                    if (Dispatcher.UIThread.CheckAccess())
+                        progress.LogAction?.Invoke(logMessage);
+                    else
+                        Dispatcher.UIThread.Post(() => progress.LogAction?.Invoke(logMessage));
+                }
             }
+    
+            // Nur diejenigen übernehmen, die *genau einmal* vorkamen
+            foreach (var (person, count) in allPersons)
+                if (count == 1)
+                    result.KasPersons.Add(person);
+                else
+                    second_result.KasPersons.Add(person);
+    
+            if (return_unused == true) return (result, second_result);
+            return (result, null);
+        }
+        catch (Exception ex)
+        {
+            Logger.Log($"Error while performing symdiff-combining: {ex.Message}", Logger.LogType.Error);
         }
 
-        // Nur diejenigen übernehmen, die *genau einmal* vorkamen
+        return (null,null);
-        foreach (var (person, count) in allPersons)
-            if (count == 1)
-                result.KasPersons.Add(person);
-            else
-                second_result.KasPersons.Add(person);
         
-        if (return_unused == true) return (result, second_result);
-        return (result, null);
     }
     
 }