hyaenidae/server/src/nav.rs

use crate::{admin::Admin, profiles::Profile};
use actix_web::{dev::Payload, web::Query, FromRequest, HttpRequest};
use futures_core::future::LocalBoxFuture;
use hyaenidae_accounts::LogoutState;
use hyaenidae_toolkit::Button;

impl FromRequest for NavState {
    type Config = ();
    type Error = actix_web::Error;
    type Future = LocalBoxFuture<'static, Result<Self, Self::Error>>;

    fn from_request(req: &HttpRequest, _: &mut Payload) -> Self::Future {
        let profile = Option::<Profile>::extract(req);
        let logout = Option::<LogoutState>::extract(req);
        let query = Option::<Query<Vec<(String, String)>>>::extract(req);
        let admin = Option::<Admin>::extract(req);
        let path = req.uri().path().to_owned();

        Box::pin(async move {
            let profile = profile.await?;
            let logout = logout.await?;
            let query = query.await?;
            let admin = admin.await?;

            let dark = true;
            let mut nav = vec![];

            if let Some(logout_state) = logout {
                let submission = Button::primary("New Submission");
                let account = Button::secondary("Account");
                let logout = Button::primary_outline("Logout");
                logout_state.button(&logout);

                submission.href("/submissions/create").dark(dark);
                account.href("/session/account").dark(dark);
                logout.dark(dark);

                let profile = if let Some(profile) = profile {
                    let btn = Button::secondary("Profile");
                    btn.href(&profile.view_path()).dark(dark);
                    btn
                } else {
                    let btn = Button::secondary("Switch Profile");
                    btn.href("/profiles/change").dark(dark);
                    btn
                };

                nav.push(submission);
                nav.push(profile);
                nav.push(account);
                if admin.is_some() {
                    let admin = Button::secondary("Admin");
                    admin.href("/admin").dark(dark);
                    nav.push(admin);
                }
                nav.push(logout);
            } else {
                let login = Button::primary_outline("Login");
                let register = Button::primary_outline("Register");

                login.href("/session/auth/login").dark(dark);
                register.href("/session/auth/register").dark(dark);

                nav.push(login);
                nav.push(register);
            }

            if let Some(query) = query {
                let mut is_open = false;
                let query = query
                    .into_inner()
                    .into_iter()
                    .filter_map(|(key, value)| {
                        if key == "show_nav" {
                            is_open = true;
                            None
                        } else {
                            Some(format!("{}={}", key, value))
                        }
                    })
                    .collect::<Vec<String>>()
                    .join("&");

                let query = if is_open {
                    query
                } else {
                    format!("{}&show_nav=true", query)
                };

                Ok(NavState {
                    buttons: nav,
                    href: format!("{}?{}", path, query),
                    is_open,
                    dark,
                })
            } else {
                Ok(NavState {
                    buttons: nav,
                    href: format!("{}?show_nav=true", path),
                    is_open: false,
                    dark,
                })
            }
        })
    }
}

pub struct NavState {
    buttons: Vec<Button>,
    href: String,
    is_open: bool,
    dark: bool,
}

impl NavState {
    pub(crate) fn buttons(&self) -> Vec<&Button> {
        self.buttons.iter().collect()
    }

    pub(crate) fn href(&self) -> &str {
        &self.href
    }

    pub(crate) fn class_string(&self) -> &str {
        if self.is_open {
            "nav-open"
        } else {
            "nav-closed"
        }
    }

    pub(crate) fn dark(&self) -> bool {
        self.dark
    }
}