headless_lms_models/

research_forms.rs

use futures::Stream;
use utoipa::ToSchema;

use crate::prelude::*;

#[derive(Debug, Serialize, Deserialize, PartialEq, Clone, ToSchema)]

pub struct ResearchForm {
    pub id: Uuid,
    pub course_id: Uuid,
    pub content: serde_json::Value,
    pub created_at: DateTime<Utc>,
    pub updated_at: DateTime<Utc>,
    pub deleted_at: Option<DateTime<Utc>>,
}

#[derive(Debug, Serialize, Deserialize, PartialEq, Clone, ToSchema)]

pub struct NewResearchForm {
    pub course_id: Uuid,
    pub content: serde_json::Value,
}

#[derive(Debug, Serialize, Deserialize, PartialEq, Clone, ToSchema)]

pub struct ResearchFormQuestion {
    pub id: Uuid,
    pub course_id: Uuid,
    pub research_consent_form_id: Uuid,
    pub question: String,
    pub created_at: DateTime<Utc>,
    pub updated_at: DateTime<Utc>,
    pub deleted_at: Option<DateTime<Utc>>,
}

#[derive(Debug, Serialize, Deserialize, PartialEq, Clone, ToSchema)]

pub struct NewResearchFormQuestionAnswer {
    pub user_id: Uuid,
    pub research_form_question_id: Uuid,
    pub research_consent: bool,
}

#[derive(Debug, Serialize, Deserialize, PartialEq, Clone, ToSchema)]

pub struct ResearchFormQuestionAnswer {
    pub id: Uuid,
    pub user_id: Uuid,
    pub course_id: Uuid,
    pub research_form_question_id: Uuid,
    pub research_consent: bool,
    pub created_at: DateTime<Utc>,
    pub updated_at: DateTime<Utc>,
    pub deleted_at: Option<DateTime<Utc>>,
}

impl NewResearchForm {
    /// Creates `NewResearchForm` with provided values that is public by default.
    pub fn new(course_id: Uuid) -> Self {
        Self {
            course_id,
            content: Default::default(),
        }
    }

    /// Sets the content of this research form.
    pub fn set_content(mut self, content: serde_json::Value) -> Self {
        self.content = content;
        self
    }
}

pub async fn upsert_research_form(
    conn: &mut PgConnection,
    pkey_policy: PKeyPolicy<Uuid>,
    new_research_form: &NewResearchForm,
) -> ModelResult<ResearchForm> {
    let form_res = sqlx::query_as!(
        ResearchForm,
        "
INSERT INTO course_specific_research_consent_forms (
    id,
    course_id,
    content
  )
VALUES ($1, $2, $3) ON CONFLICT (course_id, deleted_at)
DO UPDATE SET content = $3
RETURNING *
",
        pkey_policy.into_uuid(),
        new_research_form.course_id,
        serde_json::to_value(new_research_form.content.clone())?,
    )
    .fetch_one(conn)
    .await?;
    Ok(form_res)
}

pub async fn get_research_form_with_course_id(
    conn: &mut PgConnection,
    course_id: Uuid,
) -> ModelResult<ResearchForm> {
    let form_res = sqlx::query_as!(
        ResearchForm,
        "
SELECT * FROM course_specific_research_consent_forms
WHERE course_id = $1
AND deleted_at IS NULL
",
        course_id,
    )
    .fetch_one(conn)
    .await?;
    Ok(form_res)
}

