Feature: Auto reload, refactoring & export hosts

Author: BornToBeRoot

Source/NETworkManager.Models/Export/ExportManager.HostsFileEntry.cs

@@ -0,0 +1,98 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Xml.Linq;
+using NETworkManager.Models.HostsFileEditor;
+using Newtonsoft.Json;
+
+namespace NETworkManager.Models.Export;
+
+public static partial class ExportManager
+{
+    /// <summary>
+    ///     Method to export objects from type <see cref="HostsFileEntry" /> to a file.
+    /// </summary>
+    /// <param name="filePath">Path to the export file.</param>
+    /// <param name="fileType">Allowed <see cref="ExportFileType" /> are CSV, XML or JSON.</param>
+    /// <param name="collection">Objects as <see cref="IReadOnlyList{HostsFileEntry}" /> to export.</param>
+    public static void Export(string filePath, ExportFileType fileType, IReadOnlyList<HostsFileEntry> collection)
+    {
+        switch (fileType)
+        {
+            case ExportFileType.Csv:
+                CreateCsv(collection, filePath);
+                break;
+            case ExportFileType.Xml:
+                CreateXml(collection, filePath);
+                break;
+            case ExportFileType.Json:
+                CreateJson(collection, filePath);
+                break;
+            case ExportFileType.Txt:
+            default:
+                throw new ArgumentOutOfRangeException(nameof(fileType), fileType, null);
+        }
+    }
+
+    /// <summary>
+    ///     Creates a CSV file from the given <see cref="HostsFileEntry" /> collection.
+    /// </summary>
+    /// <param name="collection">Objects as <see cref="IReadOnlyList{HostsFileEntry}" /> to export.</param>
+    /// <param name="filePath">Path to the export file.</param>
+    private static void CreateCsv(IEnumerable<HostsFileEntry> collection, string filePath)
+    {
+        var stringBuilder = new StringBuilder();
+
+        stringBuilder.AppendLine(
+            $"{nameof(HostsFileEntry.IsEnabled)},{nameof(HostsFileEntry.IPAddress)},{nameof(HostsFileEntry.Hostname)},{nameof(HostsFileEntry.Comment)}");
+
+        foreach (var info in collection)
+            stringBuilder.AppendLine($"{info.IsEnabled},{info.IPAddress},{info.Hostname},{info.Comment}");
+
+        File.WriteAllText(filePath, stringBuilder.ToString());
+    }
+
+    /// <summary>
+    ///     Creates a XML file from the given <see cref="HostsFileEntry" /> collection.
+    /// </summary>
+    /// <param name="collection">Objects as <see cref="IReadOnlyList{HostsFileEntry}" /> to export.</param>
+    /// <param name="filePath">Path to the export file.</param>
+    private static void CreateXml(IEnumerable<HostsFileEntry> collection, string filePath)
+    {
+        var document = new XDocument(DefaultXDeclaration,
+            new XElement(ApplicationName.HostsFileEditor.ToString(),
+                new XElement(nameof(HostsFileEntry) + "s",
+                    from info in collection
+                    select
+                        new XElement(nameof(HostsFileEntry),
+                            new XElement(nameof(HostsFileEntry.IsEnabled), info.IsEnabled),
+                            new XElement(nameof(HostsFileEntry.IPAddress), info.IPAddress),
+                            new XElement(nameof(HostsFileEntry.Hostname), info.Hostname),
+                            new XElement(nameof(HostsFileEntry.Comment), info.Comment)))));
+
+        document.Save(filePath);
+    }
+
+    /// <summary>
+    ///     Creates a JSON file from the given <see cref="HostsFileEntry" /> collection.
+    /// </summary>
+    /// <param name="collection">Objects as <see cref="IReadOnlyList{HostsFileEntry}" /> to export.</param>
+    /// <param name="filePath">Path to the export file.</param>
+    private static void CreateJson(IReadOnlyList<HostsFileEntry> collection, string filePath)
+    {
+        var jsonData = new object[collection.Count];
+
+        for (var i = 0; i < collection.Count; i++)
+            jsonData[i] = new
+            {
+                collection[i].IsEnabled,
+                collection[i].IPAddress,
+                collection[i].Hostname,
+                collection[i].Comment
+            };
+
+        File.WriteAllText(filePath, JsonConvert.SerializeObject(jsonData, Formatting.Indented));
+    }
+}

