librjss 2.2.2

Robust client library for Juragan Subsystem
Documentation
use crate::api::auth::AuthEndpoints;
use crate::client::RjssClient;
use crate::handler::error::JssError;
use crate::handler::types::login::{LoginApiMessage, LoginApiResponse};
use crate::handler::types::session::SessionInfo;
use secrecy::{ExposeSecret, SecretString};
use sha2::{Digest, Sha256};
use tracing::{debug, info, instrument, trace, warn};

use super::app_parser::{extract_app_data, fetch_app_page};

#[instrument(skip(client, email, password), fields(trace_id = client.trace_id))]
pub(crate) async fn login_with_credentials(
    client: &mut RjssClient,
    email: SecretString,
    password: SecretString,
) -> Result<(), JssError> {
    let login_url = RjssClient::login_url(&client.config.base_url)?;

    let email_hash = format!("{:x}", Sha256::digest(email.expose_secret().as_bytes()));
    info!(trace_id = client.trace_id, email_hash = %email_hash, "Login attempt");

    let params = [
        ("usr", email.expose_secret()),
        ("pwd", password.expose_secret()),
    ];

    let resp = client.http.post(login_url).form(&params).send().await?;

    let status = resp.status();
    if status == reqwest::StatusCode::TOO_MANY_REQUESTS {
        let retry_after = resp
            .headers()
            .get("Retry-After")
            .and_then(|v| v.to_str().ok())
            .and_then(|v| v.parse::<u64>().ok());
        warn!(trace_id = client.trace_id, "Rate limited");
        return Err(JssError::RateLimited { retry_after });
    }

    if status != reqwest::StatusCode::OK {
        let _body = resp.text().await.unwrap_or_default();
        warn!(trace_id = client.trace_id, %status, "Login failed");
        return Err(JssError::Auth(format!("Login failed: HTTP {status}")));
    }

    let body_text = resp.text().await?;
    trace!(trace_id = client.trace_id, %body_text, "Raw login response body");
    debug!(
        trace_id = client.trace_id,
        body_hash = format!("{:x}", Sha256::digest(body_text.as_bytes())),
        "Login response received"
    );

    let v: serde_json::Value = serde_json::from_str(&body_text)
        .map_err(|e| JssError::Parse(format!("Login response not valid JSON: {e}")))?;

    let login_resp = if v["message"].as_str() == Some("Logged In") {
        debug!(
            trace_id = client.trace_id,
            "Login response has string message 'Logged In'"
        );
        LoginApiResponse {
            message: LoginApiMessage {
                sid: String::new(),
                full_name: v["full_name"].as_str().map(|s| s.to_string()),
            },
        }
    } else {
        serde_json::from_value::<LoginApiResponse>(v)
            .map_err(|e| JssError::Parse(format!("Failed to parse login response: {e}")))?
    };

    let app_html = fetch_app_page(client).await?;
    let (csrf_token, boot_data) = extract_app_data(&app_html)?;

    client.boot = Some(boot_data.clone());

    let user = &boot_data.user;
    let roles = user.roles.clone();
    let full_name = if user.full_name.is_empty() {
        login_resp.message.full_name
    } else {
        Some(user.full_name.clone())
    };
    let sitename = boot_data.sitename.clone();

    if let Some(expected) = &client.config.expected_sitename {
        if expected != &sitename {
            warn!(trace_id = client.trace_id, expected = %expected, actual = %sitename, "Sitename mismatch");
            return Err(JssError::SitenameMismatch {
                expected: expected.clone(),
                actual: sitename,
            });
        }
        debug!(trace_id = client.trace_id, sitename = %sitename, "Sitename verified");
    }

    if !client.config.required_roles.is_empty() {
        let has_role = client
            .config
            .required_roles
            .iter()
            .any(|r| roles.contains(r));
        if !has_role {
            warn!(trace_id = client.trace_id, ?roles, required = ?client.config.required_roles, "Missing required roles");
            return Err(JssError::Permission(format!(
                "Missing one of required roles: {:?}",
                client.config.required_roles
            )));
        }
    }

    client.session = Some(SessionInfo {
        sid: SecretString::new(Box::from(login_resp.message.sid)),
        csrf_token,
        full_name,
        sitename,
        roles,
    });

    info!(trace_id = client.trace_id, email_hash = %email_hash, "Login successful");
    Ok(())
}