feat: improve IP blacklist import feedback

TheMasterOfDisasters · TheMasterOfDisasters · commit 51e03967f4c6 · 2026-05-08T02:46:13.000+02:00
diff --git a/src/gui/pages/settings_general_page.rs b/src/gui/pages/settings_general_page.rs
@@ -15,14 +15,18 @@ use crate::gui::styles::text::TextType;
 use crate::gui::types::message::Message;
 use crate::gui::types::settings::Settings;
 use crate::mmdb::types::mmdb_reader::{MmdbReader, MmdbReaders};
-use crate::networking::types::ip_blacklist::IpBlacklist;
+use crate::networking::types::ip_blacklist::{IpBlacklist, IpBlacklistLoadStatus};
 use crate::translations::translations::language_translation;
 use crate::translations::translations_2::country_translation;
 use crate::translations::translations_3::{
     mmdb_files_translation, params_not_editable_translation, zoom_translation,
 };
 use crate::translations::translations_4::share_feedback_translation;
-use crate::translations::translations_5::ip_blacklist_translation;
+use crate::translations::translations_5::{
+    ip_blacklist_file_read_error_translation, ip_blacklist_loaded_translation,
+    ip_blacklist_loading_translation, ip_blacklist_no_valid_entries_translation,
+    ip_blacklist_not_selected_translation, ip_blacklist_translation,
+};
 use crate::utils::formatted_strings::get_path_termination_string;
 use crate::utils::types::file_info::FileInfo;
 use crate::utils::types::icon::Icon;
@@ -331,6 +335,8 @@ fn blacklist_selection<'a>(
     };
 
     let message = Message::LoadIpBlacklist;
+    let status = blacklist_status_text(custom_path, ip_blacklist, language);
+    let status_text_type = blacklist_status_text_type(ip_blacklist);
 
     Column::new()
         .width(Length::Fill)
@@ -363,6 +369,44 @@ fn blacklist_selection<'a>(
                     button_clear_mmdb(message, is_editable)
                 }),
         )
+        .push(Text::new(status).class(status_text_type).size(12))
+}
+
+fn blacklist_status_text(
+    custom_path: &str,
+    ip_blacklist: &IpBlacklist,
+    language: Language,
+) -> String {
+    if custom_path.is_empty() {
+        return ip_blacklist_not_selected_translation(language).to_string();
+    }
+
+    match ip_blacklist.status() {
+        IpBlacklistLoadStatus::NotSelected => {
+            ip_blacklist_not_selected_translation(language).to_string()
+        }
+        IpBlacklistLoadStatus::Loading => ip_blacklist_loading_translation(language).to_string(),
+        IpBlacklistLoadStatus::FileReadError => {
+            ip_blacklist_file_read_error_translation(language).to_string()
+        }
+        IpBlacklistLoadStatus::NoValidEntries { .. } => {
+            ip_blacklist_no_valid_entries_translation(language).to_string()
+        }
+        IpBlacklistLoadStatus::Loaded {
+            ip_count,
+            network_count,
+            ..
+        } => ip_blacklist_loaded_translation(language, *ip_count, *network_count),
+    }
+}
+
+fn blacklist_status_text_type(ip_blacklist: &IpBlacklist) -> TextType {
+    match ip_blacklist.status() {
+        IpBlacklistLoadStatus::FileReadError | IpBlacklistLoadStatus::NoValidEntries { .. } => {
+            TextType::Danger
+        }
+        _ => TextType::Standard,
+    }
 }
 
 fn button_clear_mmdb<'a>(
diff --git a/src/networking/types/ip_blacklist.rs b/src/networking/types/ip_blacklist.rs
@@ -5,20 +5,40 @@ use std::sync::Arc;
 use ipnet::IpNet;
 use prefix_trie::joint::set::JointPrefixSet;
 
