headless_lms_server/controllers/main_frontend/courses/

chatbots.rs

//! Controllers for requests starting with `/api/v0/main-frontend/{course_id}/chatbots`.
use crate::prelude::*;

use headless_lms_models::chatbot_configurations::NewChatbotConf;
use models::chatbot_configurations::ChatbotConfiguration;
use utoipa::OpenApi;

#[derive(OpenApi)]
#[openapi(paths(
    get_chatbots,
    create_chatbot,
    set_default_chatbot,
    set_non_default_chatbot
))]
pub(crate) struct MainFrontendCourseChatbotsApiDoc;

/// GET `/api/v0/main-frontend/courses/{course_id}/chatbots`
#[utoipa::path(
    get,
    path = "",
    operation_id = "getCourseChatbots",
    tag = "courses",
    params(
        ("course_id" = String, Path, description = "Course id")
    ),
    responses(
        (status = 200, description = "Course chatbots", body = Vec<ChatbotConfiguration>)
    )
)]
#[instrument(skip(pool))]
async fn get_chatbots(
    course_id: web::Path<Uuid>,
    pool: web::Data<PgPool>,
    user: AuthUser,
) -> ControllerResult<web::Json<Vec<ChatbotConfiguration>>> {
    let mut conn = pool.acquire().await?;
    let token = authorize(&mut conn, Act::Edit, Some(user.id), Res::Course(*course_id)).await?;

    let configurations =
        models::chatbot_configurations::get_for_course(&mut conn, *course_id).await?;
    token.authorized_ok(web::Json(configurations))
}

/// POST `/api/v0/main-frontend/courses/{course_id}/chatbots`
#[utoipa::path(
    post,
    path = "",
    operation_id = "createCourseChatbot",
    tag = "courses",
    params(
        ("course_id" = String, Path, description = "Course id")
    ),
    request_body(
        content = String,
        description = "JSON string literal chatbot name, e.g. \"Chatbot 1\".",
        content_type = "application/json"
    ),
    responses(
        (status = 200, description = "Created course chatbot", body = ChatbotConfiguration)
    )
)]
#[instrument(skip(pool, payload))]
async fn create_chatbot(
    course_id: web::Path<Uuid>,
    payload: web::Json<String>,
    pool: web::Data<PgPool>,
    user: AuthUser,
) -> ControllerResult<web::Json<ChatbotConfiguration>> {
    let mut conn = pool.acquire().await?;
    let token = authorize(&mut conn, Act::Edit, Some(user.id), Res::Course(*course_id)).await?;
    let mut tx = conn.begin().await?;

    let course = models::courses::get_course(&mut tx, *course_id).await?;

    if !course.can_add_chatbot {
        return Err(ControllerError::new(
            ControllerErrorType::BadRequest,
            "Course doesn't allow creating chatbots.".to_string(),
            None,
        ));
    }

    let model = models::chatbot_configurations_models::get_default(&mut tx)
        .await
        .map_err(|e| {
            ControllerError::new(
                ControllerErrorType::BadRequest,
                "No default chatbot model configured. Ask an admin to set one.".to_string(),
                Some(e.into()),
            )
        })?;

    let configuration = models::chatbot_configurations::insert(
        &mut tx,
        PKeyPolicy::Generate,
        NewChatbotConf {
            chatbot_name: payload.into_inner(),
            course_id: *course_id,
            model_id: model.id,
            ..Default::default()
        },
    )
    .await?;
    tx.commit().await?;

    token.authorized_ok(web::Json(configuration))
}

/// POST `/api/v0/main-frontend/courses/{course_id}/chatbots/{chatbot_configuration_id}/set-as-default`
#[utoipa::path(
    post,
    path = "/{chatbot_configuration_id}/set-as-default",
    operation_id = "setCourseChatbotAsDefault",
    tag = "courses",
    params(
        ("course_id" = String, Path, description = "Course id"),
        ("chatbot_configuration_id" = String, Path, description = "Chatbot configuration id")
    ),
    responses(
        (status = 200, description = "Updated course chatbot", body = ChatbotConfiguration)
    )
)]
#[instrument(skip(pool))]
async fn set_default_chatbot(
    ids: web::Path<(Uuid, Uuid)>,
    pool: web::Data<PgPool>,
    user: AuthUser,
) -> ControllerResult<web::Json<ChatbotConfiguration>> {
    let mut conn = pool.acquire().await?;
    let (course_id, chatbot_configuration_id) = *ids;

    let token = authorize(&mut conn, Act::Edit, Some(user.id), Res::Course(course_id)).await?;
    let mut tx = conn.begin().await?;

    models::chatbot_configurations::remove_default_chatbot_from_course(&mut tx, course_id).await?;

    let chatbot =
        models::chatbot_configurations::get_by_id(&mut tx, chatbot_configuration_id).await?;

    if course_id != chatbot.course_id {
        return Err(ControllerError::new(
            ControllerErrorType::BadRequest,
            "Chatbot course id doesn't match the course id provided.".to_string(),
            None,
        ));
    }

    let configuration = models::chatbot_configurations::set_default_chatbot_for_course(
        &mut tx,
        chatbot_configuration_id,
    )
    .await?;
    tx.commit().await?;

    token.authorized_ok(web::Json(configuration))
}

/// POST `/api/v0/main-frontend/courses/{course_id}/chatbots/{chatbot_configuration_id}/set-as-non-default`
#[utoipa::path(
    post,
    path = "/{chatbot_configuration_id}/set-as-non-default",
    operation_id = "setCourseChatbotAsNonDefault",
    tag = "courses",
    params(
        ("course_id" = String, Path, description = "Course id"),
        ("chatbot_configuration_id" = String, Path, description = "Chatbot configuration id")
    ),
    responses(
        (status = 200, description = "Updated course chatbot", body = ChatbotConfiguration)
    )
)]
#[instrument(skip(pool))]
async fn set_non_default_chatbot(
    ids: web::Path<(Uuid, Uuid)>,
    pool: web::Data<PgPool>,
    user: AuthUser,
) -> ControllerResult<web::Json<ChatbotConfiguration>> {
    let mut conn = pool.acquire().await?;
    let (course_id, chatbot_configuration_id) = *ids;

    let token = authorize(&mut conn, Act::Edit, Some(user.id), Res::Course(course_id)).await?;
    let mut tx = conn.begin().await?;

    models::chatbot_configurations::remove_default_chatbot_from_course(&mut tx, course_id).await?;

    let configuration =
        models::chatbot_configurations::get_by_id(&mut tx, chatbot_configuration_id).await?;

    if course_id != configuration.course_id {
        return Err(ControllerError::new(
            ControllerErrorType::BadRequest,
            "Chatbot course id doesn't match the course id provided.".to_string(),
            None,
        ));
    }
    tx.commit().await?;

    token.authorized_ok(web::Json(configuration))
}

pub fn _add_routes(cfg: &mut web::ServiceConfig) {
    cfg.route("", web::get().to(get_chatbots))
        .route("", web::post().to(create_chatbot))
        .route(
            "/{chatbot_configuration_id}/set-as-default",
            web::post().to(set_default_chatbot),
        )
        .route(
            "/{chatbot_configuration_id}/set-as-non-default",
            web::post().to(set_non_default_chatbot),
        );
}