headless_lms_models/

feedback.rs

use crate::{
    feedback_categories::{self, NewFeedbackCategory},
    prelude::*,
};
use utoipa::ToSchema;

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

pub struct NewFeedback {
    pub feedback_given: String,
    pub selected_text: Option<String>,
    pub related_blocks: Vec<FeedbackBlock>,
    pub page_id: Uuid,
    pub category: Option<NewFeedbackCategory>,
}

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

pub struct FeedbackBlock {
    pub id: Uuid,
    pub text: Option<String>,
    pub order_number: Option<i32>,
}

#[derive(Debug, Serialize, Deserialize, PartialEq, Clone, Eq, ToSchema)]
pub struct FeedbackRow {
    pub id: Uuid,
    pub created_at: DateTime<Utc>,
    pub updated_at: DateTime<Utc>,
    pub deleted_at: Option<DateTime<Utc>>,
    pub user_id: Option<Uuid>,
    pub course_id: Option<Uuid>,
    pub exam_id: Option<Uuid>,
    pub page_id: Option<Uuid>,
    pub feedback_given: String,
    pub selected_text: Option<String>,
    pub marked_as_read: bool,
    pub category_id: Option<Uuid>,
}

pub async fn insert(
    conn: &mut PgConnection,
    pkey_policy: PKeyPolicy<Uuid>,
    user_id: Option<Uuid>,
    course_id: Uuid,
    new_feedback: NewFeedback,
) -> ModelResult<Uuid> {
    let category_id = if let Some(category) = new_feedback.category {
        // if inserting the category fails for some reason, let's still try to insert
        // the feedback.
        feedback_categories::insert_or_get_by_name(&mut *conn, category)
            .await
            .inspect_err(|e| error!("Error while inserting new feedback cateogry: {e}"))
            .ok()
    } else {
        None
    };
    let mut tx = conn.begin().await?;

    let res = sqlx::query!(
        "
INSERT INTO feedback(
    id,
    user_id,
    course_id,
    feedback_given,
    selected_text,
    page_id,
    category_id
  )
VALUES ($1, $2, $3, $4, $5, $6, $7)
RETURNING *
        ",
        pkey_policy.into_uuid(),
        user_id,
        course_id,
        new_feedback.feedback_given,
        new_feedback.selected_text,
        new_feedback.page_id,
        category_id
    )
    .fetch_one(&mut *tx)
    .await?;
    for (n, block) in new_feedback.related_blocks.iter().enumerate() {
        sqlx::query!(
            "
INSERT INTO block_feedback(feedback_id, block_id, block_text, order_number)
VALUES ($1, $2, $3, $4)
",
            res.id,
            block.id,
            block.text,
            n as i32
        )
        .execute(&mut *tx)
        .await?;
    }
    tx.commit().await?;
    Ok(res.id)
}

pub async fn mark_as_read(conn: &mut PgConnection, id: Uuid, read: bool) -> ModelResult<()> {
    sqlx::query!(
        "
UPDATE feedback
SET marked_as_read = $1
WHERE id = $2
",
        read,
        id
    )
    .execute(conn)
    .await?;
    Ok(())
}

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

pub async fn set_read_state_by_id_and_course_id(
    conn: &mut PgConnection,
    id: Uuid,
    course_id: Uuid,
    read: bool,
) -> ModelResult<FeedbackRow> {
    let res = sqlx::query_as!(
        FeedbackRow,
        r#"
UPDATE feedback
SET marked_as_read = $3
WHERE id = $1
  AND course_id = $2
  AND deleted_at IS NULL
RETURNING *
        "#,
        id,
        course_id,
        read
    )
    .fetch_one(conn)
    .await?;
    Ok(res)
}

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

pub struct Feedback {
    pub id: Uuid,
    pub user_id: Option<Uuid>,
    pub course_id: Uuid,
    pub page_id: Option<Uuid>,
    pub feedback_given: String,
    pub selected_text: Option<String>,
    pub marked_as_read: bool,
    pub created_at: DateTime<Utc>,
    pub blocks: Vec<FeedbackBlock>,
    pub page_title: String,
    pub page_url_path: String,
    pub feedback_category_name: Option<String>,
    pub feedback_category_id: Option<Uuid>,
}