Source/NETworkManager.Models/HostsFileEditor/HostsFileEditor.cs

@@ -107,7 +107,7 @@ private static IEnumerable<HostsFileEntry> GetHostsFileEntries()
                     IsEnabled = !result.Groups[1].Value.Equals("#"),
                     IPAddress = result.Groups[2].Value,
                     Hostname = result.Groups[3].Value.Replace(@"\s", "").Trim(),
-                    Comment = result.Groups[4].Value.TrimStart('#'),
+                    Comment = result.Groups[4].Value.TrimStart('#',' '),
                     Line = line
                 };
 

Source/NETworkManager.Settings/GlobalStaticConfiguration.cs

@@ -19,12 +19,15 @@ public static class GlobalStaticConfiguration
 {
     #region Global settings
 
+    // Application config
+    public static int ApplicationUIRefreshInterval => 2500;
+    
     // Type to search (average type speed --> 187 chars/min)
     public static TimeSpan SearchDispatcherTimerTimeSpan => new(0, 0, 0, 0, 750);
 
     // Network config
     public static int NetworkChangeDetectionDelay => 5000;
-
+    
     // Profile config
     public static bool Profile_ExpandProfileView => true;
     public static double Profile_WidthCollapsed => 40;
@@ -219,6 +222,9 @@ public static class GlobalStaticConfiguration
     // Application: SNTP Lookup
     public static int SNTPLookup_Timeout => 4000;
     public static ExportFileType SNTPLookup_ExportFileType => ExportFileType.Csv;
+    
+    // Application: Hosts File Editor
+    public static ExportFileType HostsFileEditor_ExportFileType => ExportFileType.Csv;
 
     // Application: Discovery Protocol
     public static DiscoveryProtocol DiscoveryProtocol_Protocol => DiscoveryProtocol.LldpCdp;

Source/NETworkManager.Settings/SettingsInfo.cs

@@ -3584,7 +3584,7 @@ public ExportFileType SNMP_ExportFileType
 
     #region SNTP Lookup
 
-    private ObservableCollection<ServerConnectionInfoProfile> _sntpLookup_SNTPServers = new();
+    private ObservableCollection<ServerConnectionInfoProfile> _sntpLookup_SNTPServers = [];
 
     public ObservableCollection<ServerConnectionInfoProfile> SNTPLookup_SNTPServers
     {
@@ -3660,6 +3660,40 @@ public ExportFileType SNTPLookup_ExportFileType
     }
 
     #endregion
+    
+    #region Hosts File Editor
+    
+     private string _hostsFileEditor_ExportFilePath;
+    
+        public string HostsFileEditor_ExportFilePath
+        {
+            get => _hostsFileEditor_ExportFilePath;
+            set
+            {
+                if (value == _hostsFileEditor_ExportFilePath)
+                    return;
+    
+                _hostsFileEditor_ExportFilePath = value;
+                OnPropertyChanged();
+            }
+        }
+    
+        private ExportFileType _hostsFileEditor_ExportFileType = GlobalStaticConfiguration.HostsFileEditor_ExportFileType;
+    
+        public ExportFileType HostsFileEditor_ExportFileType
+        {
+            get => _hostsFileEditor_ExportFileType;
+            set
+            {
+                if (value == _hostsFileEditor_ExportFileType)
+                    return;
+    
+                _hostsFileEditor_ExportFileType = value;
+                OnPropertyChanged();
+            }
+        }
+    
+    #endregion
 
     #region Discovery Protocol
 

Source/NETworkManager/ViewModels/AWSSessionManagerHostViewModel.cs

@@ -650,7 +650,7 @@ private async Task SyncAllInstanceIDsFromAWS()
         }
 
         // Make the user happy, let him see a reload animation (and he cannot spam the reload command)        