/// Saves a course's research consent form and makes its question rows match the question
/// blocks in `content`: questions whose block was removed are soft-deleted.
///
/// Errors with `InvalidRequest` if the content has no questions, a question is empty, or a
/// question id belongs to another course.
pub async fn save_research_form(
    conn: &mut PgConnection,
    course_id: Uuid,
    content: serde_json::Value,
) -> ModelResult<ResearchForm> {
    let questions = questions_in_content(&content)?;
    if questions.is_empty() {
        return Err(model_err!(
            InvalidRequest,
            "A research form needs at least one question".to_string()
        ));
    }

    let mut tx = conn.begin().await?;
    let form = upsert_research_form(
        &mut tx,
        PKeyPolicy::Generate,
        &NewResearchForm { course_id, content },
    )
    .await?;

    for (question_id, question) in &questions {
        // The WHERE stops a save from taking over a question id that belongs to another course.
        sqlx::query!(
            "
INSERT INTO course_specific_consent_form_questions (
    id,
    course_id,
    research_consent_form_id,
    question
  )
VALUES ($1, $2, $3, $4) ON CONFLICT (id)
DO UPDATE SET question = $4,
research_consent_form_id = $3,
deleted_at = NULL
WHERE course_specific_consent_form_questions.course_id = excluded.course_id
RETURNING id
",
            question_id,
            course_id,
            form.id,
            question
        )
        .fetch_optional(&mut *tx)
        .await?
        .ok_or_else(|| {
            model_err!(
                InvalidRequest,
                "Question id belongs to a different course".to_string()
            )
        })?;
    }

    let question_ids: Vec<Uuid> = questions.iter().map(|(id, _)| *id).collect();
    sqlx::query!(
        "
UPDATE course_specific_consent_form_questions
SET deleted_at = NOW()
WHERE research_consent_form_id = $1
  AND deleted_at IS NULL
  AND id <> ALL($2::uuid [])
",
        form.id,
        &question_ids
    )
    .execute(&mut *tx)
    .await?;

    tx.commit().await?;
    Ok(form)
}

/// The `(id, question)` of each top-level question block; a block's clientId is its question id.
fn questions_in_content(content: &serde_json::Value) -> ModelResult<Vec<(Uuid, String)>> {
    let blocks = content.as_array().map(Vec::as_slice).unwrap_or_default();
    blocks
        .iter()
        .filter(|block| block["name"] == "moocfi/research-consent-question")
        .map(|block| {
            let id = block["clientId"]
                .as_str()
                .and_then(|id| Uuid::parse_str(id).ok())
                .ok_or_else(|| {
                    model_err!(InvalidRequest, "Question has no valid id".to_string())
                })?;
            let question = block["attributes"]["content"]
                .as_str()
                .unwrap_or_default()
                .trim()
                .to_string();
            if question.is_empty() {
                return Err(model_err!(
                    InvalidRequest,
                    "Research form questions cannot be empty".to_string()
                ));
            }
            Ok((id, question))
        })
        .collect()
}

pub async fn get_research_form_questions_with_course_id(
    conn: &mut PgConnection,
    course_id: Uuid,
) -> ModelResult<Vec<ResearchFormQuestion>> {
    let form_res = sqlx::query_as!(
        ResearchFormQuestion,
        "
SELECT * FROM course_specific_consent_form_questions
WHERE course_id = $1
AND deleted_at IS NULL
",
        course_id,
    )
    .fetch_all(conn)
    .await?;
    Ok(form_res)
}

pub async fn get_question_by_id(
    conn: &mut PgConnection,
    question_id: Uuid,
) -> ModelResult<ResearchFormQuestion> {
    let res = sqlx::query_as!(
        ResearchFormQuestion,
        "
SELECT *
FROM course_specific_consent_form_questions
WHERE id = $1
  AND deleted_at IS NULL
        ",
        question_id
    )
    .fetch_one(conn)
    .await?;
    Ok(res)
}

pub struct ExportedCourseResearchFormQustionAnswer {
    pub course_id: Uuid,
    pub research_consent_form_id: Uuid,
    pub research_form_question_id: Uuid,
    pub question: String,
    pub user_id: Uuid,
    pub research_consent: bool,
    pub created_at: DateTime<Utc>,
    pub updated_at: DateTime<Utc>,
}

