From 8a42f8dc7de3f42e09764daff450316e2196172f Mon Sep 17 00:00:00 2001 From: Elias Fierke Date: Sat, 16 May 2026 15:09:55 +0200 Subject: [PATCH] [chore:] logging for CombineAddresses.cs --- Tasks/CombineAddresses.cs | 377 ++++++++++++++++++++++---------------- 1 file changed, 219 insertions(+), 158 deletions(-) diff --git a/Tasks/CombineAddresses.cs b/Tasks/CombineAddresses.cs index 0ac8aa8..04e2a11 100644 --- a/Tasks/CombineAddresses.cs +++ b/Tasks/CombineAddresses.cs @@ -26,28 +26,48 @@ public class CombineAddresses public async Task<(KasAddressList, KasAddressList)> Perform(List address_lists, string type, CombineType comb_type, bool? exportUnused, bool? deleteOld) { - var result = await Execute(address_lists,type,comb_type,exportUnused); - - if (deleteOld == true) + try { - foreach (var list in address_lists) - { - Settings._instance.addressSets.addresses.Remove(list); - } + var result = await Execute(address_lists,type,comb_type,exportUnused); + + 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 address_lists, string type, CombineType comb_type, bool? exportUnused) { - if (type == "difference") return await Difference(address_lists, comb_type, exportUnused); - if (type == "union") return await Union(address_lists, comb_type, exportUnused); - 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); + try + { + if (type == "difference") return await Difference(address_lists, comb_type, exportUnused); + if (type == "union") return await Union(address_lists, comb_type, exportUnused); + 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 /// 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) - return (new KasAddressList(await KasAddressList.GenerateName("difference")), null); - - progress ??= new Progress + try { - TotalPersons = address_lists.Sum(l => l.KasPersons.Count), - ComparedPersons = 0 - }; - - // Vereinigung aller Listen außer der ersten - var restUnion = new List(); - 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) + if (address_lists == null || address_lists.Count == 0) + return (new KasAddressList(await KasAddressList.GenerateName("difference")), null); + + progress ??= new Progress + { + TotalPersons = address_lists.Sum(l => l.KasPersons.Count), + ComparedPersons = 0 + }; + + // Vereinigung aller Listen außer der ersten + var restUnion = new List(); + 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)); - 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)); + Logger.Log($"Error while performing difference-combining: {ex.Message}", Logger.LogType.Error); } - if (return_unused == true) return (result, second_result); - return (result, null); + return (null,null); + } public async Task<(KasAddressList, KasAddressList)> Union(List address_lists, CombineType comb_type, bool? return_unused, Progress progress = null) { - var result = new KasAddressList(await KasAddressList.GenerateName("union")); - 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) + try { - 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)); + var result = new KasAddressList(await KasAddressList.GenerateName("union")); + 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))) + 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 (result, null); + return (null,null); + } @@ -182,107 +223,127 @@ public class CombineAddresses public async Task<(KasAddressList, KasAddressList)> Intersection(List address_lists, CombineType comb_type, bool? return_unused, Progress progress = null) { - var result = new KasAddressList(await KasAddressList.GenerateName("intersection")); - 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) + try { - // Prüfen, ob Person in *allen* anderen Listen vorkommt - var isInAll = otherLists.All(list => - list.KasPersons.Any(existing => CompareAddresses(existing, person, comb_type))); - - if (isInAll) - 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} geprüft – {(isInAll ? "in allen enthalten" : "nicht überall vorhanden")}"; - - // Sicher und nicht blockierend loggen - if (progress != null) + var result = new KasAddressList(await KasAddressList.GenerateName("intersection")); + 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) { - if (Dispatcher.UIThread.CheckAccess()) - progress.LogAction?.Invoke(logMessage); + // Prüfen, ob Person in *allen* anderen Listen vorkommt + 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 (result, null); + return (null,null); + } public async Task<(KasAddressList, KasAddressList)> SymmetricDifference(List address_lists, CombineType comb_type, bool? return_unused, Progress progress = null) { - var result = new KasAddressList(await KasAddressList.GenerateName("symmetric_difference")); - 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) + try { - // Prüfen, ob schon vorhanden - var existing = allPersons.FirstOrDefault(p => CompareAddresses(p.person, person, comb_type)); - if (existing.person != null) + var result = new KasAddressList(await KasAddressList.GenerateName("symmetric_difference")); + 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) { - // 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++; - 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); + // Prüfen, ob schon vorhanden + 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 - 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); + return (null,null); + } }