impala 0.7.1

TUI for managing wifi
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92

use anyhow::Result;
use chrono::{DateTime, FixedOffset};

use iwdrs::{known_network::KnownNetwork as iwdKnownNetwork, network::NetworkType};

use tokio::sync::mpsc::UnboundedSender;

use crate::{
    event::Event,
    notification::{Notification, NotificationLevel},
};

#[derive(Debug, Clone)]
pub struct KnownNetwork {
    pub n: iwdKnownNetwork,
    pub name: String,
    pub network_type: NetworkType,
    pub is_autoconnect: bool,
    pub is_hidden: bool,
    pub last_connected: Option<DateTime<FixedOffset>>,
}

impl KnownNetwork {
    pub async fn new(n: iwdKnownNetwork) -> Result<Self> {
        let name = n.name().await?;
        let network_type = n.network_type().await?;
        let is_autoconnect = n.get_autoconnect().await?;
        let is_hidden = n.hidden().await?;
        let last_connected = match n.last_connected_time().await {
            Ok(v) => DateTime::parse_from_rfc3339(&v).ok(),
            Err(_) => None,
        };

        Ok(Self {
            n,
            name,
            network_type,
            is_autoconnect,
            is_hidden,
            last_connected,
        })
    }

    pub async fn forget(&self, sender: UnboundedSender<Event>) -> Result<()> {
        match self.n.forget().await {
            Ok(()) => {
                let _ = Notification::send(
                    format!("The Network {} is removed", self.name),
                    NotificationLevel::Info,
                    &sender,
                );
            }
            Err(e) => {
                let _ =
                    Notification::send(e.to_string(), NotificationLevel::Error, &sender.clone());
            }
        }

        Ok(())
    }

    pub async fn toggle_autoconnect(&self, sender: UnboundedSender<Event>) -> Result<()> {
        if self.is_autoconnect {
            match self.n.set_autoconnect(false).await {
                Ok(()) => {
                    Notification::send(
                        format!("Disable Autoconnect for: {}", self.name),
                        NotificationLevel::Info,
                        &sender.clone(),
                    )?;
                }
                Err(e) => {
                    Notification::send(e.to_string(), NotificationLevel::Error, &sender.clone())?;
                }
            }
        } else {
            match self.n.set_autoconnect(true).await {
                Ok(()) => {
                    Notification::send(
                        format!("Enable Autoconnect for: {}", self.name),
                        NotificationLevel::Info,
                        &sender.clone(),
                    )?;
                }
                Err(e) => {
                    Notification::send(e.to_string(), NotificationLevel::Error, &sender.clone())?;
                }
            }
        }
        Ok(())
    }
}