pub fn stream_course_research_form_user_answers(
    conn: &mut PgConnection,
    course_id: Uuid,
) -> impl Stream<Item = sqlx::Result<ExportedCourseResearchFormQustionAnswer>> + '_ {
    sqlx::query_as!(
        ExportedCourseResearchFormQustionAnswer,
        r#"
    SELECT DISTINCT ON (a.research_form_question_id, a.user_id)
        q.course_id,
        q.research_consent_form_id,
        a.research_form_question_id,
        q.question,
        a.user_id,
        a.research_consent,
        a.created_at,
        a.updated_at
        FROM course_specific_consent_form_answers a
    LEFT JOIN course_specific_consent_form_questions q ON a.research_form_question_id = q.id
    WHERE a.course_id = $1
    AND a.deleted_at IS NULL
    AND q.deleted_at IS NULL
    ORDER BY a.user_id, a.research_form_question_id, a.updated_at DESC
    "#,
        course_id
    )
    .fetch(conn)
}

pub async fn upsert_research_form_anwser(
    conn: &mut PgConnection,
    course_id: Uuid,
    answer: &NewResearchFormQuestionAnswer,
) -> ModelResult<Uuid> {
    let form_res = sqlx::query!(
        "
INSERT INTO course_specific_consent_form_answers (
    user_id,
    course_id,
    research_form_question_id,
    research_consent
  )
VALUES ($1, $2, $3, $4) ON CONFLICT (user_id, research_form_question_id)
DO UPDATE SET research_consent = $4
RETURNING *
",
        answer.user_id,
        course_id,
        answer.research_form_question_id,
        answer.research_consent
    )
    .fetch_one(conn)
    .await?;
    Ok(form_res.id)
}

pub async fn upsert_answer_for_user_id_and_question_id(
    conn: &mut PgConnection,
    user_id: Uuid,
    course_id: Uuid,
    question_id: Uuid,
    research_consent: bool,
) -> ModelResult<Uuid> {
    let res = sqlx::query!(
        "
INSERT INTO course_specific_consent_form_answers (
    user_id,
    course_id,
    research_form_question_id,
    research_consent
)
SELECT $1, q.course_id, q.id, $4
FROM course_specific_consent_form_questions q
WHERE q.id = $2
  AND q.course_id = $3
  AND q.deleted_at IS NULL
ON CONFLICT (user_id, research_form_question_id)
DO UPDATE SET
  course_id = excluded.course_id,
  research_consent = excluded.research_consent,
  deleted_at = NULL
RETURNING id
        ",
        user_id,
        question_id,
        course_id,
        research_consent
    )
    .fetch_one(conn)
    .await?;
    Ok(res.id)
}

pub async fn get_research_form_answers_with_user_id(
    conn: &mut PgConnection,
    course_id: Uuid,
    user_id: Uuid,
) -> ModelResult<Vec<ResearchFormQuestionAnswer>> {
    let form_res = sqlx::query_as!(
        ResearchFormQuestionAnswer,
        "
SELECT * FROM course_specific_consent_form_answers
WHERE course_id = $1 AND user_id = $2
AND deleted_at IS NULL
",
        course_id,
        user_id
    )
    .fetch_all(conn)
    .await?;
    Ok(form_res)
}

pub async fn get_all_research_form_answers_with_user_id(
    conn: &mut PgConnection,
    user_id: Uuid,
) -> ModelResult<Vec<ResearchFormQuestionAnswer>> {
    let form_res = sqlx::query_as!(
        ResearchFormQuestionAnswer,
        "
SELECT * FROM course_specific_consent_form_answers
WHERE user_id = $1
AND deleted_at IS NULL
",
        user_id
    )
    .fetch_all(conn)
    .await?;
    Ok(form_res)
}

pub async fn get_all_research_form_answers_with_user_course_and_question_id(
    conn: &mut PgConnection,
    user_id: Uuid,
    course_id: Uuid,
    course_specific_consent_form_question_id: Uuid,
) -> ModelResult<Vec<ResearchFormQuestionAnswer>> {
    let form_res = sqlx::query_as!(
        ResearchFormQuestionAnswer,
        "
SELECT * FROM course_specific_consent_form_answers
WHERE user_id = $1
AND course_id = $2
AND research_form_question_id = $3
AND deleted_at IS NULL
",
        user_id,
        course_id,
        course_specific_consent_form_question_id
    )
    .fetch_all(conn)
    .await?;
    Ok(form_res)
}