k-frame/crates/adapters/http-api/src/routes/widgets.rs

use crate::AppState;
use crate::extractors::AuthUser;
use api_types::{CreateWidgetDto, WidgetDto};
use application::ConfigService;
use axum::{
    extract::{Path, State},
    http::StatusCode,
    response::Json,
};
use domain::{ConfigRepository, EventPublisher, WidgetStateReader};

type S<C, E, W, B, R, A, H> = State<AppState<C, E, W, B, R, A, H>>;

pub async fn list_widgets<C, E, W, B, R, A, H>(
    _auth: AuthUser,
    State(state): S<C, E, W, B, R, A, H>,
) -> Result<Json<Vec<WidgetDto>>, StatusCode>
where
    C: ConfigRepository,
    C::Error: std::fmt::Debug,
    E: EventPublisher,
    E::Error: std::fmt::Debug,
{
    let widgets = state
        .config
        .list_widgets()
        .await
        .map_err(|_| StatusCode::INTERNAL_SERVER_ERROR)?;
    Ok(Json(widgets.iter().map(WidgetDto::from).collect()))
}

pub async fn get_widget<C, E, W, B, R, A, H>(
    _auth: AuthUser,
    State(state): S<C, E, W, B, R, A, H>,
    Path(id): Path<u16>,
) -> Result<Json<WidgetDto>, StatusCode>
where
    C: ConfigRepository,
    C::Error: std::fmt::Debug,
    E: EventPublisher,
    E::Error: std::fmt::Debug,
{
    let widget = state
        .config
        .get_widget(id)
        .await
        .map_err(|_| StatusCode::INTERNAL_SERVER_ERROR)?;
    match widget {
        Some(w) => Ok(Json(WidgetDto::from(&w))),
        None => Err(StatusCode::NOT_FOUND),
    }
}

pub async fn create_widget<C, E, W, B, R, A, H>(
    _auth: AuthUser,
    State(state): S<C, E, W, B, R, A, H>,
    Json(body): Json<CreateWidgetDto>,
) -> Result<StatusCode, (StatusCode, String)>
where
    C: ConfigRepository,
    C::Error: std::fmt::Debug,
    E: EventPublisher,
    E::Error: std::fmt::Debug,
{
    let widget = body
        .into_domain()
        .map_err(|e| (StatusCode::BAD_REQUEST, e))?;
    let svc = ConfigService::new(state.config.as_ref(), state.events.as_ref());
    svc.create_widget(widget)
        .await
        .map_err(|e| (StatusCode::INTERNAL_SERVER_ERROR, format!("{e}")))?;
    Ok(StatusCode::CREATED)
}

pub async fn update_widget<C, E, W, B, R, A, H>(
    _auth: AuthUser,
    State(state): S<C, E, W, B, R, A, H>,
    Path(_id): Path<u16>,
    Json(body): Json<CreateWidgetDto>,
) -> Result<StatusCode, (StatusCode, String)>
where
    C: ConfigRepository,
    C::Error: std::fmt::Debug,
    E: EventPublisher,
    E::Error: std::fmt::Debug,
{
    let widget = body
        .into_domain()
        .map_err(|e| (StatusCode::BAD_REQUEST, e))?;
    let svc = ConfigService::new(state.config.as_ref(), state.events.as_ref());
    svc.update_widget(widget)
        .await
        .map_err(|e| (StatusCode::INTERNAL_SERVER_ERROR, format!("{e}")))?;
    Ok(StatusCode::OK)
}

pub async fn delete_widget<C, E, W, B, R, A, H>(
    _auth: AuthUser,
    State(state): S<C, E, W, B, R, A, H>,
    Path(id): Path<u16>,
) -> Result<StatusCode, StatusCode>
where
    C: ConfigRepository,
    C::Error: std::fmt::Debug,
    E: EventPublisher,
    E::Error: std::fmt::Debug,
{
    let svc = ConfigService::new(state.config.as_ref(), state.events.as_ref());
    svc.delete_widget(id)
        .await
        .map_err(|_| StatusCode::INTERNAL_SERVER_ERROR)?;
    Ok(StatusCode::NO_CONTENT)
}

pub async fn preview_widget<C, E, W, B, R, A, H>(
    _auth: AuthUser,
    State(state): S<C, E, W, B, R, A, H>,
    Path(id): Path<u16>,
) -> Result<Json<serde_json::Value>, StatusCode>
where
    C: ConfigRepository,
    C::Error: std::fmt::Debug,
    E: EventPublisher,
    E::Error: std::fmt::Debug,
    W: WidgetStateReader,
{
    match state.widget_states.get_widget_state(id).await {
        Some(ws) => {
            let map: serde_json::Map<String, serde_json::Value> =
                ws.data.iter().map(|(k, v)| (k.clone(), v.into())).collect();
            Ok(Json(serde_json::Value::Object(map)))
        }
        None => Err(StatusCode::NOT_FOUND),
    }
}