+#[derive(Clone, Debug, Default, PartialEq, Eq)]
+pub enum IpBlacklistLoadStatus {
+    #[default]
+    NotSelected,
+    Loading,
+    Loaded {
+        ip_count: usize,
+        network_count: usize,
+        ignored_lines: usize,
+    },
+    FileReadError,
+    NoValidEntries {
+        ignored_lines: usize,
+    },
+}
+
 #[derive(Clone, Default, Debug)]
 pub struct IpBlacklist {
     ips: Arc<HashSet<IpAddr>>,
     networks: Arc<JointPrefixSet<IpNet>>,
-    is_loading: bool,
+    status: IpBlacklistLoadStatus,
 }
 
 impl IpBlacklist {
     pub async fn from_file(path: String) -> Self {
         let Ok(buf) = tokio::fs::read_to_string(&path).await else {
-            return IpBlacklist::default();
+            return IpBlacklist {
+                status: IpBlacklistLoadStatus::FileReadError,
+                ..IpBlacklist::default()
+            };
         };
         let mut ips = HashSet::new();
         let mut networks = JointPrefixSet::new();
+        let mut ignored_lines = 0;
         for line in buf.lines() {
             let Some(first) = line.split_whitespace().next() else {
                 continue;
@@ -28,12 +48,26 @@ impl IpBlacklist {
                 ips.insert(ip);
             } else if let Ok(network) = first.parse::<IpNet>() {
                 networks.insert(network);
+            } else {
+                ignored_lines += 1;
             }
         }
+        let ip_count = ips.len();
+        let network_count = networks.len();
+        let status = if ip_count == 0 && network_count == 0 {
+            IpBlacklistLoadStatus::NoValidEntries { ignored_lines }
+        } else {
+            IpBlacklistLoadStatus::Loaded {
+                ip_count,
+                network_count,
+                ignored_lines,
+            }
+        };
+
         IpBlacklist {
             ips: Arc::new(ips),
             networks: Arc::new(networks),
-            is_loading: false,
+            status,
         }
     }
 
@@ -42,15 +76,22 @@ impl IpBlacklist {
     }
 
     pub fn is_invalid(&self) -> bool {
-        self.ips.is_empty() && self.networks.is_empty() && !self.is_loading
+        matches!(
+            self.status,
+            IpBlacklistLoadStatus::FileReadError | IpBlacklistLoadStatus::NoValidEntries { .. }
+        )
     }
 
     pub fn is_loading(&self) -> bool {
-        self.is_loading
+        matches!(self.status, IpBlacklistLoadStatus::Loading)
+    }
+
+    pub fn status(&self) -> &IpBlacklistLoadStatus {
+        &self.status
     }
 
     pub fn start_loading(&mut self) {
-        self.is_loading = true;
+        self.status = IpBlacklistLoadStatus::Loading;
     }
 }
 
@@ -68,6 +109,14 @@ mod tests {
         assert!(!blacklist.is_loading());
         assert_eq!(blacklist.ips.len(), 4);
         assert_eq!(blacklist.networks.len(), 0);
+        assert_eq!(
+            blacklist.status(),
+            &IpBlacklistLoadStatus::Loaded {
+                ip_count: 4,
+                network_count: 0,
+                ignored_lines: 4,
+            }
+        );
 
         assert!(blacklist.contains(&IpAddr::V4(Ipv4Addr::new(8, 8, 8, 8))));
         assert!(blacklist.contains(&IpAddr::V4(Ipv4Addr::new(1, 2, 3, 255))));
@@ -89,6 +138,10 @@ mod tests {
         assert!(!blacklist.is_loading());
         assert_eq!(blacklist.ips.len(), 0);
         assert_eq!(blacklist.networks.len(), 0);
+        assert_eq!(
+            blacklist.status(),
+            &IpBlacklistLoadStatus::NoValidEntries { ignored_lines: 6 }
+        );
 
         assert!(!blacklist.contains(&IpAddr::V4(Ipv4Addr::new(8, 8, 8, 8))));
         assert!(!blacklist.contains(&IpAddr::V4(Ipv4Addr::new(0, 0, 0, 0))));
@@ -106,6 +159,14 @@ mod tests {
         assert!(!blacklist.is_loading());
         assert_eq!(blacklist.ips.len(), 2);
         assert_eq!(blacklist.networks.len(), 4);
+        assert_eq!(
+            blacklist.status(),
+            &IpBlacklistLoadStatus::Loaded {
+                ip_count: 2,
+                network_count: 4,
+                ignored_lines: 3,
+            }
+        );
 
         assert!(blacklist.contains(&IpAddr::V4(Ipv4Addr::new(8, 8, 8, 8))));
         assert!(blacklist.contains(&"2001:db8::1".parse::<IpAddr>().unwrap()));
@@ -137,6 +198,14 @@ mod tests {
         assert!(!blacklist.is_loading());
         assert_eq!(blacklist.ips.len(), 0);
         assert_eq!(blacklist.networks.len(), 1);
+        assert_eq!(
+            blacklist.status(),
+            &IpBlacklistLoadStatus::Loaded {
+                ip_count: 0,
+                network_count: 1,
+                ignored_lines: 0,
+            }
+        );
 
         assert!(blacklist.contains(&IpAddr::V4(Ipv4Addr::new(1, 2, 3, 1))));
         assert!(!blacklist.contains(&IpAddr::V4(Ipv4Addr::new(1, 2, 4, 1))));
@@ -170,4 +239,28 @@ mod tests {
         assert!(!blacklist.contains(&IpAddr::V4(Ipv4Addr::new(209, 186, 237, 0))));
         assert!(!blacklist.contains(&IpAddr::V4(Ipv4Addr::new(209, 233, 160, 0))));
     }
+
+    #[tokio::test]
+    async fn test_ip_blacklist_read_error() {
+        let blacklist =
+            IpBlacklist::from_file("resources/test/does_not_exist_blacklist.txt".to_string()).await;
+
+        assert!(blacklist.is_invalid());
+        assert!(!blacklist.is_loading());
+        assert_eq!(blacklist.ips.len(), 0);
+        assert_eq!(blacklist.networks.len(), 0);
+        assert_eq!(blacklist.status(), &IpBlacklistLoadStatus::FileReadError);
+        assert!(!blacklist.contains(&IpAddr::V4(Ipv4Addr::new(8, 8, 8, 8))));
+    }
+
+    #[test]
+    fn test_ip_blacklist_loading_status() {
+        let mut blacklist = IpBlacklist::default();
+
+        blacklist.start_loading();
+
+        assert!(blacklist.is_loading());
+        assert!(!blacklist.is_invalid());
+        assert_eq!(blacklist.status(), &IpBlacklistLoadStatus::Loading);
+    }
 }
diff --git a/src/translations/translations_5.rs b/src/translations/translations_5.rs
