Merge pull request #519 from LogExperts/514-loading-as-session-file-leads-to-broken-ui-if-a-log-file-in-session-is-not-found

This pull request introduces several enhancements and new utilities for managing and validating project file references, especially in the context of handling `.lxp` persistence files and improving file history and error handling. The changes add robust helpers for resolving, validating, and mapping project file references, provide mechanisms for suggesting alternative file locations, and improve error resilience in file operations.

**Key changes include new helpers for file resolution and validation, improvements to project file loading, and enhanced error handling.**

### Project File Resolution & Validation

* Added `ProjectFileResolver` and `ProjectFileValidator` utility classes to resolve project file references (including `.lxp` persistence files) to actual log files and to validate file existence, suggest alternatives, and handle plugin-based file systems. (`src/LogExpert.Core/Classes/Persister/ProjectFileResolver.cs` [[1]](diffhunk://#diff-c97308928b24e1acaf08b01001575c38fde84c91fd58a08ec8f0f0dc724dd32cR1-R34) `src/LogExpert.Core/Classes/Persister/ProjectFileValidator.cs` [[2]](diffhunk://#diff-25f80a76f76ad97c518796ad90a24c99899d5333c15ce34773dd4d52369f594aR1-R251)
* Introduced `ProjectLoadResult` to encapsulate project loading results, including validation status, mappings from log files to original references, and user intervention flags. (`src/LogExpert.Core/Classes/Persister/ProjectLoadResult.cs` [src/LogExpert.Core/Classes/Persister/ProjectLoadResult.csR1-R35](diffhunk://#diff-81f8d066d1d4e13a51237b6d95b0a0f887b86309d110527010010592e32b0996R1-R35))

### Project Persistence and Data Model

* Enhanced `ProjectPersister.LoadProjectData` to use the new validation and resolution helpers, returning a `ProjectLoadResult` instead of raw `ProjectData`. (`src/LogExpert.Core/Classes/Persister/ProjectPersister.cs` [[1]](diffhunk://#diff-3ef68afcef4c2dd062a4eac57011dd212a9b67cbec4d3d536d3147fde607ac42R3-R4) [[2]](diffhunk://#diff-3ef68afcef4c2dd062a4eac57011dd212a9b67cbec4d3d536d3147fde607ac42L16-R24)
* Updated `ProjectData` to include a `ProjectFilePath` property for improved context in file validation and alternative search. (`src/LogExpert.Core/Classes/Persister/ProjectData.cs` [src/LogExpert.Core/Classes/Persister/ProjectData.csR18-R22](diffhunk://#diff-b2b14f679e01b1ca86200e829986b5b05e21178471200d744f3f688de5715f9eR18-R22))

### File Reference Resolution Helpers

* Added `PersisterHelpers` with methods to resolve `.lxp` settings files to their contained log file paths, supporting plugin-based file systems and collections of file names. (`src/LogExpert.Core/Classes/Persister/PersisterHelpers.cs` [src/LogExpert.Core/Classes/Persister/PersisterHelpers.csR1-R71](diffhunk://#diff-9f15d9ff4e5401af8904f6820f7925779dcf6a8695eef85c558ea48fdb749c0dR1-R71))

### Configuration and Error Handling Improvements

* Improved error handling in config and persistence loading by including additional exception types (e.g., `JsonSerializationException`, `FileNotFoundException`) in catch blocks. (`src/LogExpert.Configuration/ConfigManager.cs` [[1]](diffhunk://#diff-82e64762f3f98762e436cfbe90148c10be3527395d43c7f4182c274020abb63cL810-R849) `src/LogExpert.Core/Classes/Persister/PersisterXML.cs` [[2]](diffhunk://#diff-344fe0500e61ba45bffd7be7db326b8af8860bfc091f9512646e25d7fd26ba39L604-R605)
* Added methods to manage file history in `ConfigManager`, including limiting history size and clearing the last open files list. (`src/LogExpert.Configuration/ConfigManager.cs` [[1]](diffhunk://#diff-82e64762f3f98762e436cfbe90148c10be3527395d43c7f4182c274020abb63cR49) [[2]](diffhunk://#diff-82e64762f3f98762e436cfbe90148c10be3527395d43c7f4182c274020abb63cR255-R291)

These changes collectively make project file handling more robust, user-friendly, and extensible, especially in environments with diverse file systems and potential for missing or relocated files.

Author: Hirogen

src/LogExpert.Configuration/ConfigManager.cs

@@ -46,6 +46,7 @@ public class ConfigManager : IConfigManager
     };
 
     private const string SETTINGS_FILE_NAME = "settings.json";
+    private const int MAX_FILE_HISTORY = 10;
 
     #endregion
 
@@ -251,6 +252,43 @@ public void ImportHighlightSettings (FileInfo fileInfo, ExportImportFlags import
         Save(SettingsFlags.All);
     }
 
+    /// <summary>
+    /// Adds the specified file name to the file history list, moving it to the top if it already exists.
+    /// </summary>
+    /// <remarks>If the file name already exists in the history, it is moved to the top of the list. The file
+    /// history list is limited to a maximum number of entries; the oldest entries are removed if the limit is exceeded.
+    /// This method is supported only on Windows platforms.</remarks>
+    /// <param name="fileName">The name of the file to add to the file history list. Comparison is case-insensitive.</param>
+    [SupportedOSPlatform("windows")]
+    public void AddToFileHistory (string fileName)
+    {
+        bool findName (string s) => s.ToUpperInvariant().Equals(fileName.ToUpperInvariant(), StringComparison.Ordinal);
+
+        var index = Instance.Settings.FileHistoryList.FindIndex(findName);
+
+        if (index != -1)
+        {
+            Instance.Settings.FileHistoryList.RemoveAt(index);
+        }
+
+        Instance.Settings.FileHistoryList.Insert(0, fileName);
+
+        while (Instance.Settings.FileHistoryList.Count > MAX_FILE_HISTORY)
+        {
+            Instance.Settings.FileHistoryList.RemoveAt(Instance.Settings.FileHistoryList.Count - 1);
+        }
+
+        Save(SettingsFlags.FileHistory);
+    }
+
+    public void ClearLastOpenFilesList ()
+    {
+        lock (_loadSaveLock)
+        {
+            Instance.Settings.LastOpenFilesList.Clear();
+        }
+    }
+
     #endregion
 
     #region Private Methods
@@ -807,7 +845,8 @@ IOException or
                                        NotSupportedException or
                                        PathTooLongException or
                                        UnauthorizedAccessException or
-                                       SecurityException)
+                                       SecurityException or
+                                       JsonSerializationException)
         {
             _logger.Error($"Error while deserializing config data: {e}");
             newGroups = [];
@@ -1060,6 +1099,7 @@ private bool ValidateSettings (Settings settings)
 
         return true;
     }
+
     #endregion
 
     /// <summary>

src/LogExpert.Core/Classes/Persister/PersisterHelpers.cs

@@ -0,0 +1,71 @@
+using System.Collections.ObjectModel;
+
+using LogExpert.Core.Interface;
+
+namespace LogExpert.Core.Classes.Persister;
+
+public static class PersisterHelpers
+{
+
+    private const string LOCAL_FILE_SYSTEM_NAME = "LocalFileSystem";
+
+    /// <summary>
+    /// Checks if the file name is a settings file (.lxp). If so, the contained logfile name
+    /// is returned. If not, the given file name is returned unchanged.
+    /// </summary>
+    /// <param name="fileName">The file name to resolve</param>
+    /// <param name="pluginRegistry">Plugin registry for file system resolution (optional)</param>
+    /// <returns>The resolved log file path</returns>
+    public static string FindFilenameForSettings (string fileName, IPluginRegistry pluginRegistry)
+    {
+        ArgumentException.ThrowIfNullOrWhiteSpace(fileName, nameof(fileName));
+
+        if (fileName.EndsWith(".lxp", StringComparison.OrdinalIgnoreCase))
+        {
+            var persistenceData = Persister.Load(fileName);
+            if (persistenceData == null)
+            {
+                return fileName;
+            }
+
+            if (!string.IsNullOrEmpty(persistenceData.FileName))
+            {
+                if (pluginRegistry != null)
+                {
+                    var fs = pluginRegistry.FindFileSystemForUri(persistenceData.FileName);
+                    // Use file system plugin for non-local files (network, SFTP, etc.)
+                    if (fs != null && fs.GetType().Name != LOCAL_FILE_SYSTEM_NAME)
+                    {
+                        return persistenceData.FileName;
+                    }
+                }
+
+                // Handle rooted paths (absolute paths)
+                if (Path.IsPathRooted(persistenceData.FileName))
+                {
+                    return persistenceData.FileName;
+                }
+
+                // Handle relative paths in .lxp files
+                var dir = Path.GetDirectoryName(fileName);
+                return Path.Join(dir, persistenceData.FileName);
+            }
+        }
+
+        return fileName;
+    }
+
+    public static ReadOnlyCollection<string> FindFilenameForSettings (ReadOnlyCollection<string> fileNames, IPluginRegistry pluginRegistry)
+    {
+        ArgumentNullException.ThrowIfNull(fileNames);
+
+        var foundFiles = new List<string>(fileNames.Count);
+
+        foreach (var fileName in fileNames)
+        {
+            foundFiles.Add(FindFilenameForSettings(fileName, pluginRegistry));
+        }
+
+        return foundFiles.AsReadOnly();
+    }
+}

src/LogExpert.Core/Classes/Persister/PersisterXML.cs

@@ -601,7 +601,8 @@ public static PersistenceData Load (string fileName)
         }
         catch (Exception xmlParsingException) when (xmlParsingException is XmlException or
                                                                            UnauthorizedAccessException or
-                                                                           IOException)
+                                                                           IOException or
+                                                                           FileNotFoundException)
         {
             _logger.Error(xmlParsingException, $"Error loading persistence data from {fileName}, unknown format, parsing xml or json was not possible");
             return null;

src/LogExpert.Core/Classes/Persister/ProjectData.cs

@@ -15,5 +15,10 @@ public class ProjectData
     /// </summary>
     public string TabLayoutXml { get; set; }
 
+    /// <summary>
+    /// Gets or sets the full file path to the project file.
+    /// </summary>
+    public string ProjectFilePath { get; set; }
+
     #endregion
 }

src/LogExpert.Core/Classes/Persister/ProjectFileResolver.cs

@@ -0,0 +1,34 @@
+using System.Collections.ObjectModel;
+
+using LogExpert.Core.Interface;
+
+namespace LogExpert.Core.Classes.Persister;
+
+/// <summary>
+/// Helper class to resolve project file references to actual log files.
+/// Handles .lxp (persistence) files by extracting the actual log file path.
+/// </summary>
+public static class ProjectFileResolver
+{
+    /// <summary>
+    /// Resolves project file names to actual log files.
+    /// If a file is a .lxp persistence file, extracts the log file path from it.
+    /// </summary>
+    /// <param name="projectData">The project data containing file references</param>
+    /// <param name="pluginRegistry">Plugin registry for file system resolution (optional)</param>
+    /// <returns>List of tuples containing (logFilePath, originalFilePath)</returns>
+    public static ReadOnlyCollection<(string LogFile, string OriginalFile)> ResolveProjectFiles (ProjectData projectData, IPluginRegistry pluginRegistry = null)
+    {
+        ArgumentNullException.ThrowIfNull(projectData);
+
+        var resolved = new List<(string LogFile, string OriginalFile)>();
+
+        foreach (var fileName in projectData.FileNames)
+        {
+            var logFile = PersisterHelpers.FindFilenameForSettings(fileName, pluginRegistry);
+            resolved.Add((logFile, fileName));
+        }
+
+        return resolved.AsReadOnly();
+    }
+}