quokka-admin 0.1.0

use axum::Extension;
use quokka::extract::Session;
use quokka_admin::{
    middleware::{
        AdminAuthProvider, AdminLoginProvider, AuthenticatedUser, LoginResult, PermissionContext,
    },
    service::page_loader::ADMIN_USER_SESSION_KEY,
};

use crate::EXAMPLE_SUPER_USER_GROUP;

pub struct TestLoginProvider;

pub struct TestAuthProvider;

impl AdminLoginProvider for TestLoginProvider {
    async fn do_login(
        &self,
        login_data: &quokka_admin::middleware::LoginData,
    ) -> quokka::Result<Option<LoginResult>> {
        if login_data.login_name == "Test" && login_data.password == "Password" {
            tracing::debug!("Got a secure login from the test user!");

            return Ok(Some(LoginResult {
                user_identifier: "Test".to_string(),
            }));
        }

        if login_data.login_name == "Admin" && login_data.password == "Password" {
            tracing::debug!("Got a secure login from the admin user!");

            return Ok(Some(LoginResult {
                user_identifier: "Admin".to_string(),
            }));
        }

        Ok(None)
    }
}

impl<S: Send + Sync + 'static> AdminAuthProvider<S> for TestAuthProvider {
    type AuthParams = Extension<Session>;

    async fn authenticate(
        &self,
        params: Self::AuthParams,
    ) -> quokka::Result<Option<AuthenticatedUser>> {
        let login_name = params
            .0
            .get_extension::<LoginResult>(ADMIN_USER_SESSION_KEY)?
            .user_identifier;

        if login_name == "Test" {
            tracing::debug!("Authenticated a test user successfully");

            return Ok(Some(AuthenticatedUser {
                name: "Test".to_string(),
                groups: Default::default(),
                context: Default::default(),
            }));
        }

        if login_name == "Admin" {
            tracing::debug!("Authenticated a test admin user successfully");

            return Ok(Some(AuthenticatedUser {
                name: "Admin".to_string(),
                groups: vec![EXAMPLE_SUPER_USER_GROUP.to_string()],
                context: Default::default(),
            }));
        }

        Ok(None)
    }

    async fn authorize(
        &self,
        user: &AuthenticatedUser,
        permission: &PermissionContext,
    ) -> quokka::Result<bool> {
        if user.name == "Test" && permission.resource == "/admin" {
            tracing::debug!(?user, ?permission, "Allowed a test user to access resource");

            return Ok(true);
        }

        Ok(false)
    }
}