smokesignal / src / http / handle_admin_profile_index.rs

use anyhow::Result;
use axum::{
    Form,
    extract::Query,
    response::{IntoResponse, Redirect},
};
use axum_template::RenderHtml;
use minijinja::context as template_context;
use serde::Deserialize;

use crate::{
    contextual_error,
    http::{
        context::{AdminRequestContext, admin_template_context},
        errors::WebError,
        pagination::{Pagination, PaginationView},
    },
    profile_index::ProfileIndexManager,
    select_template,
};

#[derive(Debug, Deserialize)]
pub(crate) struct SearchIndexQuery {
    #[serde(default)]
    query: Option<String>,
}

#[derive(Debug, Deserialize)]
pub(crate) struct DeleteIndexedProfileForm {
    aturi: String,
}

pub(crate) async fn handle_admin_profile_index(
    admin_ctx: AdminRequestContext,
    pagination: Query<Pagination>,
    search_query: Query<SearchIndexQuery>,
) -> Result<impl IntoResponse, WebError> {
    let canonical_url = format!(
        "https://{}/admin/search-index/profiles",
        admin_ctx.web_context.config.external_base
    );
    let default_context =
        admin_template_context(&admin_ctx, &canonical_url, "search-index-profiles");

    let render_template = select_template!("admin_profile_index", false, false, admin_ctx.language);
    let error_template = select_template!(false, false, admin_ctx.language);

    // Check if OpenSearch is enabled
    let opensearch_endpoint = match admin_ctx.web_context.config.opensearch_endpoint.as_ref() {
        Some(endpoint) => endpoint,
        None => {
            return contextual_error!(
                admin_ctx.web_context,
                admin_ctx.language,
                error_template,
                default_context,
                anyhow::anyhow!("OpenSearch is not enabled")
            );
        }
    };

    // Create profile index manager
    let manager = match ProfileIndexManager::new(opensearch_endpoint) {
        Ok(m) => m,
        Err(err) => {
            return contextual_error!(
                admin_ctx.web_context,
                admin_ctx.language,
                error_template,
                default_context,
                err
            );
        }
    };

    // Get index stats
    let stats = match manager.get_stats().await {
        Ok(s) => s,
        Err(err) => {
            return contextual_error!(
                admin_ctx.web_context,
                admin_ctx.language,
                error_template,
                default_context,
                err
            );
        }
    };

    let (page, page_size) = pagination.admin_clamped();

    // Get profiles (either search or list)
    let (total_count, mut profiles) = if let Some(ref q) = search_query.query {
        if !q.is_empty() {
            match manager.search_indexed_profiles(q, page, page_size).await {
                Ok(result) => result,
                Err(err) => {
                    return contextual_error!(
                        admin_ctx.web_context,
                        admin_ctx.language,
                        error_template,
                        default_context,
                        err
                    );
                }
            }
        } else {
            match manager.list_indexed_profiles(page, page_size).await {
                Ok(result) => result,
                Err(err) => {
                    return contextual_error!(
                        admin_ctx.web_context,
                        admin_ctx.language,
                        error_template,
                        default_context,
                        err
                    );
                }
            }
        }
    } else {
        match manager.list_indexed_profiles(page, page_size).await {
            Ok(result) => result,
            Err(err) => {
                return contextual_error!(
                    admin_ctx.web_context,
                    admin_ctx.language,
                    error_template,
                    default_context,
                    err
                );
            }
        }
    };

    // Build query params for pagination
    let mut params: Vec<(&str, String)> = vec![];
    if let Some(ref q) = search_query.query
        && !q.is_empty()
    {
        params.push(("query", q.clone()));
    }

    let params_refs: Vec<(&str, &str)> = params.iter().map(|(k, v)| (*k, v.as_str())).collect();

    let pagination_view = PaginationView::new(page_size, profiles.len() as i64, page, params_refs);

    if profiles.len() > page_size as usize {
        profiles.truncate(page_size as usize);
    }

    Ok(RenderHtml(
        &render_template,
        admin_ctx.web_context.engine.clone(),
        template_context! { ..default_context, ..template_context! {
            profiles,
            total_count,
            index_stats => stats,
            search_query => search_query.query.clone().unwrap_or_default(),
            pagination => pagination_view,
        }},
    )
    .into_response())
}

pub(crate) async fn handle_admin_profile_index_delete(
    admin_ctx: AdminRequestContext,
    Form(form): Form<DeleteIndexedProfileForm>,
) -> Result<impl IntoResponse, WebError> {
    let error_template = select_template!(false, false, admin_ctx.language);

    // Check if OpenSearch is enabled
    let opensearch_endpoint = match admin_ctx.web_context.config.opensearch_endpoint.as_ref() {
        Some(endpoint) => endpoint,
        None => {
            return contextual_error!(
                admin_ctx.web_context,
                admin_ctx.language,
                error_template,
                template_context! {},
                anyhow::anyhow!("OpenSearch is not enabled")
            );
        }
    };

    // Create profile index manager
    let manager = match ProfileIndexManager::new(opensearch_endpoint) {
        Ok(m) => m,
        Err(err) => {
            return contextual_error!(
                admin_ctx.web_context,
                admin_ctx.language,
                error_template,
                template_context! {},
                err
            );
        }
    };

    // Delete the indexed profile
    if let Err(err) = manager.delete_indexed_profile(&form.aturi).await {
        return contextual_error!(
            admin_ctx.web_context,
            admin_ctx.language,
            error_template,
            template_context! {},
            err
        );
    }

    Ok(Redirect::to("/admin/search-index/profiles").into_response())
}

pub(crate) async fn handle_admin_profile_index_rebuild(
    admin_ctx: AdminRequestContext,
) -> Result<impl IntoResponse, WebError> {
    let error_template = select_template!(false, false, admin_ctx.language);

    // Check if OpenSearch is enabled
    let opensearch_endpoint = match admin_ctx.web_context.config.opensearch_endpoint.as_ref() {
        Some(endpoint) => endpoint,
        None => {
            return contextual_error!(
                admin_ctx.web_context,
                admin_ctx.language,
                error_template,
                template_context! {},
                anyhow::anyhow!("OpenSearch is not enabled")
            );
        }
    };

    // Create profile index manager
    let manager = match ProfileIndexManager::new(opensearch_endpoint) {
        Ok(m) => m,
        Err(err) => {
            return contextual_error!(
                admin_ctx.web_context,
                admin_ctx.language,
                error_template,
                template_context! {},
                err
            );
        }
    };

    // Rebuild the index
    let indexed_count = match manager
        .rebuild_index(
            &admin_ctx.web_context.pool,
            admin_ctx.web_context.identity_resolver.clone(),
        )
        .await
    {
        Ok(count) => count,
        Err(err) => {
            return contextual_error!(
                admin_ctx.web_context,
                admin_ctx.language,
                error_template,
                template_context! {},
                err
            );
        }
    };

    tracing::info!(
        "Profile search index rebuilt: {} profiles indexed",
        indexed_count
    );

    Ok(Redirect::to("/admin/search-index/profiles").into_response())
}