pub async fn get_feedback_for_course(
    conn: &mut PgConnection,
    course_id: Uuid,
    category_filter: Option<Uuid>,
    read: bool,
    pagination: Pagination,
) -> ModelResult<Vec<Feedback>> {
    let res = sqlx::query!(
        r#"
SELECT fb.*,
  pages.title AS "page_title",
  pages.url_path AS "page_url_path"
FROM (
    SELECT feedback.id AS "id!",
      feedback.user_id,
      feedback.course_id AS "course_id!",
      feedback.page_id,
      feedback.feedback_given AS "feedback_given!",
      feedback.selected_text,
      feedback.marked_as_read AS "marked_as_read!",
      feedback.created_at AS "created_at!",
      feedback.category_id,
      feedback_categories.name AS "feedback_category_name: Option<String>",
      array_agg(block_feedback.block_id) filter (
        WHERE block_feedback.block_id IS NOT NULL
      ) AS "block_ids: Vec<Uuid>",
      array_agg(block_feedback.block_text) filter (
        WHERE block_feedback.block_id IS NOT NULL
      ) AS "block_texts: Vec<Option<String>>",
      array_agg(block_feedback.order_number) filter (
        WHERE block_feedback.block_id IS NOT NULL
      ) AS "block_order_numbers: Vec<Option<i32>>"
    FROM feedback
      LEFT JOIN block_feedback ON block_feedback.feedback_id = feedback.id
      LEFT JOIN feedback_categories ON feedback_categories.id = feedback.category_id
      AND feedback_categories.deleted_at IS NULL
    WHERE course_id = $1
      AND feedback.marked_as_read = $2
      AND feedback.deleted_at IS NULL
      AND block_feedback.deleted_at IS NULL
      AND (
        CASE
          WHEN $5::uuid IS NOT NULL
            THEN feedback_categories.id = $5::uuid
            ELSE TRUE
        END
      )
    GROUP BY feedback.id,
      feedback.user_id,
      feedback.course_id,
      feedback.feedback_given,
      feedback.marked_as_read,
      feedback.created_at,
      feedback_categories.name
    ORDER BY feedback.created_at DESC,
      feedback.id
    LIMIT $3 OFFSET $4
  ) fb
  JOIN pages ON pages.id = fb.page_id
ORDER BY fb."created_at!" DESC,
  fb."id!"
        "#,
        course_id,
        read,
        pagination.limit(),
        pagination.offset(),
        category_filter as Option<Uuid>
    )
    .map(|r| Feedback {
        id: r.id,
        user_id: r.user_id,
        course_id: r.course_id,
        page_id: r.page_id,
        feedback_given: r.feedback_given,
        selected_text: r.selected_text,
        marked_as_read: r.marked_as_read,
        created_at: r.created_at,
        blocks: r
            .block_ids
            .unwrap_or_default()
            .into_iter()
            .zip(r.block_texts.unwrap_or_default())
            .zip(r.block_order_numbers.unwrap_or_default())
            .map(|((id, text), order_number)| FeedbackBlock {
                id,
                text,
                order_number,
            })
            .collect(),
        page_title: r.page_title,
        page_url_path: r.page_url_path,
        feedback_category_name: r.feedback_category_name,
        feedback_category_id: r.category_id,
    })
    .fetch_all(conn)
    .await?;
    Ok(res)
}

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

pub struct FeedbackCount {
    pub read: u32,
    pub unread: u32,
    pub categories: Vec<CategoryFeedbackCount>,
}

#[derive(Debug, Serialize, Deserialize, PartialEq, Clone, Eq, ToSchema)]
pub struct CategoryFeedbackCount {
    pub category_id: Uuid,
    pub read_feedback: u32,
    pub unread_feedback: u32,
}

pub async fn get_feedback_count_for_course(
    conn: &mut PgConnection,
    course_id: Uuid,
) -> ModelResult<FeedbackCount> {
    let res_categories = sqlx::query!(
        r#"
SELECT COUNT(*) filter (
    WHERE marked_as_read
  ) AS READ,
  COUNT(*) filter (
    WHERE NOT(marked_as_read)
  ) AS unread,
  category_id
FROM feedback
WHERE course_id = $1
  AND deleted_at IS NULL
GROUP BY category_id
        "#,
        course_id
    )
    .fetch_all(&mut *conn)
    .await?;

    let mut all_read = 0;
    let mut all_unread = 0;

    let c: Vec<CategoryFeedbackCount> = res_categories
        .iter()
        .filter_map(|x| {
            let read = x.read.unwrap_or_default().try_into().ok()?;
            let unread = x.unread.unwrap_or_default().try_into().ok()?;
            all_read += read;
            all_unread += unread;
            Some(CategoryFeedbackCount {
                category_id: x.category_id?,
                read_feedback: read,
                unread_feedback: unread,
            })
        })
        .collect();

    Ok(FeedbackCount {
        read: all_read,
        unread: all_unread,
        categories: c,
    })
}

/// Block-level feedback on the given pages of the course.
pub async fn get_block_ids_by_page_ids(
    conn: &mut PgConnection,
    course_id: Uuid,
    page_ids: &[Uuid],
) -> ModelResult<Vec<crate::pages::PageBlockReferences>> {
    let res = sqlx::query_as!(
        crate::pages::PageBlockReferences,
        r#"
SELECT feedback.id,
  feedback.page_id AS "page_id!",
  array_agg(
    block_feedback.block_id
    ORDER BY block_feedback.order_number
  ) AS "block_ids!"
FROM feedback
  JOIN block_feedback ON block_feedback.feedback_id = feedback.id
  AND block_feedback.deleted_at IS NULL
WHERE feedback.page_id = ANY($1)
  AND feedback.course_id = $2
  AND feedback.deleted_at IS NULL
GROUP BY feedback.id
        "#,
        page_ids,
        course_id
    )
    .fetch_all(conn)
    .await?;
    Ok(res)
}

/// Sets each feedback's page; `feedback_ids` and `page_ids` are parallel.
pub async fn set_page_ids(
    conn: &mut PgConnection,
    feedback_ids: &[Uuid],
    page_ids: &[Uuid],
) -> ModelResult<()> {
    sqlx::query!(
        "
UPDATE feedback
SET page_id = moved.page_id
FROM UNNEST($1::uuid [], $2::uuid []) AS moved(id, page_id)
WHERE feedback.id = moved.id
        ",
        feedback_ids,
        page_ids
    )
    .execute(conn)
    .await?;
    Ok(())
}