Merge pull request 'Reintroduce status and power-related templates and routes' (#140) from refactor_stats into main

Reviewed-on: #140

Cargo.lock

@@ -1078,8 +1078,8 @@ dependencies = [
 
 [[package]]
 name = "golgi"
-version = "0.2.2"
-source = "git+https://git.coopcloud.tech/golgi-ssb/golgi.git#22d12f31ac37a05ec5db6e62bc667bb006fc31fd"
+version = "0.2.4"
+source = "git+https://git.coopcloud.tech/golgi-ssb/golgi.git#9981b64bb23e1dbb95e31cfa1c545d23bb4f40d2"
 dependencies = [
  "async-std",
  "async-stream 0.3.3",
@@ -1610,7 +1610,7 @@ dependencies = [
 [[package]]
 name = "kuska-ssb"
 version = "0.4.1"
-source = "git+https://github.com/Kuska-ssb/ssb#6b0457a8ddd0e86a8f84cffac2b5cb835723822f"
+source = "git+https://github.com/Kuska-ssb/ssb#315c7e31aa6255d5657665ce9357034113d2b552"
 dependencies = [
  "async-std",
  "async-stream 0.2.1",
@@ -2200,7 +2200,7 @@ dependencies = [
 
 [[package]]
 name = "peach-config"
-version = "0.1.26"
+version = "0.1.27"
 dependencies = [
  "async-std",
  "clap",
@@ -2293,7 +2293,7 @@ dependencies = [
 
 [[package]]
 name = "peach-network"
-version = "0.4.2"
+version = "0.5.0"
 dependencies = [
  "get_if_addrs",
  "miniserde",
@@ -2333,7 +2333,7 @@ dependencies = [
 
 [[package]]
 name = "peach-web"
-version = "0.6.19"
+version = "0.6.21"
 dependencies = [
  "async-std",
  "base64 0.13.0",
@@ -2346,8 +2346,11 @@ dependencies = [
  "log 0.4.17",
  "maud",
  "peach-lib",
+ "peach-network",
+ "peach-stats",
  "rouille",
  "temporary",
+ "vnstat_parse",
  "xdg",
 ]
 
@@ -2407,7 +2410,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f77e66f6d6d898cbbd4a09c48fd3507cfc210b7c83055de02a38b5f7a1e6d216"
 dependencies = [
  "libc",
- "time 0.1.44",
+ "time 0.3.11",
 ]
 
 [[package]]
@@ -3813,6 +3816,12 @@ version = "0.9.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "49874b5167b65d7193b8aba1567f5c7d93d001cafc34600cee003eda787e483f"
 
+[[package]]
+name = "vnstat_parse"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "75334377a2918b45b5b8da023080375a4ec0aa04b0bc88f896ea93cf4b32feff"
+
 [[package]]
 name = "void"
 version = "1.0.2"

peach-config/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "peach-config"
-version = "0.1.26"
+version = "0.1.27"
 authors = ["Andrew Reid <gnomad@cryptolab.net>", "Max Fowler <max@mfowler.info>"]
 edition = "2018"
 description = "Command line tool for installing, updating and configuring PeachCloud"

peach-config/src/error.rs

@@ -42,6 +42,8 @@ pub enum PeachConfigError {
     Golgi { source: GolgiError },
     #[snafu(display("{}", message))]
     CmdInputError { message: String },
+    #[snafu(display("{}", message))]
+    WaitForSbotError { message: String },
 }
 
 impl From<std::io::Error> for PeachConfigError {

peach-config/src/main.rs

@@ -10,6 +10,7 @@ mod setup_peach_deb;
 mod status;
 mod update;
 mod utils;
+mod wait_for_sbot;
 
 use clap::arg_enum;
 use log::error;
@@ -61,6 +62,10 @@ enum PeachConfig {
     /// It takes an address argument of the form host:port
     #[structopt(name = "publish-address")]
     PublishAddress(PublishAddressOpts),
+
+    /// Wait for a successful connection to sbot
+    #[structopt(name = "wait-for-sbot")]
+    WaitForSbot,
 }
 
 #[derive(StructOpt, Debug)]
@@ -193,6 +198,14 @@ async fn run() {
                     }
                 }
             }
+            PeachConfig::WaitForSbot => match wait_for_sbot::wait_for_sbot().await {
+                Ok(sbot_id) => {
+                    println!("connected with sbot and found sbot_id: {:?}", sbot_id)
+                }
+                Err(err) => {
+                    error!("peach-config did not successfully connect to sbot: {}", err)
+                }
+            },
         }
     }
 }

peach-config/src/wait_for_sbot.rs

@@ -0,0 +1,52 @@
+use std::{thread, time};
+
+use crate::error::PeachConfigError;
+use peach_lib::sbot::init_sbot;
+
+static MAX_NUM_ATTEMPTS: u8 = 10;
+
+/// Utility function to wait for a successful whoami call with sbot
+/// After each attempt to call whoami it waits 2 seconds,
+/// and if after MAX_NUM_ATTEMPTS (10) there is no successful whoami call
+/// it returns an Error. Otherwise it returns Ok(sbot_id).
+pub async fn wait_for_sbot() -> Result<String, PeachConfigError> {
+    let mut num_attempts = 0;
+    let mut whoami = None;
+
+    while num_attempts < MAX_NUM_ATTEMPTS {
+        let mut sbot = None;
+
+        let sbot_res = init_sbot().await;
+        match sbot_res {
+            Ok(sbot_instance) => {
+                sbot = Some(sbot_instance);
+            }
+            Err(err) => {
+                eprintln!("failed to connect to sbot: {:?}", err);
+            }
+        }
+
+        if sbot.is_some() {
+            let sbot_id_res = sbot.unwrap().whoami().await;
+            match sbot_id_res {
+                Ok(sbot_id) => {
+                    whoami = Some(sbot_id);
+                    break;
+                }
+                Err(err) => {
+                    eprintln!("whoami failed: {:?}", err);
+                }
+            }
+        }
+
+        println!("trying to connect to sbot again {:?}", num_attempts);
+        num_attempts += 1;
+
+        let sleep_duration = time::Duration::from_secs(2);
+        thread::sleep(sleep_duration);
+    }
+
+    whoami.ok_or(PeachConfigError::WaitForSbotError {
+        message: "Failed to find sbot_id after 10 attempts".to_string(),
+    })
+}

peach-network/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "peach-network"
-version = "0.4.2"
+version = "0.5.0"
 authors = ["Andrew Reid <glyph@mycelial.technology>"]
 edition = "2021"
 description = "Query and configure network interfaces."

peach-network/src/network.rs

@@ -14,6 +14,7 @@
 //! access point credentials to `wpa_supplicant-<wlan_iface>.conf`.
 
 use std::{
+    collections::HashMap,
     fs::OpenOptions,
     io::prelude::*,
     process::{Command, Stdio},
@@ -106,8 +107,86 @@ pub struct Traffic {
     pub transmitted: u64,
 }
 
+/// Access point data including state and signal strength.
+#[derive(Debug)]
+#[cfg_attr(feature = "miniserde_support", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "serde_support", derive(Serialize, Deserialize))]
+pub struct AccessPoint {
+    /// Access point data retrieved via scan.
+    pub detail: Option<Scan>,
+    /// Current state of the access point (e.g. "Available" or "Out of range").
+    pub state: String,
+    /// Signal strength of the access point as a percentage.
+    pub signal: Option<i32>,
+}
+
+impl AccessPoint {
+    fn available(detail: Option<Scan>, signal: Option<i32>) -> AccessPoint {
+        AccessPoint {
+            detail,
+            state: String::from("Available"),
+            signal,
+        }
+    }
+
+    fn saved() -> AccessPoint {
+        AccessPoint {
+            detail: None,
+            state: String::from("Out of range"),
+            signal: None,
+        }
+    }
+}
+
 /* GET - Methods for retrieving data */
 
+/// Retrieve combined list of available (in-range) and saved wireless access
+/// points for a given network interface.
+///
+/// # Arguments
+///
+/// * `iface` - A string slice holding the name of a wireless network interface
+///
+/// If the list results include one or more access points for the given network
+/// interface, an `Ok` `Result` type is returned containing `HashMap<String,
+/// AccessPoint>`.
+///
+/// Each entry in the returned `HashMap` contains an SSID (`String`) and
+/// `AccessPoint` `struct`. If no access points are found, an empty `HashMap`
+/// is returned in the `Result`. In the event of an error, a `NetworkError`
+/// is returned in the `Result`.
+pub fn all_networks(iface: &str) -> Result<HashMap<String, AccessPoint>, NetworkError> {
+    let mut wlan_networks = HashMap::new();
+
+    if let Ok(Some(networks)) = available_networks(iface) {
+        for ap in networks {
+            let ssid = ap.ssid.clone();
+
+            let rssi = ap.signal_level.clone();
+            // parse the string to a signed integer (for math)
+            let rssi_parsed = rssi.parse::<i32>().unwrap();
+            // perform rssi (dBm) to quality (%) conversion
+            let quality_percent = 2 * (rssi_parsed + 100);
+
+            let ap_detail = AccessPoint::available(Some(ap), Some(quality_percent));
+            wlan_networks.insert(ssid, ap_detail);
+        }
+    }
+
+    if let Ok(Some(networks)) = saved_networks() {
+        for saved_ssid in networks {
+            if !wlan_networks.contains_key(&saved_ssid) {
+                let ssid = saved_ssid.clone();
+
+                let ap_detail = AccessPoint::saved();
+                wlan_networks.insert(ssid, ap_detail);
+            }
+        }
+    }
+
+    Ok(wlan_networks)
+}
+
 /// Retrieve list of available wireless access points for a given network
 /// interface.
 ///

peach-web/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "peach-web"
-version = "0.6.19"
+version = "0.6.21"
 authors = ["Andrew Reid <gnomad@cryptolab.net>", "Max Fowler <max@mfowler.info>"]
 edition = "2018"
 description = "peach-web is a web application which provides a web interface for monitoring and interacting with the PeachCloud device. This allows administration of the single-board computer (ie. Raspberry Pi) running PeachCloud, as well as the ssb-server and related plugins."
@@ -44,9 +44,9 @@ lazy_static = "1.4"
 log = "0.4"
 maud = "0.23"
 peach-lib = { path = "../peach-lib" }
-# these will be reintroduced when the full peachcloud mode is added
-#peach-network = { path = "../peach-network" }
-#peach-stats = { path = "../peach-stats" }
+peach-network = { path = "../peach-network" }
+peach-stats = { path = "../peach-stats" }
 rouille = { version = "3.5", default-features = false }
 temporary = "0.6"
+vnstat_parse = "0.1.0"
 xdg = "2.2"

peach-web/src/main.rs

@@ -39,6 +39,12 @@ lazy_static! {
     static ref THEME: RwLock<Theme> = RwLock::new(Theme::Light);
 }
 
+/// Wireless interface identifier.
+pub const WLAN_IFACE: &str = "wlan0";
+
+/// Access point interface identifier.
+pub const AP_IFACE: &str = "ap0";
+
 /// Session data for each authenticated client.
 #[derive(Debug, Clone)]
 pub struct SessionData {

peach-web/src/private_router.rs

@@ -166,6 +166,18 @@ pub fn mount_peachpub_routes(
             routes::settings::admin::delete::handle_form(request)
         },
 
+        (GET) (/settings/power) => {
+            Response::html(routes::settings::power::menu::build_template(request))
+        },
+
+        (GET) (/settings/power/reboot) => {
+            routes::settings::power::reboot::handle_reboot()
+        },
+
+        (GET) (/settings/power/shutdown) => {
+            routes::settings::power::shutdown::handle_shutdown()
+        },
+
         (GET) (/settings/scuttlebutt) => {
             Response::html(routes::settings::scuttlebutt::menu::build_template(request))
                 .reset_flash()
@@ -200,14 +212,66 @@ pub fn mount_peachpub_routes(
             routes::settings::scuttlebutt::default::write_config()
         },
 
+        (GET) (/settings/network) => {
+            Response::html(routes::settings::network::menu::build_template(request)).reset_flash()
+        },
+
+        (GET) (/settings/network/dns) => {
+            Response::html(routes::settings::network::configure_dns::build_template(request)).reset_flash()
+        },
+
+        (POST) (/settings/network/dns) => {
+            routes::settings::network::configure_dns::handle_form(request)
+        },
+
+        (GET) (/settings/network/wifi) => {
+            Response::html(routes::settings::network::list_aps::build_template())
+        },
+
+        (GET) (/settings/network/wifi/add) => {
+            Response::html(routes::settings::network::add_ap::build_template(request, None)).reset_flash()
+        },
+
+        (POST) (/settings/network/wifi/add) => {
+            routes::settings::network::add_ap::handle_form(request)
+        },
+
+        (GET) (/settings/network/wifi/add/{ssid: String}) => {
+            Response::html(routes::settings::network::add_ap::build_template(request, Some(ssid))).reset_flash()
+        },
+
+        (GET) (/settings/network/wifi/modify) => {
+            Response::html(routes::settings::network::modify_ap::build_template(request, None)).reset_flash()
+        },
+
+        (POST) (/settings/network/wifi/modify) => {
+            routes::settings::network::modify_ap::handle_form(request)
+        },
+
+        (GET) (/settings/network/wifi/modify/{ssid: String}) => {
+            Response::html(routes::settings::network::modify_ap::build_template(request, Some(ssid))).reset_flash()
+        },
+
+        (GET) (/settings/network/wifi/{ssid: String}) => {
+            Response::html(routes::settings::network::ap_details::build_template(request, ssid))
+        },
+
         (GET) (/settings/theme/{theme: String}) => {
             routes::settings::theme::set_theme(theme)
         },
 
+        (GET) (/status) => {
+            Response::html(routes::status::device::build_template())
+        },
+
         (GET) (/status/scuttlebutt) => {
             Response::html(routes::status::scuttlebutt::build_template()).add_cookie("back_url=/status/scuttlebutt")
         },
 
+        (GET) (/status/network) => {
+            Response::html(routes::status::network::build_template())
+        },
+
         // render the not_found template and set a 404 status code if none of
         // the other blocks matches the request
         _ => Response::html(templates::not_found::build_template()).with_status_code(404)

peach-web/src/routes/home.rs

@@ -1,7 +1,7 @@
 use maud::{html, PreEscaped};
 use peach_lib::sbot::SbotStatus;
 
-use crate::{templates, utils::theme};
+use crate::{templates, utils::theme, SERVER_CONFIG};
 
 /// Read the state of the go-sbot process and define status-related
 /// elements accordingly.
@@ -24,9 +24,23 @@ fn render_status_elements<'a>() -> (&'a str, &'a str, &'a str) {
     }
 }
 
+/// Render the URL for the status element (icon / link).
+///
+/// If the application is running in standalone mode then the element links
+/// directly to the Scuttlebutt status page. If not, it links to the device
+/// status page.
+fn render_status_url<'a>() -> &'a str {
+    if SERVER_CONFIG.standalone_mode {
+        "/status/scuttlebutt"
+    } else {
+        "/status"
+    }
+}
+
 /// Home template builder.
 pub fn build_template() -> PreEscaped<String> {
     let (circle_color, center_circle_text, circle_border) = render_status_elements();
+    let status_url = render_status_url();
 
     // render the home template html
     let home_template = html! {
@@ -63,7 +77,7 @@ pub fn build_template() -> PreEscaped<String> {
             }
             (PreEscaped("<!-- bottom-left -->"))
             (PreEscaped("<!-- SYSTEM STATUS LINK AND ICON -->"))
-            a class="bottom-left" href="/status/scuttlebutt" title="Status" {
+            a class="bottom-left" href=(status_url) title="Status" {
                 div class={ "circle circle-small border-circle-small " (circle_border) } {
                     img class="icon-medium" src="/icons/heart-pulse.svg";
                 }

peach-web/src/routes/settings/menu.rs

@@ -11,8 +11,10 @@ pub fn build_template() -> PreEscaped<String> {
         div class="card center" {
             (PreEscaped("<!-- BUTTONS -->"))
             div id="settingsButtons" {
-                // render the network settings button if we're not in standalone mode
+                // render the network settings and power menu buttons if we're
+                // not in standalone mode
                 @if !SERVER_CONFIG.standalone_mode {
+                    a id="power" class="button button-primary center" href="/settings/power" title="Power Menu" { "Power" }
                     a id="network" class="button button-primary center" href="/settings/network" title="Network Settings" { "Network" }
                 }
                 a id="scuttlebutt" class="button button-primary center" href="/settings/scuttlebutt" title="Scuttlebutt Settings" { "Scuttlebutt" }

peach-web/src/routes/settings/mod.rs

@@ -1,6 +1,7 @@
 pub mod admin;
 //pub mod dns;
 pub mod menu;
-//pub mod network;
+pub mod network;
+pub mod power;
 pub mod scuttlebutt;
 pub mod theme;

peach-web/src/routes/settings/network.rs

@@ -1,322 +0,0 @@
-use log::{debug, warn};
-use rocket::{
-    form::{Form, FromForm},
-    get, post,
-    request::FlashMessage,
-    response::{Flash, Redirect},
-    uri, UriDisplayQuery,
-};
-use rocket_dyn_templates::{tera::Context, Template};
-
-use peach_network::network;
-
-use crate::{
-    context,
-    context::network::{NetworkAlertContext, NetworkDetailContext, NetworkListContext},
-    routes::authentication::Authenticated,
-    utils::{monitor, monitor::Threshold},
-    AP_IFACE, WLAN_IFACE,
-};
-
-// STRUCTS USED BY NETWORK ROUTES
-
-#[derive(Debug, FromForm, UriDisplayQuery)]
-pub struct Ssid {
-    pub ssid: String,
-}
-
-#[derive(Debug, FromForm)]
-pub struct WiFi {
-    pub ssid: String,
-    pub pass: String,
-}
-
-// HELPERS AND ROUTES FOR /settings/network/wifi/usage/reset
-
-#[get("/wifi/usage/reset")]
-pub fn wifi_usage_reset(_auth: Authenticated) -> Flash<Redirect> {
-    let url = uri!(wifi_usage);
-    match monitor::reset_data() {
-        Ok(_) => Flash::success(Redirect::to(url), "Reset stored network traffic total"),
-        Err(_) => Flash::error(
-            Redirect::to(url),
-            "Failed to reset stored network traffic total",
-        ),
-    }
-}
-
-#[post("/wifi/connect", data = "<network>")]
-pub fn connect_wifi(network: Form<Ssid>, _auth: Authenticated) -> Flash<Redirect> {
-    let ssid = &network.ssid;
-    let url = uri!(network_detail(ssid = ssid));
-    match network::id(&*WLAN_IFACE, ssid) {
-        Ok(Some(id)) => match network::connect(&id, &*WLAN_IFACE) {
-            Ok(_) => Flash::success(Redirect::to(url), "Connected to chosen network"),
-            Err(_) => Flash::error(Redirect::to(url), "Failed to connect to chosen network"),
-        },
-        _ => Flash::error(Redirect::to(url), "Failed to retrieve the network ID"),
-    }
-}
-
-#[post("/wifi/disconnect", data = "<network>")]
-pub fn disconnect_wifi(network: Form<Ssid>, _auth: Authenticated) -> Flash<Redirect> {
-    let ssid = &network.ssid;
-    let url = uri!(network_home);
-    match network::disable(&*WLAN_IFACE, ssid) {
-        Ok(_) => Flash::success(Redirect::to(url), "Disconnected from WiFi network"),
-        Err(_) => Flash::error(Redirect::to(url), "Failed to disconnect from WiFi network"),
-    }
-}
-
-#[post("/wifi/forget", data = "<network>")]
-pub fn forget_wifi(network: Form<Ssid>, _auth: Authenticated) -> Flash<Redirect> {
-    let ssid = &network.ssid;
-    let url = uri!(network_home);
-    match network::forget(&*WLAN_IFACE, ssid) {
-        Ok(_) => Flash::success(Redirect::to(url), "WiFi credentials removed"),
-        Err(_) => Flash::error(
-            Redirect::to(url),
-            "Failed to remove WiFi credentials".to_string(),
-        ),
-    }
-}
-
-#[get("/wifi/modify?<ssid>")]
-pub fn wifi_password(ssid: &str, flash: Option<FlashMessage>, _auth: Authenticated) -> Template {
-    let mut context = Context::new();
-    context.insert("back", &Some("/settings/network/wifi".to_string()));
-    context.insert("title", &Some("Update WiFi Password".to_string()));
-    context.insert("selected", &Some(ssid.to_string()));
-
-    // check to see if there is a flash message to display
-    if let Some(flash) = flash {
-        // add flash message contents to the context object
-        context.insert("flash_name", &Some(flash.kind().to_string()));
-        context.insert("flash_msg", &Some(flash.message().to_string()));
-    };
-
-    Template::render("settings/network/modify_ap", &context.into_json())
-}
-
-#[post("/wifi/modify", data = "<wifi>")]
-pub fn wifi_set_password(wifi: Form<WiFi>, _auth: Authenticated) -> Flash<Redirect> {
-    let ssid = &wifi.ssid;
-    let pass = &wifi.pass;
-    let url = uri!(network_detail(ssid = ssid));
-    match network::update(&*WLAN_IFACE, ssid, pass) {
-        Ok(_) => Flash::success(Redirect::to(url), "WiFi password updated".to_string()),
-        Err(_) => Flash::error(
-            Redirect::to(url),
-            "Failed to update WiFi password".to_string(),
-        ),
-    }
-}
-
-// HELPERS AND ROUTES FOR /settings/network
-
-#[get("/")]
-pub fn network_home(flash: Option<FlashMessage>, _auth: Authenticated) -> Template {
-    // assign context
-    let mut context = Context::new();
-    context.insert("back", &Some("/settings"));
-    context.insert("title", &Some("Network Configuration"));
-    context.insert("ap_state", &context::network::ap_state());
-
-    // check to see if there is a flash message to display
-    if let Some(flash) = flash {
-        // add flash message contents to the context object
-        context.insert("flash_name", &Some(flash.kind().to_string()));
-        context.insert("flash_msg", &Some(flash.message().to_string()));
-    };
-
-    // template_dir is set in Rocket.toml
-    Template::render("settings/network/menu", &context.into_json())
-}
-
-// HELPERS AND ROUTES FOR /settings/network/ap/activate
-
-#[get("/ap/activate")]
-pub fn deploy_ap(_auth: Authenticated) -> Flash<Redirect> {
-    // activate the wireless access point
-    debug!("Activating WiFi access point.");
-    match network::start_iface_service(&*AP_IFACE) {
-        Ok(_) => Flash::success(
-            Redirect::to("/settings/network"),
-            "Activated WiFi access point",
-        ),
-        Err(_) => Flash::error(
-            Redirect::to("/settings/network"),
-            "Failed to activate WiFi access point",
-        ),
-    }
-}
-
-// HELPERS AND ROUTES FOR /settings/network/wifi
-
-#[get("/wifi")]
-pub fn wifi_list(flash: Option<FlashMessage>, _auth: Authenticated) -> Template {
-    // assign context through context_builder call
-    let mut context = NetworkListContext::build();
-    context.back = Some("/settings/network".to_string());
-    context.title = Some("WiFi Networks".to_string());
-
-    // check to see if there is a flash message to display
-    if let Some(flash) = flash {
-        // add flash message contents to the context object
-        context.flash_name = Some(flash.kind().to_string());
-        context.flash_msg = Some(flash.message().to_string());
-    };
-
-    Template::render("settings/network/list_aps", &context)
-}
-
-// HELPERS AND ROUTES FOR /settings/network/wifi<ssid>
-
-#[get("/wifi?<ssid>")]
-pub fn network_detail(ssid: &str, flash: Option<FlashMessage>, _auth: Authenticated) -> Template {
-    let mut context = NetworkDetailContext::build();
-    context.back = Some("/settings/network/wifi".to_string());
-    context.title = Some("WiFi Network".to_string());
-    context.selected = Some(ssid.to_string());
-
-    if let Some(flash) = flash {
-        context.flash_name = Some(flash.kind().to_string());
-        context.flash_msg = Some(flash.message().to_string());
-    };
-
-    Template::render("settings/network/ap_details", &context)
-}
-
-// HELPERS AND ROUTES FOR /settings/network/wifi/activate
-
-#[get("/wifi/activate")]
-pub fn deploy_client(_auth: Authenticated) -> Flash<Redirect> {
-    // activate the wireless client
-    debug!("Activating WiFi client mode.");
-    match network::start_iface_service(&*WLAN_IFACE) {
-        Ok(_) => Flash::success(Redirect::to("/settings/network"), "Activated WiFi client"),
-        Err(_) => Flash::error(
-            Redirect::to("/settings/network"),
-            "Failed to activate WiFi client",
-        ),
-    }
-}
-
-// HELPERS AND ROUTES FOR /settings/network/wifi/add
-
-#[get("/wifi/add")]
-pub fn add_wifi(flash: Option<FlashMessage>, _auth: Authenticated) -> Template {
-    let mut context = Context::new();
-    context.insert("back", &Some("/settings/network".to_string()));
-    context.insert("title", &Some("Add WiFi Network".to_string()));
-
-    // check to see if there is a flash message to display
-    if let Some(flash) = flash {
-        // add flash message contents to the context object
-        context.insert("flash_name", &Some(flash.kind().to_string()));
-        context.insert("flash_msg", &Some(flash.message().to_string()));
-    };
-
-    Template::render("settings/network/add_ap", &context.into_json())
-}
-
-#[get("/wifi/add?<ssid>")]
-pub fn add_ssid(ssid: &str, flash: Option<FlashMessage>, _auth: Authenticated) -> Template {
-    let mut context = Context::new();
-    context.insert("back", &Some("/settings/network".to_string()));
-    context.insert("title", &Some("Add WiFi Network".to_string()));
-    context.insert("selected", &Some(ssid.to_string()));
-
-    // check to see if there is a flash message to display
-    if let Some(flash) = flash {
-        // add flash message contents to the context object
-        context.insert("flash_name", &Some(flash.kind().to_string()));
-        context.insert("flash_msg", &Some(flash.message().to_string()));
-    };
-
-    Template::render("settings/network/add_ap", &context.into_json())
-}
-
-#[post("/wifi/add", data = "<wifi>")]
-pub fn add_credentials(wifi: Form<WiFi>, _auth: Authenticated) -> Template {
-    let mut context = Context::new();
-    context.insert("back", &Some("/settings/network".to_string()));
-    context.insert("title", &Some("Add WiFi Network".to_string()));
-
-    // check if the credentials already exist for this access point
-    // note: this is nicer but it's an unstable feature:
-    //       if check_saved_aps(&wifi.ssid).contains(true)
-    // use unwrap_or instead, set value to false if err is returned
-    //let creds_exist = network::saved_networks(&wifi.ssid).unwrap_or(false);
-    let creds_exist = match network::saved_networks() {
-        Ok(Some(networks)) => networks.contains(&wifi.ssid),
-        _ => false,
-    };
-
-    // if credentials not found, generate and write wifi config to wpa_supplicant
-    let (flash_name, flash_msg) = if creds_exist {
-        (
-            "error".to_string(),
-            "Network credentials already exist for this access point".to_string(),
-        )
-    } else {
-        match network::add(&*WLAN_IFACE, &wifi.ssid, &wifi.pass) {
-            Ok(_) => {
-                debug!("Added WiFi credentials.");
-                // force reread of wpa_supplicant.conf file with new credentials
-                match network::reconfigure() {
-                    Ok(_) => debug!("Successfully reconfigured wpa_supplicant"),
-                    Err(_) => warn!("Failed to reconfigure wpa_supplicant"),
-                }
-                ("success".to_string(), "Added WiFi credentials".to_string())
-            }
-            Err(e) => {
-                debug!("Failed to add WiFi credentials.");
-                ("error".to_string(), format!("{}", e))
-            }
-        }
-    };
-
-    context.insert("flash_name", &Some(flash_name));
-    context.insert("flash_msg", &Some(flash_msg));
-
-    Template::render("settings/network/add_ap", &context.into_json())
-}
-
-// HELPERS AND ROUTES FOR WIFI USAGE
-
-#[get("/wifi/usage")]
-pub fn wifi_usage(flash: Option<FlashMessage>, _auth: Authenticated) -> Template {
-    let mut context = NetworkAlertContext::build();
-    // set back icon link to network route
-    context.back = Some("/settings/network".to_string());
-    context.title = Some("Network Data Usage".to_string());
-    // check to see if there is a flash message to display
-    if let Some(flash) = flash {
-        // add flash message contents to the context object
-        context.flash_name = Some(flash.kind().to_string());
-        context.flash_msg = Some(flash.message().to_string());
-    };
-    // template_dir is set in Rocket.toml
-    Template::render("settings/network/data_usage_limits", &context)
-}
-
-#[post("/wifi/usage", data = "<thresholds>")]
-pub fn wifi_usage_alerts(thresholds: Form<Threshold>, _auth: Authenticated) -> Flash<Redirect> {
-    match monitor::update_store(thresholds.into_inner()) {
-        Ok(_) => {
-            debug!("WiFi data usage thresholds updated.");
-            Flash::success(
-                Redirect::to("/settings/network/wifi/usage"),
-                "Updated alert thresholds and flags",
-            )
-        }
-        Err(_) => {
-            warn!("Failed to update WiFi data usage thresholds.");
-            Flash::error(
-                Redirect::to("/settings/network/wifi/usage"),
-                "Failed to update alert thresholds and flags",
-            )
-        }
-    }
-}

peach-web/src/routes/settings/network/add_ap.rs

@@ -0,0 +1,97 @@
+use maud::{html, Markup, PreEscaped};
+use peach_network::network;
+use rouille::{post_input, try_or_400, Request, Response};
+
+use crate::{
+    templates,
+    utils::{
+        flash::{FlashRequest, FlashResponse},
+        theme,
+    },
+    WLAN_IFACE,
+};
+
+// ROUTE: /settings/network/wifi/add
+
+fn render_ssid_input(selected_ap: Option<String>) -> Markup {
+    html! {
+        (PreEscaped("<!-- input for network ssid -->"))
+        input id="ssid" name="ssid" class="center input" type="text" placeholder="SSID" title="Network name (SSID) for WiFi access point" value=[selected_ap] autofocus;
+    }
+}
+
+fn render_password_input() -> Markup {
+    html! {
+        (PreEscaped("<!-- input for network password -->"))
+        input id="pass" name="pass" class="center input" type="password" placeholder="Password" title="Password for WiFi access point";
+    }
+}
+
+fn render_buttons() -> Markup {
+    html! {
+        (PreEscaped("<!-- BUTTONS -->"))
+        div id="buttons" {
+            input id="addWifi" class="button button-primary center" title="Add" type="submit" value="Add";
+            a class="button button-secondary center" href="/settings/network" title="Cancel" { "Cancel" }
+        }
+    }
+}
+
+/// WiFi access point credentials form template builder.
+pub fn build_template(request: &Request, selected_ap: Option<String>) -> PreEscaped<String> {
+    let (flash_name, flash_msg) = request.retrieve_flash();
+
+    let form_template = html! {
+        (PreEscaped("<!-- WIFI ADD CREDENTIALS FORM -->"))
+        div class="card center" {
+            form id="wifiCreds" action="/settings/network/wifi/add" method="post" {
+                (render_ssid_input(selected_ap))
+                (render_password_input())
+                (render_buttons())
+            }
+            @if let (Some(name), Some(msg)) = (flash_name, flash_msg) {
+                (PreEscaped("<!-- FLASH MESSAGE -->"))
+                (templates::flash::build_template(name, msg))
+            }
+        }
+    };
+
+    let body = templates::nav::build_template(
+        form_template,
+        "Add WiFi Network",
+        Some("/settings/network"),
+    );
+
+    let theme = theme::get_theme();
+
+    templates::base::build_template(body, theme)
+}
+
+/// Parse the SSID and password for an access point and save the new credentials.
+pub fn handle_form(request: &Request) -> Response {
+    let data = try_or_400!(post_input!(request, {
+        ssid: String,
+        pass: String,
+    }));
+
+    let (name, msg) = match network::add(WLAN_IFACE, &data.ssid, &data.pass) {
+        Ok(_) => match network::reconfigure() {
+            Ok(_) => ("success".to_string(), "Added WiFi credentials".to_string()),
+            Err(err) => (
+                "error".to_string(),
+                format!(
+                    "Added WiFi credentials but failed to reconfigure interface: {}",
+                    err
+                ),
+            ),
+        },
+        Err(err) => (
+            "error".to_string(),
+            format!("Failed to add WiFi credentials for {}: {}", &data.ssid, err),
+        ),
+    };
+
+    let (flash_name, flash_msg) = (format!("flash_name={}", name), format!("flash_msg={}", msg));
+
+    Response::redirect_303("/settings/network/wifi/add").add_flash(flash_name, flash_msg)
+}

peach-web/src/routes/settings/network/ap_details.rs

@@ -0,0 +1,197 @@
+use std::collections::HashMap;
+
+use maud::{html, Markup, PreEscaped};
+use peach_network::{network, network::AccessPoint, NetworkError};
+use rouille::Request;
+
+use crate::{
+    templates,
+    utils::{flash::FlashRequest, theme},
+    WLAN_IFACE,
+};
+
+// ROUTE: /settings/network/wifi?<ssid>
+
+fn render_network_status_icon(ssid: &str, wlan_ssid: &str, ap_state: &str) -> Markup {
+    let status_label_value = if ssid == wlan_ssid {
+        "CONNECTED"
+    } else if ap_state == "Available" {
+        "AVAILABLE"
+    } else {
+        "NOT IN RANGE"
+    };
+
+    html! {
+        (PreEscaped("<!-- NETWORK STATUS ICON -->"))
+        div class="grid-column-1" {
+            img id="wifiIcon" class="center icon" src="/icons/wifi.svg" alt="WiFi icon";
+            label class="center label-small font-gray" for="wifiIcon" title="Access Point Status" { (status_label_value) }
+        }
+    }
+}
+
+fn render_network_detailed_info(ssid: &str, ap_protocol: &str, ap_signal: Option<i32>) -> Markup {
+    let ap_signal_value = match ap_signal {
+        Some(signal) => signal.to_string(),
+        None => "Unknown".to_string(),
+    };
+
+    html! {
+        (PreEscaped("<!-- NETWORK DETAILED INFO -->"))
+        div class="grid-column-2" {
+            label class="label-small font-gray" for="netSsid" title="WiFi network SSID" { "SSID" };
+            p id="netSsid" class="card-text" title="SSID" { (ssid) }
+            label class="label-small font-gray" for="netSec" title="Security protocol" { "SECURITY" };
+            p id="netSec" class="card-text" title={ "Security protocol in use by " (ssid) } { (ap_protocol) }
+            label class="label-small font-gray" for="netSig" title="Signal Strength" { "SIGNAL" };
+            p id="netSig" class="card-text" title="Signal strength of WiFi access point" { (ap_signal_value) }
+        }
+    }
+}
+
+fn render_disconnect_form(ssid: &str) -> Markup {
+    html! {
+        form id="wifiDisconnect" action="/settings/network/wifi/disconnect" method="post" {
+            (PreEscaped("<!-- hidden element: allows ssid to be sent in request -->"))
+            input id="disconnectSsid" name="ssid" type="text" value=(ssid) style="display: none;";
+            input id="disconnectWifi" class="button button-warning center" title="Disconnect from Network" type="submit" value="Disconnect";
+        }
+    }
+}
+
+fn render_connect_form(ssid: &str) -> Markup {
+    html! {
+        form id="wifiConnect" action="/settings/network/wifi/connect" method="post" {
+            (PreEscaped("<!-- hidden element: allows ssid to be sent in request -->"))
+            input id="connectSsid" name="ssid" type="text" value=(ssid) style="display: none;";
+            input id="connectWifi" class="button button-primary center" title="Connect to Network" type="submit" value="Connect";
+        }
+    }
+}
+
+fn render_forget_form(ssid: &str) -> Markup {
+    html! {
+       form id="wifiForget" action="/settings/network/wifi/forget" method="post" {
+           (PreEscaped("<!-- hidden element: allows ssid to be sent in request -->"))
+           input id="forgetSsid" name="ssid" type="text" value=(ssid) style="display: none;";
+           input id="forgetWifi" class="button button-warning center" title="Forget Network" type="submit" value="Forget";
+       }
+    }
+}
+
+fn render_buttons(
+    selected_ap: &str,
+    wlan_ssid: &str,
+    ap: &AccessPoint,
+    saved_wifi_networks: Vec<String>,
+) -> Markup {
+    html! {
+        (PreEscaped("<!-- BUTTONS -->"))
+        div id="buttons" {
+            @if wlan_ssid == selected_ap {
+                (render_disconnect_form(selected_ap))
+            }
+            @if saved_wifi_networks.contains(&selected_ap.to_string()) {
+                @if wlan_ssid != selected_ap && ap.state == "Available" {
+                    (render_connect_form(selected_ap))
+                }
+                a class="button button-primary center" href={ "/settings/network/wifi/modify?ssid=" (selected_ap) } { "Modify" }
+                (render_forget_form(selected_ap))
+            } @else {
+                // display the Add button if AP creds not already in saved
+                // networks list
+                a class="button button-primary center" href={ "/settings/network/wifi/add?ssid=" (selected_ap) } { "Add" }
+            }
+            a class="button button-secondary center" href="/settings/network/wifi" title="Cancel" { "Cancel" }
+        }
+    }
+}
+
+/// Retrieve the list of all saved and in-range networks (including SSID and
+/// AP details for each network), the list of all saved networks (SSIDs only)
+/// and the SSID for the WiFi interface.
+fn retrieve_network_data() -> (
+    Result<HashMap<String, AccessPoint>, NetworkError>,
+    Vec<String>,
+    String,
+) {
+    let all_wifi_networks = network::all_networks(WLAN_IFACE);
+    let saved_wifi_networks = match network::saved_networks() {
+        Ok(Some(ssids)) => ssids,
+        _ => Vec::new(),
+    };
+    let wlan_ssid = match network::ssid(WLAN_IFACE) {
+        Ok(Some(ssid)) => ssid,
+        _ => String::from("Not connected"),
+    };
+
+    (all_wifi_networks, saved_wifi_networks, wlan_ssid)
+}
+
+/// WiFi access point (AP) template builder.
+///
+/// Render a UI card with details about the selected access point, including
+/// the connection state, security protocol being used, the SSID and the
+/// signal strength. Buttons are also rendering based on the state of the
+/// access point and whether or not credentials for the AP have previously
+/// been saved.
+///
+/// If the AP is available (ie. in-range) then a Connect button is rendered.
+/// A Disconnect button is rendered if the WiFi client is currently
+/// connected to the AP.
+///
+/// If credentials have not previously been saved for the AP, an Add button is
+/// rendered. Forget and Modify buttons are rendered if credentials for the AP
+/// have previously been saved.
+pub fn build_template(request: &Request, selected_ap: String) -> PreEscaped<String> {
+    let (flash_name, flash_msg) = request.retrieve_flash();
+
+    let (all_wifi_networks, saved_wifi_networks, wlan_ssid) = retrieve_network_data();
+
+    let network_info_box_class = if selected_ap == wlan_ssid {
+        "two-grid capsule success-border"
+    } else {
+        "two-grid capsule"
+    };
+
+    let network_list_template = html! {
+        (PreEscaped("<!-- NETWORK CARD -->"))
+        div class="card center" {
+            @if let Ok(wlan_networks) = all_wifi_networks {
+                // select only the access point we are interested in displaying
+                @if let Some((ssid, ap)) = wlan_networks.get_key_value(&selected_ap) {
+                    @let ap_protocol = match &ap.detail {
+                        Some(detail) => detail.protocol.clone(),
+                        None => "None".to_string()
+                    };
+                    (PreEscaped("<!-- NETWORK INFO BOX -->"))
+                    div class=(network_info_box_class) title="PeachCloud network mode and status" {
+                        (PreEscaped("<!-- left column -->"))
+                        (render_network_status_icon(ssid, &wlan_ssid, &ap.state))
+                        (PreEscaped("<!-- right column -->"))
+                        (render_network_detailed_info(ssid, &ap_protocol, ap.signal))
+                    }
+                    (render_buttons(ssid, &wlan_ssid, ap, saved_wifi_networks))
+                } @else {
+                    p class="card-text list-item" { (selected_ap) " not found in saved or in-range networks" }
+                }
+            } @else {
+                p class="card-text list-item" { "No saved or in-range networks found" }
+            }
+            @if let (Some(name), Some(msg)) = (flash_name, flash_msg) {
+                (PreEscaped("<!-- FLASH MESSAGE -->"))
+                (templates::flash::build_template(name, msg))
+            }
+        }
+    };
+
+    let body = templates::nav::build_template(
+        network_list_template,
+        "WiFi Networks",
+        Some("/settings/network"),
+    );
+
+    let theme = theme::get_theme();
+
+    templates::base::build_template(body, theme)
+}

peach-web/src/routes/settings/network/configure_dns.rs

@@ -0,0 +1,201 @@
+use log::info;
+use maud::{html, Markup, PreEscaped};
+use peach_lib::{
+    config_manager, dyndns_client,
+    error::PeachError,
+    jsonrpc_client_core::{Error, ErrorKind},
+    jsonrpc_core::types::error::ErrorCode,
+};
+use rouille::{post_input, try_or_400, Request, Response};
+
+use crate::{
+    error::PeachWebError,
+    templates,
+    utils::{
+        flash::{FlashRequest, FlashResponse},
+        theme,
+    },
+};
+
+// ROUTE: /settings/network/dns
+
+fn render_dyndns_status_indicator() -> Markup {
+    let (indicator_class, indicator_label) = match dyndns_client::is_dns_updater_online() {
+        Ok(true) => ("success-border", "Dynamic DNS is currently online."),
+        _ => (
+            "warning-border",
+            "Dynamic DNS is enabled but may be offline.",
+        ),
+    };
+
+    html! {
+        (PreEscaped("<!-- DYNDNS STATUS INDICATOR -->"))
+        div id="dyndns-status-indicator" class={ "stack capsule " (indicator_class) } {
+            div class="stack" {
+                label class="label-small font-near-black" { (indicator_label) }
+            }
+        }
+    }
+}
+
+fn render_external_domain_input() -> Markup {
+    let external_domain = config_manager::get_config_value("EXTERNAL_DOMAIN").ok();
+
+    html! {
+        div class="input-wrapper" {
+            (PreEscaped("<!-- input for externaldomain -->"))
+            label id="external_domain" class="label-small input-label font-near-black" {
+                label class="label-small input-label font-gray" for="external_domain" style="padding-top: 0.25rem;" { "External Domain (optional)" }
+                input id="external_domain" class="form-input"  style="margin-bottom: 0;" name="external_domain" type="text" title="external domain" value=[external_domain];
+            }
+        }
+    }
+}
+
+fn render_dyndns_enabled_checkbox() -> Markup {
+    let dyndns_enabled = config_manager::get_dyndns_enabled_value().unwrap_or(false);
+
+    html! {
+        div class="input-wrapper" {
+            div {
+                (PreEscaped("<!-- checkbox for dyndns flag -->"))
+                label class="label-small input-label font-gray" { "Enable Dynamic DNS" }
+                input style="margin-left: 0px;" id="enable_dyndns" name="enable_dyndns" title="Activate dynamic DNS" type="checkbox" checked[dyndns_enabled];
+            }
+        }
+    }
+}
+
+fn render_dynamic_domain_input() -> Markup {
+    let dyndns_domain =
+        config_manager::get_config_value("DYN_DOMAIN").unwrap_or_else(|_| String::from(""));
+    let dyndns_subdomain =
+        dyndns_client::get_dyndns_subdomain(&dyndns_domain).unwrap_or(dyndns_domain);
+
+    html! {
+        div class="input-wrapper" {
+            (PreEscaped("<!-- input for dyndns domain -->"))
+            label id="cut" class="label-small input-label font-near-black" {
+                label class="label-small input-label font-gray" for="cut" style="padding-top: 0.25rem;" { "Dynamic DNS Domain" }
+                input id="dyndns_domain" class="alert-input" name="dynamic_domain" placeholder="" type="text" title="dyndns_domain" value=(dyndns_subdomain);
+                { ".dyn.peachcloud.org" }
+            }
+        }
+    }
+}
+
+fn render_save_button() -> Markup {
+    html! {
+        div id="buttonDiv" style="margin-top: 2rem;" {
+            input id="configureDNSButton" class="button button-primary center" title="Add" type="submit" value="Save";
+        }
+    }
+}
+
+/// DNS configuration form template builder.
+pub fn build_template(request: &Request) -> PreEscaped<String> {
+    let (flash_name, flash_msg) = request.retrieve_flash();
+
+    let dyndns_enabled = config_manager::get_dyndns_enabled_value().unwrap_or(false);
+
+    let form_template = html! {
+        (PreEscaped("<!-- CONFIGURE DNS FORM -->"))
+        div class="card center" {
+            @if dyndns_enabled {
+                (render_dyndns_status_indicator())
+            }
+            form id="configureDNS" class="center" action="/settings/network/dns" method="post" {
+                (render_external_domain_input())
+                (render_dyndns_enabled_checkbox())
+                (render_dynamic_domain_input())
+                (render_save_button())
+                @if let (Some(name), Some(msg)) = (flash_name, flash_msg) {
+                    (PreEscaped("<!-- FLASH MESSAGE -->"))
+                    (templates::flash::build_template(name, msg))
+                }
+            }
+        }
+    };
+
+    let body = templates::nav::build_template(
+        form_template,
+        "Configure Dynamic DNS",
+        Some("/settings/network"),
+    );
+
+    let theme = theme::get_theme();
+
+    templates::base::build_template(body, theme)
+}
+
+pub fn save_dns_configuration(
+    external_domain: String,
+    enable_dyndns: bool,
+    dynamic_domain: String,
+) -> Result<(), PeachWebError> {
+    // first save local configurations
+    config_manager::set_external_domain(&external_domain)?;
+    config_manager::set_dyndns_enabled_value(enable_dyndns)?;
+
+    let full_dynamic_domain = dyndns_client::get_full_dynamic_domain(&dynamic_domain);
+
+    // if dynamic dns is enabled and this is a new domain name, then register it
+    if enable_dyndns && dyndns_client::check_is_new_dyndns_domain(&full_dynamic_domain)? {
+        if let Err(registration_err) = dyndns_client::register_domain(&full_dynamic_domain) {
+            info!("Failed to register dyndns domain: {:?}", registration_err);
+
+            // error message describing the failed update
+            let err_msg = match registration_err {
+                PeachError::JsonRpcClientCore(Error(ErrorKind::JsonRpcError(rpc_err), _)) => {
+                    if let ErrorCode::ServerError(-32030) = rpc_err.code {
+                        format!(
+                            "Error registering domain: {} was previously registered",
+                            full_dynamic_domain
+                        )
+                    } else {
+                        format!("Failed to register dyndns domain: {:?}", rpc_err)
+                    }
+                }
+                _ => "Failed to register dyndns domain".to_string(),
+            };
+
+            Err(PeachWebError::FailedToRegisterDynDomain(err_msg))
+        } else {
+            info!("Registered new dyndns domain");
+
+            Ok(())
+        }
+    } else {
+        info!("Domain {} already registered", dynamic_domain);
+
+        Ok(())
+    }
+}
+
+/// Parse the DNS configuration parameters and apply them.
+pub fn handle_form(request: &Request) -> Response {
+    let data = try_or_400!(post_input!(request, {
+        external_domain: String,
+        enable_dyndns: bool,
+        dynamic_domain: String,
+    }));
+
+    let (name, msg) = match save_dns_configuration(
+        data.external_domain,
+        data.enable_dyndns,
+        data.dynamic_domain,
+    ) {
+        Ok(_) => (
+            "success".to_string(),
+            "New dynamic DNS configuration is now enabled".to_string(),
+        ),
+        Err(err) => (
+            "error".to_string(),
+            format!("Failed to save DNS configuration: {}", err),
+        ),
+    };
+
+    let (flash_name, flash_msg) = (format!("flash_name={}", name), format!("flash_msg={}", msg));
+
+    Response::redirect_303("/settings/network/dns").add_flash(flash_name, flash_msg)
+}

peach-web/src/routes/settings/network/data_usage_limits.rs

@@ -0,0 +1,164 @@
+// TODO:
+//
+// This template and associated feature set requires vnstat_parse.
+// - https://crates.io/crates/vnstat_parse
+//
+// Use the PeachCloud config system to store warning and cutoff flags,
+// as well as the associated totals (thresholds):
+//
+// - DATA_WARNING_ENABLED
+// - DATA_WARNING_LIMIT
+// - DATA_CUTOFF_ENABLED
+// - DATA_CUTOFF_LIMIT
+
+use maud::{html, Markup, PreEscaped};
+use peach_network::network;
+use rouille::Request;
+use vnstat_parse::Vnstat;
+
+use crate::{
+    templates,
+    utils::{flash::FlashRequest, theme},
+    WLAN_IFACE,
+};
+
+// ROUTE: /settings/network/wifi/usage
+
+fn render_data_usage_total_capsule() -> Markup {
+    html! {
+        div class="stack capsule" style="margin-left: 2rem; margin-right: 2rem;" {
+            div class="flex-grid" {
+                label id="dataTotal" class="label-large" title="Data download total in MB" {
+                    data_total.total / 1024 / 1024 | round
+                }
+                label class="label-small font-near-black" { "MB" }
+            }
+            label class="center-text label-small font-gray" { "USAGE TOTAL" }
+        }
+    }
+}
+
+fn render_warning_threshold_icon() -> Markup {
+    // threshold.warn_flag
+    let warning_enabled = true;
+
+    let icon_class = match warning_enabled {
+        true => "icon",
+        false => "icon icon-inactive",
+    };
+
+    html! {
+        div class="card-container container" {
+            div {
+                img id="warnIcon" class=(icon_class) alt="Warning" title="Warning threshold" src="/icons/alert.svg";
+            }
+        }
+    }
+}
+
+fn render_warning_threshold_input() -> Markup {
+    // TODO: source threshold.warn value and replace below
+
+    html! {
+        div {
+            (PreEscaped("<!-- input for warning threshold -->"))
+            label id="warn" class="label-small font-near-black" {
+                input id="warnInput" class="alert-input" name="warn" placeholder="0" type="text" title="Warning threshold value" value="{{ threshold.warn }}" { "MB" }
+            }
+            label class="label-small font-gray" for="warn" style="padding-top: 0.25rem;" { "WARNING THRESHOLD" }
+        }
+    }
+}
+
+fn render_warning_threshold_checkbox() -> Markup {
+    let warning_enabled = true;
+
+    html! {
+        div {
+            (PreEscaped("<!-- checkbox for warning threshold flag -->"))
+            input id="warnCheck" name="warn_flag" title="Activate warning" type="checkbox" checked[warning_enabled];
+        }
+    }
+}
+
+fn render_critical_threshold_icon() -> Markup {
+    // threshold.cut_flag
+    let cutoff_enabled = true;
+
+    let icon_class = match cutoff_enabled {
+        true => "icon",
+        false => "icon icon-inactive",
+    };
+
+    html! {
+        div {
+            img id="cutIcon"
+                class=(icon_class)
+                alt="Cutoff"
+                title="Cutoff threshold"
+                src="/icons/scissor.svg";
+        }
+    }
+}
+
+fn render_critical_threshold_input() -> Markup {
+    // TODO: source threshold.cut value and replace below
+
+    html! {
+        div {
+            (PreEscaped("<!-- input for cutoff threshold -->"))
+            label id="cut" class="label-small font-near-black"><input id="cutInput" class="alert-input" name="cut" placeholder="0" type="text" title="Critical threshold value" value="{{ threshold.cut }}" { "MB" }
+            label class="label-small font-gray" for="cut" style="padding-top: 0.25rem;" { "CUTOFF THRESHOLD" }
+        }
+    }
+}
+
+fn render_critical_threshold_checkbox() -> Markup {
+    // threshold.cut_flag
+    let cutoff_enabled = true;
+
+    html! {
+        div {
+            (PreEscaped("<!-- checkbox for cutoff threshold flag -->"))
+            input id="cutCheck" name="cut_flag" title="Activate cutoff" type="checkbox" checked[cutoff_enabled];
+        }
+    }
+}
+
+fn render_buttons() -> Markup {
+    html! {
+        div id="buttonDiv" class="button-div" {
+            input id="updateAlerts" class="button button-primary center" title="Update" type="submit" value="Update";
+            a id="resetTotal" class="button button-warning center" href="/settings/network/wifi/usage/reset" title="Reset stored usage total to zero" { "Reset" }
+            a class="button button-secondary center" href="/settings/network" title="Cancel" { "Cancel" }
+        }
+    }
+}
+
+/// WiFi data usage form template builder.
+pub fn build_template(request: &Request) -> PreEscaped<String> {
+    let (flash_name, flash_msg) = request.retrieve_flash();
+
+    let wlan_data = Vnstat::get(WLAN_IFACE);
+
+    // wlan_data.all_time_total
+    // wlan_data.all_time_total_unit
+
+    let form_template = html! {
+        (PreEscaped("<!-- NETWORK DATA ALERTS FORM -->"))
+        form id="wifiAlerts" action="/network/wifi/usage" class="card center" method="post" {
+            (render_data_usage_total_capsule())
+            (render_warning_threshold_icon())
+            (render_warning_threshold_input())
+            (render_warning_threshold_checkbox())
+            (render_critical_threshold_icon())
+            (render_critical_threshold_input())
+            (render_critical_threshold_checkbox())
+            (render_buttons())
+        }
+        @if let (Some(name), Some(msg)) = (flash_name, flash_msg) {
+            (PreEscaped("<!-- FLASH MESSAGE -->"))
+            (templates::flash::build_template(name, msg))
+        }
+    };
+}

peach-web/src/routes/settings/network/list_aps.rs

@@ -0,0 +1,106 @@
+use std::collections::HashMap;
+
+use maud::{html, Markup, PreEscaped};
+use peach_network::{network, network::AccessPoint};
+
+use crate::{templates, utils::theme, AP_IFACE, WLAN_IFACE};
+
+// ROUTE: /settings/network/wifi
+
+/// Retrieve network state data required by the WiFi network list template.
+fn get_network_state_data(ap: &str, wlan: &str) -> (String, String, HashMap<String, AccessPoint>) {
+    let ap_state = match network::state(ap) {
+        Ok(Some(state)) => state,
+        _ => "Interface unavailable".to_string(),
+    };
+
+    let wlan_ssid = match network::ssid(wlan) {
+        Ok(Some(ssid)) => ssid,
+        _ => "Not connected".to_string(),
+    };
+
+    let network_list = match network::all_networks(wlan) {
+        Ok(networks) => networks,
+        Err(_) => HashMap::new(),
+    };
+
+    (ap_state, wlan_ssid, network_list)
+}
+
+fn render_network_connected_elements(ssid: String) -> Markup {
+    let ap_detail_url = format!("/network/wifi?ssid={}", ssid);
+
+    html! {
+        a class="list-item link primary-bg" href=(ap_detail_url) {
+            img id="netStatus" class="icon icon-active icon-medium list-icon" src="/icons/wifi.svg" alt="WiFi online";
+            p class="list-text" { (ssid) }
+            label class="label-small list-label font-gray" for="netStatus" title="Status" { "Connected" }
+        }
+    }
+}
+
+fn render_network_available_elements(ssid: String, ap_state: String) -> Markup {
+    let ap_detail_url = format!("/network/wifi?ssid={}", ssid);
+
+    html! {
+        a class="list-item link light-bg" href=(ap_detail_url) {
+            img id="netStatus" class="icon icon-inactive icon-medium list-icon" src="/icons/wifi.svg" alt="WiFi offline";
+            p class="list-text" { (ssid) }
+            label class="label-small list-label font-gray" for="netStatus" title="Status" { (ap_state) }
+        }
+    }
+}
+
+fn render_network_unavailable_elements(ssid: String, ap_state: String) -> Markup {
+    let ap_detail_url = format!("/network/wifi?ssid={}", ssid);
+
+    html! {
+        a class="list-item link" href=(ap_detail_url) {
+            img id="netStatus" class="icon icon-inactive icon-medium list-icon" src="/icons/wifi.svg" alt="WiFi offline";
+            p class="list-text" { (ssid) }
+            label class="label-small list-label font-gray" for="netStatus" title="Status" { (ap_state) }
+        }
+    }
+}
+
+/// WiFi network list template builder.
+pub fn build_template() -> PreEscaped<String> {
+    let (ap_state, wlan_ssid, network_list) = get_network_state_data(AP_IFACE, WLAN_IFACE);
+
+    let list_template = html! {
+        div class="card center" {
+            div class="center list-container" {
+                ul class="list" {
+                    @if ap_state == "up" {
+                        li class="list-item light-bg warning-border" {
+                            "Enable WiFi client mode to view saved and available networks."
+                        }
+                    } @else if network_list.is_empty() {
+                        li class="list-item light-bg" {
+                            "No saved or available networks found."
+                        }
+                    } @else {
+                        @for (ssid, ap) in network_list {
+                            li {
+                                @if ssid == wlan_ssid {
+                                    (render_network_connected_elements(ssid))
+                                } @else if ap.state == "Available" {
+                                    (render_network_available_elements(ssid, ap.state))
+                                } @else {
+                                    (render_network_unavailable_elements(ssid, ap.state))
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    };
+
+    let body =
+        templates::nav::build_template(list_template, "WiFi Networks", Some("/settings/network"));
+
+    let theme = theme::get_theme();
+
+    templates::base::build_template(body, theme)
+}

peach-web/src/routes/settings/network/menu.rs

@@ -0,0 +1,65 @@
+use maud::{html, Markup, PreEscaped};
+use peach_network::network;
+use rouille::Request;
+
+use crate::{
+    templates,
+    utils::{flash::FlashRequest, theme},
+    AP_IFACE,
+};
+
+// ROUTE: /settings/network
+
+/// Read the wireless interface mode (WiFi AP or client) and selectively render
+/// the activation button for the deactivated mode.
+fn render_mode_toggle_button() -> Markup {
+    match network::state(AP_IFACE) {
+        Ok(Some(state)) if state == "up" => {
+            html! {
+                a id="connectWifi" class="button button-primary center" href="/settings/network/wifi/activate" title="Enable WiFi" { "Enable WiFi" }
+            }
+        }
+        _ => html! {
+            a id="deployAccessPoint" class="button button-primary center" href="/settings/network/ap/activate" title="Deploy Access Point" { "Deploy Access Point" }
+        },
+    }
+}
+
+fn render_buttons() -> Markup {
+    html! {
+        (PreEscaped("<!-- BUTTONS -->"))
+        div id="buttons" {
+            a class="button button-primary center" href="/settings/network/wifi/add" title="Add WiFi Network" { "Add WiFi Network" }
+            a id="configureDNS" class="button button-primary center" href="/settings/network/dns" title="Configure DNS" { "Configure DNS" }
+            (PreEscaped("<!-- if ap is up, show 'Enable WiFi' button, else show 'Deplay Access Point' -->"))
+            (render_mode_toggle_button())
+            a id="listWifi" class="button button-primary center" href="/settings/network/wifi" title="List WiFi Networks" { "List WiFi Networks" }
+            // TODO: uncomment this once data usage feature is in place
+            // a id="viewUsage" class="button button-primary center" href="/settings/network/wifi/usage" title="View Data Usage" { "View Data Usage" }
+            a id="viewStatus" class="button button-primary center" href="/status/network" title="View Network Status" { "View Network Status" }
+        }
+    }
+}
+
+/// Network settings menu template builder.
+pub fn build_template(request: &Request) -> PreEscaped<String> {
+    let (flash_name, flash_msg) = request.retrieve_flash();
+
+    let menu_template = html! {
+        (PreEscaped("<!-- NETWORK SETTINGS MENU -->"))
+        div class="card center" {
+            (render_buttons())
+            // render flash message if cookies were found in the request
+            @if let (Some(name), Some(msg)) = (flash_name, flash_msg) {
+                (PreEscaped("<!-- FLASH MESSAGE -->"))
+                (templates::flash::build_template(name, msg))
+            }
+        }
+    };
+
+    let body = templates::nav::build_template(menu_template, "Network Settings", Some("/settings"));
+
+    let theme = theme::get_theme();
+
+    templates::base::build_template(body, theme)
+}

peach-web/src/routes/settings/network/mod.rs

@@ -0,0 +1,8 @@
+pub mod add_ap;
+pub mod ap_details;
+pub mod configure_dns;
+// TODO: uncomment this once data usage feature is in place
+// pub mod data_usage_limits;
+pub mod list_aps;
+pub mod menu;
+pub mod modify_ap;

peach-web/src/routes/settings/network/modify_ap.rs

@@ -0,0 +1,105 @@
+use maud::{html, Markup, PreEscaped};
+use peach_network::network;
+use rouille::{post_input, try_or_400, Request, Response};
+
+use crate::{
+    templates,
+    utils::{
+        flash::{FlashRequest, FlashResponse},
+        theme,
+    },
+    WLAN_IFACE,
+};
+
+// ROUTE: /settings/network/wifi/modify?<ssid>
+
+fn render_ssid_input(selected_ap: Option<String>) -> Markup {
+    html! {
+        (PreEscaped("<!-- input for network ssid -->"))
+        input id="ssid" name="ssid" class="center input" type="text" placeholder="SSID" title="Network name (SSID) for WiFi access point" value=[selected_ap] autofocus;
+    }
+}
+
+fn render_password_input() -> Markup {
+    html! {
+        (PreEscaped("<!-- input for network password -->"))
+        input id="pass" name="pass" class="center input" type="password" placeholder="Password" title="Password for WiFi access point";
+    }
+}
+
+fn render_buttons() -> Markup {
+    html! {
+        (PreEscaped("<!-- BUTTONS -->"))
+        div id="buttons" {
+            input id="savePassword" class="button button-primary center" title="Save" type="submit" value="Save";
+            a class="button button-secondary center" href="/settings/network" title="Cancel" { "Cancel" }
+        }
+    }
+}
+
+/// WiFi access point password modification form template builder.
+pub fn build_template(request: &Request, selected_ap: Option<String>) -> PreEscaped<String> {
+    let (flash_name, flash_msg) = request.retrieve_flash();
+
+    let form_template = html! {
+        (PreEscaped("<!-- NETWORK MODIFY AP PASSWORD FORM -->"))
+        div class="card center" {
+            form id="wifiModify" action="/settings/network/wifi/modify" method="post" {
+                (render_ssid_input(selected_ap))
+                (render_password_input())
+                (render_buttons())
+            }
+            // render flash message if cookies were found in the request
+            @if let (Some(name), Some(msg)) = (flash_name, flash_msg) {
+                (PreEscaped("<!-- FLASH MESSAGE -->"))
+                (templates::flash::build_template(name, msg))
+            }
+        }
+    };
+
+    let body = templates::nav::build_template(
+        form_template,
+        "Change WiFi Password",
+        Some("/settings/network"),
+    );
+
+    let theme = theme::get_theme();
+
+    templates::base::build_template(body, theme)
+}
+
+/// Parse the SSID and password for an access point and save the new password.
+pub fn handle_form(request: &Request) -> Response {
+    let data = try_or_400!(post_input!(request, {
+        ssid: String,
+        pass: String,
+    }));
+
+    let (name, msg) = match network::id(WLAN_IFACE, &data.ssid) {
+        Ok(Some(id)) => match network::modify(&id, &data.ssid, &data.pass) {
+            Ok(_) => ("success".to_string(), "WiFi password updated".to_string()),
+            Err(err) => (
+                "error".to_string(),
+                format!("Failed to update WiFi password: {}", err),
+            ),
+        },
+        Ok(None) => (
+            "error".to_string(),
+            format!(
+                "Failed to update WiFi password: no saved credentials found for network {}",
+                &data.ssid
+            ),
+        ),
+        Err(err) => (
+            "error".to_string(),
+            format!(
+                "Failed to update WiFi password: no ID found for network {}: {}",
+                &data.ssid, err
+            ),
+        ),
+    };
+
+    let (flash_name, flash_msg) = (format!("flash_name={}", name), format!("flash_msg={}", msg));
+
+    Response::redirect_303("/settings/network/wifi/modify").add_flash(flash_name, flash_msg)
+}

peach-web/src/routes/settings/power/menu.rs

@@ -0,0 +1,37 @@
+use maud::{html, PreEscaped};
+use rouille::Request;
+
+use crate::{
+    templates,
+    utils::{flash::FlashRequest, theme},
+};
+
+/// Power menu template builder.
+///
+/// Presents options for rebooting or shutting down the device.
+pub fn build_template(request: &Request) -> PreEscaped<String> {
+    let (flash_name, flash_msg) = request.retrieve_flash();
+
+    let power_menu_template = html! {
+        (PreEscaped("<!-- POWER MENU -->"))
+        div class="card center" {
+            div class="card-container" {
+                div id="buttons" {
+                    a id="rebootBtn" class="button button-primary center" href="/reboot" title="Reboot Device" { "Reboot" }
+                    a id="shutdownBtn" class="button button-warning center" href="/shutdown" title="Shutdown Device" { "Shutdown" }
+                    a id="cancelBtn" class="button button-secondary center" href="/settings" title="Cancel" { "Cancel" }
+                }
+                @if let (Some(name), Some(msg)) = (flash_name, flash_msg) {
+                    (PreEscaped("<!-- FLASH MESSAGE -->"))
+                    (templates::flash::build_template(name, msg))
+                }
+            }
+        }
+    };
+
+    let body = templates::nav::build_template(power_menu_template, "Power Menu", Some("/"));
+
+    let theme = theme::get_theme();
+
+    templates::base::build_template(body, theme)
+}

peach-web/src/routes/settings/power/mod.rs

@@ -0,0 +1,3 @@
+pub mod menu;
+pub mod reboot;
+pub mod shutdown;

peach-web/src/routes/settings/power/reboot.rs

@@ -0,0 +1,36 @@
+use log::info;
+use rouille::Response;
+
+use std::{
+    io::Result,
+    process::{Command, Output},
+};
+
+use crate::utils::flash::FlashResponse;
+
+/// Executes a system command to reboot the device immediately.
+fn reboot() -> Result<Output> {
+    info!("Rebooting the device");
+    // ideally, we'd like to reboot after 5 seconds to allow time for JSON
+    // response but this is not possible with the `shutdown` command alone.
+    // TODO: send "rebooting..." message to `peach-oled` for display
+    Command::new("sudo")
+        .arg("shutdown")
+        .arg("-r")
+        .arg("now")
+        .output()
+}
+
+pub fn handle_reboot() -> Response {
+    let (name, msg) = match reboot() {
+        Ok(_) => ("success".to_string(), "Rebooting the device".to_string()),
+        Err(err) => (
+            "error".to_string(),
+            format!("Failed to reboot the device: {}", err),
+        ),
+    };
+
+    let (flash_name, flash_msg) = (format!("flash_name={}", name), format!("flash_msg={}", msg));
+
+    Response::redirect_303("/power").add_flash(flash_name, flash_msg)
+}

peach-web/src/routes/settings/power/shutdown.rs

@@ -0,0 +1,35 @@
+use log::info;
+use rouille::Response;
+
+use std::{
+    io::Result,
+    process::{Command, Output},
+};
+
+use crate::utils::flash::FlashResponse;
+
+/// Executes a system command to shutdown the device immediately.
+fn shutdown() -> Result<Output> {
+    info!("Shutting down the device");
+    // ideally, we'd like to shutdown after 5 seconds to allow time for JSON
+    // response but this is not possible with the `shutdown` command alone.
+    // TODO: send "shutting down..." message to `peach-oled` for display
+    Command::new("sudo").arg("shutdown").arg("now").output()
+}
+
+pub fn handle_shutdown() -> Response {
+    let (name, msg) = match shutdown() {
+        Ok(_) => (
+            "success".to_string(),
+            "Shutting down the device".to_string(),
+        ),
+        Err(err) => (
+            "error".to_string(),
+            format!("Failed to shutdown the device: {}", err),
+        ),
+    };
+
+    let (flash_name, flash_msg) = (format!("flash_name={}", name), format!("flash_msg={}", msg));
+
+    Response::redirect_303("/power").add_flash(flash_name, flash_msg)
+}

peach-web/src/routes/status/device.rs

@@ -1,238 +1,381 @@
-use log::info;
-use rocket::{
-    get,
-    request::FlashMessage,
-    response::{Flash, Redirect},
-};
-use rocket_dyn_templates::Template;
-use serde::Serialize;
-use std::{
-    io,
-    process::{Command, Output},
-};
+use std::process::Command;
 
-use peach_lib::{
-    config_manager::load_peach_config, dyndns_client, network_client, oled_client, sbot::SbotStatus,
-};
+use maud::{html, Markup, PreEscaped};
+use peach_lib::{config_manager, dyndns_client, oled_client};
 use peach_stats::{
     stats,
-    stats::{CpuStatPercentages, DiskUsage, LoadAverage, MemStat},
+    stats::{CpuStatPercentages, MemStat},
 };
 
-use crate::routes::authentication::Authenticated;
+use crate::{templates, utils::theme};
 
-// HELPERS AND ROUTES FOR /status
+// ROUTE: /status
 
-/// System statistics data.
-#[derive(Debug, Serialize)]
-pub struct StatusContext {
-    pub back: Option<String>,
-    pub cpu_stat_percent: Option<CpuStatPercentages>,
-    pub disk_stats: Vec<DiskUsage>,
-    pub flash_name: Option<String>,
-    pub flash_msg: Option<String>,
-    pub load_average: Option<LoadAverage>,
-    pub mem_stats: Option<MemStat>,
-    pub network_ping: String,
-    pub oled_ping: String,
-    pub dyndns_enabled: bool,
-    pub dyndns_is_online: bool,
-    pub config_is_valid: bool,
-    pub sbot_is_online: bool,
-    pub title: Option<String>,
-    pub uptime: Option<i32>,
+/// Query systemd to determine the state of the networking service.
+fn retrieve_networking_state() -> Option<String> {
+    // call: `systemctl show networking.service --no-page`
+    let networking_service_output = Command::new("systemctl")
+        .arg("show")
+        .arg("networking.service")
+        .arg("--no-page")
+        .output()
+        .ok()?;
+
+    let service_info = std::str::from_utf8(&networking_service_output.stdout).ok()?;
+
+    // find the line starting with "ActiveState=" and return the value
+    service_info
+        .lines()
+        .find(|line| line.starts_with("ActiveState="))
+        .and_then(|line| line.strip_prefix("ActiveState="))
+        .map(|state| state.to_string())
 }
 
-impl StatusContext {
-    pub fn build() -> StatusContext {
-        // convert result to Option<CpuStatPercentages>, discard any error
-        let cpu_stat_percent = stats::cpu_stats_percent().ok();
-        let load_average = stats::load_average().ok();
-        let mem_stats = stats::mem_stats().ok();
-        // TODO: add `wpa_supplicant_status` to peach_network to replace this ping call
-        // instead of: "is the network json-rpc server running?", we want to ask:
-        // "is the wpa_supplicant systemd service functioning correctly?"
-        let network_ping = match network_client::ping() {
-            Ok(_) => "ONLINE".to_string(),
-            Err(_) => "OFFLINE".to_string(),
-        };
-        let oled_ping = match oled_client::ping() {
-            Ok(_) => "ONLINE".to_string(),
-            Err(_) => "OFFLINE".to_string(),
-        };
+/// Query systemd to determine the state of the sbot service.
+fn retrieve_sbot_state() -> Option<String> {
+    // retrieve the name of the go-sbot service or set default
+    let go_sbot_service = config_manager::get_config_value("GO_SBOT_SERVICE")
+        .unwrap_or_else(|_| "go-sbot.service".to_string());
 
-        let uptime = match stats::uptime() {
-            Ok(secs) => {
-                let uptime_mins = secs / 60;
-                uptime_mins.to_string()
-            }
-            Err(_) => "Unavailable".to_string(),
-        };
+    let sbot_service_output = Command::new("systemctl")
+        .arg("show")
+        .arg(go_sbot_service)
+        .arg("--no-page")
+        .output()
+        .ok()?;
 
-        // parse the uptime string to a signed integer (for math)
-        let uptime_parsed = uptime.parse::<i32>().ok();
+    let service_info = std::str::from_utf8(&sbot_service_output.stdout).ok()?;
 
-        // serialize disk usage data into Vec<DiskUsage>
-        let disk_usage_stats = match stats::disk_usage() {
-            Ok(disks) => disks,
-            Err(_) => Vec::new(),
-        };
+    // find the line starting with "ActiveState=" and return the value
+    service_info
+        .lines()
+        .find(|line| line.starts_with("ActiveState="))
+        .and_then(|line| line.strip_prefix("ActiveState="))
+        .map(|state| state.to_string())
+}
 
-        let mut disk_stats = Vec::new();
-        // select only the partition we're interested in: /dev/mmcblk0p2 ("/")
-        for disk in disk_usage_stats {
-            if disk.mountpoint == "/" {
-                disk_stats.push(disk);
+fn retrieve_device_status_data() -> (Option<u64>, String) {
+    let uptime = stats::uptime().ok();
+
+    let oled_ping = match oled_client::ping() {
+        Ok(_) => "ONLINE".to_string(),
+        Err(_) => "OFFLINE".to_string(),
+    };
+
+    (uptime, oled_ping)
+}
+
+fn retrieve_device_usage_data() -> (Option<CpuStatPercentages>, Option<MemStat>) {
+    // convert result to Option<CpuStatPercentages>, discard any error
+    let cpu_stat_percent = stats::cpu_stats_percent().ok();
+    let mem_stats = stats::mem_stats().ok();
+
+    (cpu_stat_percent, mem_stats)
+}
+
+fn render_network_capsule() -> Markup {
+    let (state, stack_class, img_class) = match retrieve_networking_state() {
+        Some(state) if state.as_str() == "active" => {
+            ("active", "stack capsule border-success", "icon icon-medium")
+        }
+        Some(state) if state.as_str() == "inactive" => (
+            "inactive",
+            "stack capsule border-warning",
+            "icon icon-inactive icon-medium",
+        ),
+        Some(state) if state.as_str() == "failed" => (
+            "failed",
+            "stack capsule border-danger",
+            "icon icon-inactive icon-medium",
+        ),
+        _ => (
+            "error",
+            "stack capsule border-danger",
+            "icon icon-inactive icon-medium",
+        ),
+    };
+
+    html! {
+        (PreEscaped("<!-- PEACH-NETWORK STATUS STACK -->"))
+        div class=(stack_class) {
+            img id="networkIcon" class=(img_class) alt="Network" title="Networking service status" src="icons/wifi.svg";
+            div class="stack" style="padding-top: 0.5rem;" {
+                label class="label-small font-near-black" { "Networking" }
+                label class="label-small font-near-black" { (state.to_uppercase()) }
             }
         }
+    }
+}
 
-        // dyndns_is_online & config_is_valid
-        let dyndns_enabled: bool;
-        let dyndns_is_online: bool;
-        let config_is_valid: bool;
-        let load_peach_config_result = load_peach_config();
-        match load_peach_config_result {
-            Ok(peach_config) => {
-                dyndns_enabled = peach_config.dyn_enabled;
-                config_is_valid = true;
-                if dyndns_enabled {
-                    let is_dyndns_online_result = dyndns_client::is_dns_updater_online();
-                    match is_dyndns_online_result {
-                        Ok(is_online) => {
-                            dyndns_is_online = is_online;
-                        }
-                        Err(_err) => {
-                            dyndns_is_online = false;
-                        }
+fn render_oled_capsule(state: String) -> Markup {
+    let (stack_class, img_class) = match state.as_str() {
+        "ONLINE" => ("stack capsule border-success", "icon icon-medium"),
+        _ => (
+            "stack capsule border-warning",
+            "icon icon-inactive icon-medium",
+        ),
+    };
+
+    html! {
+        (PreEscaped("<!-- PEACH-OLED STATUS STACK -->"))
+        div class=(stack_class) {
+            img id="oledIcon" class=(img_class) alt="Display" title="OLED display microservice status" src="icons/lcd.svg";
+            div class="stack" style="padding-top: 0.5rem;" {
+                label class="label-small font-near-black" { "Display" }
+                label class="label-small font-near-black" { (state) }
+            }
+        }
+    }
+}
+
+fn render_diagnostics_capsule() -> Markup {
+    // TODO: write a diagnostics module (maybe in peach-lib)
+
+    let diagnostics_state = "CLEAR";
+
+    html! {
+        (PreEscaped("<!-- DIAGNOSTICS AND LOGS STACK -->"))
+        div class="stack capsule border-success" {
+            img id="statsIcon" class="icon icon-medium" alt="Line chart" title="System diagnostics and logs" src="icons/chart.svg";
+            div class="stack" style="padding-top: 0.5rem;" {
+                label class="label-small font-near-black" { "Diagnostics" }
+                label class="label-small font-near-black" { (diagnostics_state) };
+            }
+        }
+    }
+}
+
+fn render_dyndns_capsule() -> Markup {
+    let (state, stack_class, img_class) = match dyndns_client::is_dns_updater_online() {
+        Ok(true) => ("ONLINE", "stack capsule border-success", "icon icon-medium"),
+        Ok(false) => (
+            "OFFLINE",
+            "stack capsule border-warning",
+            "icon icon-inactive icon-medium",
+        ),
+        Err(_) => (
+            "ERROR",
+            "stack capsule border-danger",
+            "icon icon-inactive icon-medium",
+        ),
+    };
+
+    html! {
+        (PreEscaped("<!-- DYNDNS STATUS STACK -->"))
+        div class=(stack_class) {
+            img id="dnsIcon" class=(img_class) alt="Dyndns" title="Dyndns status" src="icons/dns.png";
+            div class="stack" style="padding-top: 0.5rem;" {
+                label class="label-small font-near-black" { "Dyn DNS" }
+                label class="label-small font-near-black" { (state) }
+            }
+        }
+    }
+}
+
+fn render_config_capsule() -> Markup {
+    let (state, stack_class, img_class) =
+        match config_manager::load_peach_config_from_disc().is_ok() {
+            true => ("LOADED", "stack capsule border-success", "icon icon-medium"),
+            false => (
+                "INVALID",
+                "stack capsule border-warning",
+                "icon icon-inactive icon-medium",
+            ),
+        };
+
+    html! {
+        (PreEscaped("<!-- CONFIG STATUS STACK -->"))
+        div class=(stack_class) {
+            img id="configIcon" class=(img_class) alt="Config" title="Config status" src="icons/clipboard.png";
+            div class="stack" style="padding-top: 0.5rem;" {
+                label class="label-small font-near-black" { "Config" }
+                label class="label-small font-near-black" { (state) }
+            }
+        }
+    }
+}
+
+fn render_sbot_capsule() -> Markup {
+    let (state, stack_class, img_class) = match retrieve_sbot_state() {
+        Some(state) if state.as_str() == "active" => {
+            ("active", "stack capsule border-success", "icon icon-medium")
+        }
+        Some(state) if state.as_str() == "inactive" => (
+            "inactive",
+            "stack capsule border-warning",
+            "icon icon-inactive icon-medium",
+        ),
+        Some(state) if state.as_str() == "failed" => (
+            "failed",
+            "stack capsule border-danger",
+            "icon icon-inactive icon-medium",
+        ),
+        _ => (
+            "error",
+            "stack capsule border-danger",
+            "icon icon-inactive icon-medium",
+        ),
+    };
+
+    html! {
+        (PreEscaped("<!-- SBOT STATUS STACK -->"))
+        div class=(stack_class) {
+            img id="sbotIcon" class=(img_class) alt="Sbot" title="Sbot status" src="icons/hermies.svg";
+            div class="stack" style="padding-top: 0.5rem;" {
+                label class="label-small font-near-black" { "Sbot" }
+                label class="label-small font-near-black" { (state.to_uppercase()) }
+            }
+        }
+    }
+}
+
+fn render_cpu_usage_meter(cpu_usage_percent: Option<CpuStatPercentages>) -> Markup {
+    html! {
+       @if let Some(cpu_usage) = cpu_usage_percent {
+           @let cpu_usage_total = (cpu_usage.nice + cpu_usage.system + cpu_usage.user).round();
+            div class="flex-grid" {
+                span class="card-text" { "CPU" }
+                span class="label-small push-right" { (cpu_usage_total) "%" }
+            }
+            meter value=(cpu_usage_total) min="0" max="100" title="CPU usage" {
+                div class="meter-gauge" {
+                    span style={ "width: " (cpu_usage_total) "%;" } {
+                        "CPU Usage"
                     }
-                } else {
-                    dyndns_is_online = false;
                 }
             }
-            Err(_err) => {
-                dyndns_enabled = false;
-                dyndns_is_online = false;
-                config_is_valid = false;
+        } @else {
+            p class="card-text" { "CPU usage data unavailable" }
+        }
+    }
+}
+
+fn render_mem_usage_meter(mem_stats: Option<MemStat>) -> Markup {
+    html! {
+        @if let Some(mem) = mem_stats {
+            // convert kilobyte values to megabyte values
+            @let mem_free_mb = mem.free / 1024;
+            @let mem_total_mb = mem.total / 1024;
+            @let mem_used_mb = mem.used / 1024;
+            // calculate memory usage as a percentage
+            @let mem_used_percent = mem_used_mb * 100 / mem_total_mb;
+            // render disk free value as megabytes or gigabytes based on size
+            @let mem_free_value = if mem_free_mb > 1024 {
+                format!("{} GB", (mem_free_mb / 1024))
+            } else {
+                format!("{} MB", mem_free_mb)
+            };
+
+            div class="flex-grid" {
+                span class="card-text" { "Memory" }
+                span class="label-small push-right" { (mem_used_percent) "% (" (mem_free_value) " free)" }
+            }
+            meter value=(mem_used_mb) min="0" max=(mem_total_mb) title="Memory usage" {
+                div class="meter-gauge" {
+                    span style={ "width: " (mem_used_percent) "%;" } { "Memory Usage" }
+                }
+            }
+        } @else {
+            p class="card-text" { "Memory usage data unavailable" }
+        }
+    }
+}
+
+fn render_disk_usage_meter() -> Markup {
+    let disk_usage_stats = match stats::disk_usage() {
+        Ok(disks) => disks,
+        Err(_) => Vec::new(),
+    };
+
+    // select only the partition we're interested in: /dev/mmcblk0p2 ("/")
+    let disk_usage = disk_usage_stats.iter().find(|disk| disk.mountpoint == "/");
+
+    html! {
+        @if let Some(disk) = disk_usage {
+            // calculate free disk space in megabytes
+            @let disk_free_mb = disk.one_k_blocks_free / 1024;
+            // calculate free disk space in gigabytes
+            @let disk_free_gb = disk_free_mb / 1024;
+            // render disk free value as megabytes or gigabytes based on size
+            @let disk_free_value = if disk_free_mb > 1024 {
+                format!("{} GB", disk_free_gb)
+            } else {
+                format!("{} MB", disk_free_mb)
+            };
+
+            div class="flex-grid" {
+                span class="card-text" { "Disk" }
+                span class="label-small push-right" { (disk.used_percentage) "% (" (disk_free_value) " free)" }
+            }
+            meter value=(disk.used_percentage) min="0" max="100" title="Disk usage" {
+                div class="meter-gauge" {
+                    span style={ "width: " (disk.used_percentage) "%;" } {
+                        "Disk Usage"
+                    }
+                }
+            }
+        } @else {
+            p class="card-text" { "Disk usage data unavailable" }
+        }
+    }
+}
+
+/// Display system uptime in hours and minutes.
+fn render_uptime_capsule(uptime: Option<u64>) -> Markup {
+    html! {
+        @if let Some(uptime_secs) = uptime {
+            @let uptime_mins = uptime_secs / 60;
+            @if uptime_mins < 60 {
+                // display system uptime in minutes
+                p class="capsule center-text" {
+                    "Uptime: " (uptime_mins) " minutes"
+                }
+            } @else {
+                // display system uptime in hours and minutes
+                @let hours = uptime_mins / 60;
+                @let mins = uptime_mins % 60;
+                p class="capsule center-text" {
+                    "Uptime: " (hours) " hours, " (mins) " minutes"
+                }
+            }
+        } @else {
+            p class="card-text" { "Uptime data unavailable" }
+        }
+    }
+}
+
+/// Device status template builder.
+pub fn build_template() -> PreEscaped<String> {
+    let (uptime, oled_state) = retrieve_device_status_data();
+    let (cpu_usage, mem_usage) = retrieve_device_usage_data();
+
+    let device_status_template = html! {
+        (PreEscaped("<!-- DEVICE STATUS CARD -->"))
+        div class="card center" {
+            div class="card-container" {
+                // display status capsules for network, oled and diagnostics
+                div class="three-grid" {
+                    (render_network_capsule())
+                    (render_oled_capsule(oled_state))
+                    (render_diagnostics_capsule())
+                }
+                // display status capsules for dyndns, config and sbot
+                div class="three-grid" style="padding-top: 1rem; padding-bottom: 1rem;" {
+                    (render_dyndns_capsule())
+                    (render_config_capsule())
+                    (render_sbot_capsule())
+                }
+                (render_cpu_usage_meter(cpu_usage))
+                (render_mem_usage_meter(mem_usage))
+                (render_disk_usage_meter())
+                (render_uptime_capsule(uptime))
             }
         }
-
-        // test if go-sbot is running
-        let sbot_status = SbotStatus::read();
-        let sbot_is_online: bool = match sbot_status {
-            // return true if state is active
-            Ok(status) => matches!(status.state == Some("active".to_string()), true),
-            _ => false,
-        };
-
-        StatusContext {
-            back: None,
-            cpu_stat_percent,
-            disk_stats,
-            flash_name: None,
-            flash_msg: None,
-            load_average,
-            mem_stats,
-            network_ping,
-            oled_ping,
-            dyndns_enabled,
-            dyndns_is_online,
-            config_is_valid,
-            sbot_is_online,
-            title: None,
-            uptime: uptime_parsed,
-        }
-    }
-}
-
-#[get("/")]
-pub fn device_status(flash: Option<FlashMessage>, _auth: Authenticated) -> Template {
-    // assign context through context_builder call
-    let mut context = StatusContext::build();
-    context.back = Some("/".to_string());
-    context.title = Some("Device Status".to_string());
-    // check to see if there is a flash message to display
-    if let Some(flash) = flash {
-        // add flash message contents to the context object
-        context.flash_name = Some(flash.kind().to_string());
-        context.flash_msg = Some(flash.message().to_string());
     };
-    // template_dir is set in Rocket.toml
-    Template::render("status/device", &context)
-}
-
-// HELPERS AND ROUTES FOR /power/reboot
-
-/// Executes a system command to reboot the device immediately.
-pub fn reboot() -> io::Result<Output> {
-    info!("Rebooting the device");
-    // ideally, we'd like to reboot after 5 seconds to allow time for JSON
-    // response but this is not possible with the `shutdown` command alone.
-    // TODO: send "rebooting..." message to `peach-oled` for display
-    Command::new("sudo")
-        .arg("shutdown")
-        .arg("-r")
-        .arg("now")
-        .output()
-}
-
-#[get("/power/reboot")]
-pub fn reboot_cmd(_auth: Authenticated) -> Flash<Redirect> {
-    match reboot() {
-        Ok(_) => Flash::success(Redirect::to("/power"), "Rebooting the device"),
-        Err(_) => Flash::error(Redirect::to("/power"), "Failed to reboot the device"),
-    }
-}
-
-// HELPERS AND ROUTES FOR /power/shutdown
-
-/// Executes a system command to shutdown the device immediately.
-pub fn shutdown() -> io::Result<Output> {
-    info!("Shutting down the device");
-    // ideally, we'd like to reboot after 5 seconds to allow time for JSON
-    // response but this is not possible with the `shutdown` command alone.
-    // TODO: send "shutting down..." message to `peach-oled` for display
-    Command::new("sudo").arg("shutdown").arg("now").output()
-}
-
-#[get("/power/shutdown")]
-pub fn shutdown_cmd(_auth: Authenticated) -> Flash<Redirect> {
-    match shutdown() {
-        Ok(_) => Flash::success(Redirect::to("/power"), "Shutting down the device"),
-        Err(_) => Flash::error(Redirect::to("/power"), "Failed to shutdown the device"),
-    }
-}
-
-// HELPERS AND ROUTES FOR /power
-
-#[derive(Debug, Serialize)]
-pub struct PowerContext {
-    pub back: Option<String>,
-    pub flash_name: Option<String>,
-    pub flash_msg: Option<String>,
-    pub title: Option<String>,
-}
-
-impl PowerContext {
-    pub fn build() -> PowerContext {
-        PowerContext {
-            back: None,
-            flash_name: None,
-            flash_msg: None,
-            title: None,
-        }
-    }
-}
-
-#[get("/power")]
-pub fn power_menu(flash: Option<FlashMessage>, _auth: Authenticated) -> Template {
-    let mut context = PowerContext::build();
-    context.back = Some("/".to_string());
-    context.title = Some("Power Menu".to_string());
-    // check to see if there is a flash message to display
-    if let Some(flash) = flash {
-        // add flash message contents to the context object
-        context.flash_name = Some(flash.kind().to_string());
-        context.flash_msg = Some(flash.message().to_string());
-    };
-    Template::render("power", &context)
+
+    let body = templates::nav::build_template(device_status_template, "Device Status", Some("/"));
+
+    let theme = theme::get_theme();
+
+    templates::base::build_template(body, theme)
 }

peach-web/src/routes/status/mod.rs

@@ -1,3 +1,3 @@
-//pub mod device;
-//pub mod network;
+pub mod device;
+pub mod network;
 pub mod scuttlebutt;

peach-web/src/routes/status/network.rs

@@ -1,21 +1,285 @@
-use rocket::{get, request::FlashMessage};
-use rocket_dyn_templates::Template;
+use maud::{html, Markup, PreEscaped};
+use peach_network::network;
+use vnstat_parse::Vnstat;
 
-use crate::context::network::NetworkStatusContext;
-use crate::routes::authentication::Authenticated;
+use crate::{templates, utils::theme, AP_IFACE, WLAN_IFACE};
 
-// HELPERS AND ROUTES FOR /status/network
+enum NetworkState {
+    AccessPoint,
+    WiFiClient,
+}
 
-#[get("/network")]
-pub fn network_status(flash: Option<FlashMessage>, _auth: Authenticated) -> Template {
-    let mut context = NetworkStatusContext::build();
-    context.back = Some("/status".to_string());
-    context.title = Some("Network Status".to_string());
+// ROUTE: /status/network
 
-    if let Some(flash) = flash {
-        context.flash_name = Some(flash.kind().to_string());
-        context.flash_msg = Some(flash.message().to_string());
+/// Render the cog icon which is used as a link to the network settings page.
+fn render_network_config_icon() -> Markup {
+    html! {
+        (PreEscaped("<!-- top-right config icon -->"))
+        a class="link two-grid-top-right" href="/settings/network" title="Configure network settings" {
+            img id="configureNetworking" class="icon-small" src="/icons/cog.svg" alt="Configure";
+        }
+    }
+}
+
+/// Render the network mode icon, either a WiFi signal or router, based
+/// on the state of the AP and WiFi interfaces.
+///
+/// A router icon is shown if the AP is online (interface is "up").
+///
+/// A WiFi signal icon is shown if the AP interface is down. The colour of
+/// the icon is black if the WLAN interface is up and gray if it's down.
+fn render_network_mode_icon(state: &NetworkState) -> Markup {
+    // TODO: make this DRYer
+    let (icon_class, icon_src, icon_alt, label_title, label_value) = match state {
+        NetworkState::AccessPoint => (
+            "center icon icon-active",
+            "/icons/router.svg",
+            "WiFi router",
+            "Access Point Online",
+            "ONLINE",
+        ),
+        NetworkState::WiFiClient => match network::state(WLAN_IFACE) {
+            Ok(Some(state)) if state == "up" => (
+                "center icon icon-active",
+                "/icons/wifi.svg",
+                "WiFi signal",
+                "WiFi Client Online",
+                "ONLINE",
+            ),
+            _ => (
+                "center icon icon-inactive",
+                "/icons/wifi.svg",
+                "WiFi signal",
+                "WiFi Client Offline",
+                "OFFLINE",
+            ),
+        },
     };
 
-    Template::render("status/network", &context)
+    html! {
+        (PreEscaped("<!-- network mode icon with label -->"))
+        div class="grid-column-1" {
+            img id="netModeIcon" class=(icon_class) src=(icon_src) alt=(icon_alt);
+            label id="netModeLabel" for="netModeIcon" class="center label-small font-gray" title=(label_title) { (label_value) }
+        }
+    }
+}
+
+/// Render the network data associated with the deployed access point or
+/// connected WiFi client depending on active mode.
+///
+/// Data includes the network mode (access point or WiFi client), SSID and IP
+/// address.
+fn render_network_data(state: &NetworkState, ssid: String, ip: String) -> Markup {
+    let (mode_value, mode_title, ssid_value, ip_title) = match state {
+        NetworkState::AccessPoint => (
+            "Access Point",
+            "Access Point SSID",
+            // TODO: remove hardcoding of this value (query interface instead)
+            "peach",
+            "Access Point IP Address",
+        ),
+        NetworkState::WiFiClient => (
+            "WiFi Client",
+            "WiFi SSID",
+            ssid.as_str(),
+            "WiFi Client IP Address",
+        ),
+    };
+
+    html! {
+        (PreEscaped("<!-- network mode, ssid & ip with labels -->"))
+        div class="grid-column-2" {
+            label class="label-small font-gray" for="netMode" title="Network Mode" { "MODE" }
+            p id="netMode" class="card-text" title="Network Mode" { (mode_value) }
+            label class="label-small font-gray" for="netSsid" title=(mode_title) { "SSID" }
+            p id="netSsid" class="card-text" title="SSID" { (ssid_value) }
+            label class="label-small font-gray" for="netIp" title=(ip_title) { "IP" }
+            p id="netIp" class="card-text" title="IP" { (ip) }
+        }
+    }
+}
+
+/// Render the network status grid comprised of the network config icon,
+/// network mode icon and network data text.
+fn render_network_status_grid(state: &NetworkState, ssid: String, ip: String) -> Markup {
+    html! {
+        (PreEscaped("<!-- NETWORK STATUS GRID -->"))
+        div class="two-grid" title="PeachCloud network mode and status" {
+            (render_network_config_icon())
+            (PreEscaped("<!-- left column -->"))
+            (render_network_mode_icon(state))
+            (PreEscaped("<!-- right column -->"))
+            (render_network_data(state, ssid, ip))
+        }
+    }
+}
+
+/// Render the signal strength stack comprised of a signal icon, RSSI value
+/// and label.
+///
+/// This stack is displayed when the network mode is set to WiFi
+/// client (ie. the value reported is the strength of the connection of the
+/// local WiFi interface to a remote access point).
+fn render_signal_strength_stack() -> Markup {
+    let wlan_rssi = match network::rssi(WLAN_IFACE) {
+        Ok(Some(rssi)) => rssi,
+        _ => 0.to_string(),
+    };
+
+    html! {
+        div class="stack" {
+            img id="netSignal" class="icon icon-medium" alt="Signal" title="WiFi Signal (%)" src="/icons/low-signal.svg";
+            div class="flex-grid" style="padding-top: 0.5rem;" {
+                label class="label-medium" for="netSignal" style="padding-right: 3px;" title="Signal strength of WiFi connection (%)" { (wlan_rssi) }
+            }
+            label class="label-small font-gray" { "SIGNAL" }
+        }
+    }
+}
+
+/// Render the connected devices stack comprised of a devices icon, value
+/// of connected devices and label.
+///
+/// This stack is displayed when the network mode is set to access point
+/// (ie. the value reported is the number of remote devices connected to the
+/// local access point).
+fn render_connected_devices_stack() -> Markup {
+    html! {
+        div class="stack" {
+            img id="devices" class="icon icon-medium" title="Connected devices" src="/icons/devices.svg" alt="Digital devices";
+            div class="flex-grid" style="padding-top: 0.5rem;" {
+                label class="label-medium" for="devices" style="padding-right: 3px;" title="Number of connected devices";
+            }
+            label class="label-small font-gray" { "DEVICES" }
+        }
+    }
+}
+
+/// Render the data download stack comprised of a download icon, traffic value
+/// and label.
+///
+/// A zero value is displayed if no interface traffic is available for the
+/// WLAN interface.
+fn render_data_download_stack(iface_traffic: &Option<Vnstat>) -> Markup {
+    html! {
+        div class="stack" {
+            img id="dataDownload" class="icon icon-medium" title="Download" src="/icons/down-arrow.svg" alt="Download";
+            div class="flex-grid" style="padding-top: 0.5rem;" {
+                @if let Some(traffic) = iface_traffic {
+                    label class="label-medium" for="dataDownload" style="padding-right: 3px;" title={ "Data download total in " (traffic.all_time_rx_unit) } { (traffic.all_time_rx) }
+                    label class="label-small font-near-black" { (traffic.all_time_rx_unit) }
+                } @else {
+                    label class="label-medium" for="dataDownload" style="padding-right: 3px;" title="Data download total" { "0" }
+                    label class="label-small font-near-black";
+                }
+            }
+            label class="label-small font-gray" { "DOWNLOAD" }
+        }
+    }
+}
+
+/// Render the data upload stack comprised of an upload icon, traffic value
+/// and label.
+///
+/// A zero value is displayed if no interface traffic is available for the
+/// WLAN interface.
+fn render_data_upload_stack(iface_traffic: Option<Vnstat>) -> Markup {
+    html! {
+        div class="stack" {
+            img id="dataUpload" class="icon icon-medium" title="Upload" src="/icons/up-arrow.svg" alt="Upload";
+            div class="flex-grid" style="padding-top: 0.5rem;" {
+                @if let Some(traffic) = iface_traffic {
+                    label class="label-medium" for="dataUpload" style="padding-right: 3px;" title={ "Data upload total in " (traffic.all_time_tx_unit) } { (traffic.all_time_tx) }
+                    label class="label-small font-near-black" { (traffic.all_time_tx_unit) }
+                } @else {
+                    label class="label-medium" for="dataUpload" style="padding-right: 3px;" title="Data upload total" { "0" }
+                    label class="label-small font-near-black";
+                }
+            }
+            label class="label-small font-gray" { "UPLOAD" }
+        }
+    }
+}
+
+/// Render the device / signal and traffic grid.
+///
+/// The connected devices stack is displayed if the network mode is set to
+/// access point and the signal strength stack is displayed if the network
+/// mode is set to WiFi client.
+fn render_device_and_traffic_grid(state: NetworkState, iface_traffic: Option<Vnstat>) -> Markup {
+    html! {
+        div class="three-grid card-container" {
+            @match state {
+                NetworkState::AccessPoint => (render_connected_devices_stack()),
+                NetworkState::WiFiClient => (render_signal_strength_stack()),
+            }
+            (render_data_download_stack(&iface_traffic))
+            (render_data_upload_stack(iface_traffic))
+        }
+    }
+}
+
+/// Network state data retrieval.
+///
+/// This data is injected into the template rendering functions.
+fn retrieve_network_data() -> (NetworkState, Option<Vnstat>, String, String) {
+    // if the access point interface is "up",
+    // retrieve the traffic stats, ip and ssidfor the ap interface.
+    // otherwise retrieve the stats and ip for the wlan interface.
+    let (state, traffic, ip, ssid) = match network::state(AP_IFACE) {
+        Ok(Some(state)) if state == "up" => {
+            let ap_traffic = Vnstat::get(AP_IFACE).ok();
+
+            let ap_ip = match network::ip(AP_IFACE) {
+                Ok(Some(ip)) => ip,
+                _ => String::from("x.x.x.x"),
+            };
+
+            let ap_ssid = String::from("peach");
+
+            (NetworkState::AccessPoint, ap_traffic, ap_ip, ap_ssid)
+        }
+        _ => {
+            let wlan_traffic = Vnstat::get(WLAN_IFACE).ok();
+
+            let wlan_ip = match network::ip(WLAN_IFACE) {
+                Ok(Some(ip)) => ip,
+                _ => String::from("x.x.x.x"),
+            };
+
+            let wlan_ssid = match network::ssid(WLAN_IFACE) {
+                Ok(Some(ssid)) => ssid,
+                _ => String::from("Not connected"),
+            };
+
+            (NetworkState::WiFiClient, wlan_traffic, wlan_ip, wlan_ssid)
+        }
+    };
+
+    (state, traffic, ip, ssid)
+}
+
+/// Network status template builder.
+pub fn build_template() -> PreEscaped<String> {
+    let (state, traffic, ip, ssid) = retrieve_network_data();
+
+    let network_status_template = html! {
+        (PreEscaped("<!-- NETWORK STATUS CARD -->"))
+        div class="card center" {
+            (PreEscaped("<!-- NETWORK INFO BOX -->"))
+            div class="capsule capsule-container success-border" {
+                (render_network_status_grid(&state, ssid, ip))
+                hr style="color: var(--light-gray);";
+                (render_device_and_traffic_grid(state, traffic))
+            }
+        }
+    };
+
+    let body =
+        templates::nav::build_template(network_status_template, "Network Status", Some("/status"));
+
+    let theme = theme::get_theme();
+
+    templates::base::build_template(body, theme)
 }

peach-web/src/templates/nav.rs

@@ -14,7 +14,7 @@ pub fn build_template(
     let theme = theme::get_theme();
 
     // conditionally render the hermies icon and theme-switcher icon with correct link
-    let (hermies, switcher) = match theme.as_str() {
+    let (hermies, theme_switcher) = match theme.as_str() {
         // if we're using the dark theme, render light icons and "light" query param
         "dark" => (
             "/icons/hermies_hex_light.svg",
@@ -56,8 +56,7 @@ pub fn build_template(
             a class="nav-item" href="/" {
                 img class="icon nav-icon-left" src="/icons/peach-icon.png" alt="PeachCloud" title="Home";
             }
-            // render the pre-defined theme-switcher icon
-            (switcher)
+            (theme_switcher)
         }
     }
 }

peach-web/src/utils/sbot.rs

@@ -12,7 +12,11 @@ use async_std::task;
 use dirs;
 use futures::stream::TryStreamExt;
 use golgi::{
-    api::friends::RelationshipQuery, blobs, messages::SsbMessageKVT, sbot::Keystore, Sbot,
+    api::{friends::RelationshipQuery, history_stream::CreateHistoryStream},
+    blobs,
+    messages::SsbMessageKVT,
+    sbot::Keystore,
+    Sbot,
 };
 use log::debug;
 use peach_lib::config_manager;
@@ -133,7 +137,8 @@ pub fn latest_sequence_number() -> Result<u64, Box<dyn Error>> {
         // retrieve the local id
         let id = sbot_client.whoami().await?;
 
-        let history_stream = sbot_client.create_history_stream(id).await?;
+        let args = CreateHistoryStream::new(id).keys_values(true, true);
+        let history_stream = sbot_client.create_history_stream(args).await?;
         let mut msgs: Vec<SsbMessageKVT> = history_stream.try_collect().await?;
 
         // there will be zero messages when the sbot is run for the first time