-        await Task.Delay(2500);
+        await Task.Delay(GlobalStaticConfiguration.ApplicationUIRefreshInterval);
 
         Log.Info("All Instance IDs synced from AWS!");
 
@@ -679,7 +679,7 @@ private async Task SyncGroupInstanceIDsFromAWS(string group)
         }
 
         // Make the user happy, let him see a reload animation (and he cannot spam the reload command)        
-        await Task.Delay(2500);
+        await Task.Delay(GlobalStaticConfiguration.ApplicationUIRefreshInterval);
 
         Log.Info("Group synced!");
 

Source/NETworkManager/ViewModels/HostsFileEditorViewModel.cs

@@ -172,9 +172,6 @@ public HostsFileEditorViewModel(IDialogCoordinator instance)
         // Watch hosts file for changes
         HostsFileEditor.HostsFileChanged += (_, _) =>
         {
-            StatusMessage = "Refreshing...";
-            IsStatusMessageDisplayed = true;
-            
             Application.Current.Dispatcher.Invoke(() =>
             {
                 Refresh().ConfigureAwait(false);
@@ -203,11 +200,54 @@ private bool Refresh_CanExecute(object parameter)
 
     private async Task RefreshAction()
     {
-        StatusMessage = "Refreshing...";
-        IsStatusMessageDisplayed = true;
-
         await Refresh();
     }
+  
+    public ICommand ExportCommand => new RelayCommand(_ => ExportAction().ConfigureAwait(false));
+    
+    private async Task ExportAction()
+    {
+        var customDialog = new CustomDialog
+        {
+            Title = Strings.Export
+        };
+
+        var exportViewModel = new ExportViewModel(async instance =>
+        {
+            await _dialogCoordinator.HideMetroDialogAsync(this, customDialog);
+
+            try
+            {
+               ExportManager.Export(instance.FilePath, instance.FileType,
+                    instance.ExportAll
+                        ? Results
+                        : new ObservableCollection<HostsFileEntry>(SelectedResults.Cast<HostsFileEntry>().ToArray()));
+            }
+            catch (Exception ex)
+            {
+                Log.Error("Error while exporting data as " + instance.FileType, ex);
+                
+                var settings = AppearanceManager.MetroDialog;
+                settings.AffirmativeButtonText = Strings.OK;
+
+                await _dialogCoordinator.ShowMessageAsync(this, Strings.Error,
+                    Strings.AnErrorOccurredWhileExportingTheData + Environment.NewLine +
+                    Environment.NewLine + ex.Message, MessageDialogStyle.Affirmative, settings);
+            }
+
+            SettingsManager.Current.HostsFileEditor_ExportFileType = instance.FileType;
+            SettingsManager.Current.HostsFileEditor_ExportFilePath = instance.FilePath;
+        }, _ => { _dialogCoordinator.HideMetroDialogAsync(this, customDialog); }, [
+            ExportFileType.Csv, ExportFileType.Xml, ExportFileType.Json
+        ], true, SettingsManager.Current.HostsFileEditor_ExportFileType, SettingsManager.Current.HostsFileEditor_ExportFilePath);
+
+        customDialog.Content = new ExportDialog
+        {
+            DataContext = exportViewModel
+        };
+
+        await _dialogCoordinator.ShowMetroDialogAsync(this, customDialog);
+    }
 
     public ICommand RestartAsAdminCommand => new RelayCommand(_ => RestartAsAdminAction().ConfigureAwait(false));
 
@@ -233,19 +273,47 @@ private async Task Refresh(bool init = false)
             return;
 
         IsRefreshing = true;
+        
+        // Retry 3 times if the hosts file is locked
+        for (var i = 1; i < 4; i++)
+        {
+            // Wait for 2.5 seconds on refresh
+            if (init == false || i > 1)
+            {
+                StatusMessage = "Refreshing...";
+                IsStatusMessageDisplayed = true;
+                
+                await Task.Delay(GlobalStaticConfiguration.ApplicationUIRefreshInterval);
+            }
 
-        if (!init)
-            await Task.Delay(2500);
+            try
+            {
+                var entries = await HostsFileEditor.GetHostsFileEntriesAsync();
+                
+                Results.Clear();
+                
+                entries.ToList().ForEach(Results.Add);
+
+                StatusMessage = "Reloaded at " + DateTime.Now.ToShortTimeString();
+                IsStatusMessageDisplayed = true;
+                
+                break;
+            }
+            catch (Exception ex)
+            {
+                Log.Error(ex);
+                
+                StatusMessage = "Failed to reload hosts file: " + ex.Message;
 
-        Results.Clear();
-       
-        // Todo: try catch + Re-try count and delay
-        
-        (await HostsFileEditor.GetHostsFileEntriesAsync()).ToList().ForEach(Results.Add);
-        
-        StatusMessage = "Reloaded at " + DateTime.Now.ToShortTimeString();
-        IsStatusMessageDisplayed = true;
+                if (i < 3)
+                    StatusMessage += Environment.NewLine + "Retrying in 2.5 seconds...";
 
+                IsStatusMessageDisplayed = true;
+                
+                await Task.Delay(GlobalStaticConfiguration.ApplicationUIRefreshInterval);
+            }
+        }
+        
         IsRefreshing = false;
     }
 

Source/NETworkManager/ViewModels/IPApiDNSResolverWidgetViewModel.cs

@@ -88,7 +88,7 @@ private async Task CheckAsync()
         Result = null;
 
         // Make the user happy, let him see a reload animation (and he cannot spam the reload command)        
-        await Task.Delay(2500);
+        await Task.Delay(GlobalStaticConfiguration.ApplicationUIRefreshInterval);
 
         Result = await DNSResolverService.GetInstance().GetDNSResolverAsync();
 

Source/NETworkManager/ViewModels/IPApiIPGeolocationWidgetViewModel.cs

@@ -90,7 +90,7 @@ private async Task CheckAsync()
         Result = null;
 
         // Make the user happy, let him see a reload animation (and he cannot spam the reload command)        
-        await Task.Delay(2500);
+        await Task.Delay(GlobalStaticConfiguration.ApplicationUIRefreshInterval);
 
         Result = await IPGeolocationService.GetInstance().GetIPGeolocationAsync();
 

Source/NETworkManager/ViewModels/NetworkInterfaceViewModel.cs

@@ -938,16 +938,14 @@ private async Task RemoveIPv4AddressAction()
 
     private async void ReloadNetworkInterfaces()
     {
-        Debug.WriteLine("ReloadNetworkInterfaces.............");
-        
         // Avoid multiple reloads
         if(IsNetworkInterfaceLoading)
             return;
 
         IsNetworkInterfaceLoading = true;
 
         // Make the user happy, let him see a reload animation (and he cannot spam the reload command)
-        await Task.Delay(2500);
+        await Task.Delay(GlobalStaticConfiguration.ApplicationUIRefreshInterval);
 
         // Store the last selected id
         var id = SelectedNetworkInterface?.Id ?? string.Empty;

Source/NETworkManager/ViewModels/SettingsAutostartViewModel.cs

@@ -47,7 +47,7 @@ private async Task EnableDisableAutostart(bool enable)
                 await AutostartManager.DisableAsync();
 
             // Make the user happy, let him see a reload animation (and he cannot spam the reload command)
-            await Task.Delay(2500);
+            await Task.Delay(GlobalStaticConfiguration.ApplicationUIRefreshInterval);
         }
         catch (Exception ex)
         {