headless_lms_models/

peer_or_self_review_submissions.rs

use std::collections::HashMap;

use crate::prelude::*;
use utoipa::ToSchema;

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

pub struct PeerOrSelfReviewSubmission {
    pub id: Uuid,
    pub created_at: DateTime<Utc>,
    pub updated_at: DateTime<Utc>,
    pub deleted_at: Option<DateTime<Utc>>,
    pub user_id: Uuid,
    pub exercise_id: Uuid,
    pub course_id: Uuid,
    pub peer_or_self_review_config_id: Uuid,
    pub exercise_slide_submission_id: Uuid,
}

/// Same as PeerOrSelfReviewSubmission with optional submission owner (user who received the review). Used for "given" reviews.
#[derive(Debug, Serialize, Deserialize, PartialEq, Clone, Eq, ToSchema)]

pub struct PeerOrSelfReviewSubmissionWithSubmissionOwner {
    #[serde(flatten)]
    pub submission: PeerOrSelfReviewSubmission,
    pub submission_owner_user_id: Option<Uuid>,
}

pub async fn insert(
    conn: &mut PgConnection,
    pkey_policy: PKeyPolicy<Uuid>,
    user_id: Uuid,
    exercise_id: Uuid,
    course_id: Uuid,
    peer_or_self_review_config_id: Uuid,
    exercise_slide_submission_id: Uuid,
) -> ModelResult<Uuid> {
    let res = sqlx::query!(
        "
INSERT INTO peer_or_self_review_submissions (
    id,
    user_id,
    exercise_id,
    course_id,
    peer_or_self_review_config_id,
    exercise_slide_submission_id
  )
VALUES ($1, $2, $3, $4, $5, $6)
RETURNING *
        ",
        pkey_policy.into_uuid(),
        user_id,
        exercise_id,
        course_id,
        peer_or_self_review_config_id,
        exercise_slide_submission_id,
    )
    .fetch_one(conn)
    .await?;
    Ok(res.id)
}

#[allow(clippy::too_many_arguments)]
pub async fn insert_for_submission_context(
    conn: &mut PgConnection,
    pkey_policy: PKeyPolicy<Uuid>,
    reviewer_user_id: Uuid,
    receiver_user_id: Uuid,
    exercise_id: Uuid,
    course_id: Uuid,
    peer_or_self_review_config_id: Uuid,
    exercise_slide_submission_id: Uuid,
    reviewer_user_exercise_state_id: Uuid,
    receiver_user_exercise_state_id: Uuid,
) -> ModelResult<PeerOrSelfReviewSubmission> {
    let res = sqlx::query_as!(
        PeerOrSelfReviewSubmission,
        r#"
INSERT INTO peer_or_self_review_submissions (
    id,
    user_id,
    exercise_id,
    course_id,
    peer_or_self_review_config_id,
    exercise_slide_submission_id
)
SELECT
    $1,
    reviewer_state.user_id,
    exercise.id,
    exercise.course_id,
    config.id,
    receiver_submission.id
FROM exercises exercise
  JOIN peer_or_self_review_configs config
    ON config.id = $5
   AND config.course_id = $4
   AND (config.exercise_id = exercise.id OR config.exercise_id IS NULL)
   AND config.deleted_at IS NULL
  JOIN exercise_slide_submissions receiver_submission
    ON receiver_submission.id = $6
   AND receiver_submission.exercise_id = exercise.id
   AND receiver_submission.course_id = $4
   AND receiver_submission.user_id = $3
   AND receiver_submission.deleted_at IS NULL
  JOIN user_exercise_states reviewer_state
    ON reviewer_state.id = $7
   AND reviewer_state.user_id = $2
   AND reviewer_state.exercise_id = exercise.id
   AND reviewer_state.course_id = $4
   AND reviewer_state.deleted_at IS NULL
  JOIN user_exercise_states receiver_state
    ON receiver_state.id = $8
   AND receiver_state.user_id = $3
   AND receiver_state.exercise_id = exercise.id
   AND receiver_state.course_id = $4
   AND receiver_state.deleted_at IS NULL
WHERE exercise.id = $9
  AND exercise.course_id = $4
  AND exercise.deleted_at IS NULL
RETURNING *
        "#,
        pkey_policy.into_uuid(),
        reviewer_user_id,
        receiver_user_id,
        course_id,
        peer_or_self_review_config_id,
        exercise_slide_submission_id,
        reviewer_user_exercise_state_id,
        receiver_user_exercise_state_id,
        exercise_id
    )
    .fetch_one(conn)
    .await?;
    Ok(res)
}

/// How many peer and self reviews students have given on each exercise; exercises with none are
/// left out.
pub async fn count_by_exercise_ids(
    conn: &mut PgConnection,
    exercise_ids: &[Uuid],
) -> ModelResult<HashMap<Uuid, i64>> {
    if exercise_ids.is_empty() {
        return Ok(HashMap::new());
    }
    let counts = sqlx::query!(
        r#"
SELECT exercise_id,
  COUNT(*) AS "count!"
FROM peer_or_self_review_submissions
WHERE exercise_id = ANY($1)
  AND deleted_at IS NULL
GROUP BY exercise_id
        "#,
        exercise_ids
    )
    .fetch_all(conn)
    .await?;
    Ok(counts
        .into_iter()
        .map(|row| (row.exercise_id, row.count))
        .collect())
}

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

pub async fn get_by_ids(
    conn: &mut PgConnection,
    ids: &[Uuid],
) -> ModelResult<Vec<PeerOrSelfReviewSubmission>> {
    let res = sqlx::query_as!(
        PeerOrSelfReviewSubmission,
        "
SELECT *
FROM peer_or_self_review_submissions
WHERE id = ANY($1)
  AND deleted_at IS NULL
        ",
        ids
    )
    .fetch_all(conn)
    .await?;
    Ok(res)
}

pub async fn get_users_submission_ids_for_exercise_and_course_instance(
    conn: &mut PgConnection,
    user_id: Uuid,
    exercise_id: Uuid,
    course_id: Uuid,
) -> ModelResult<Vec<Uuid>> {
    let res = sqlx::query!(
        "
SELECT exercise_slide_submission_id
FROM peer_or_self_review_submissions
WHERE user_id = $1
  AND exercise_id = $2
  AND course_id = $3
  AND deleted_at IS NULL
    ",
        user_id,
        exercise_id,
        course_id
    )
    .fetch_all(conn)
    .await?
    .into_iter()
    .map(|record| record.exercise_slide_submission_id)
    .collect();
    Ok(res)
}

pub async fn get_all_received_peer_or_self_review_submissions_for_user_and_course(
    conn: &mut PgConnection,
    user_id: Uuid,
    course_id: Uuid,
) -> ModelResult<Vec<PeerOrSelfReviewSubmission>> {
    let res = sqlx::query_as!(
        PeerOrSelfReviewSubmission,
        "
SELECT prs.*
FROM exercise_slide_submissions ess
INNER JOIN peer_or_self_review_submissions prs ON (ess.id = prs.exercise_slide_submission_id)
WHERE ess.user_id = $1
  AND ess.course_id = $2
  AND ess.deleted_at IS NULL
  AND prs.deleted_at IS NULL
    ",
        user_id,
        course_id
    )
    .fetch_all(conn)
    .await?;
    Ok(res)
}

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

pub async fn get_num_peer_reviews_given_by_user_and_course_instance_and_exercise(
    conn: &mut PgConnection,
    user_id: Uuid,
    course_id: Uuid,
    exercise_id: Uuid,
) -> ModelResult<i64> {
    let res = sqlx::query!(
        "
SELECT COUNT(*)
FROM peer_or_self_review_submissions
WHERE user_id = $1
  AND exercise_id = $3
  AND course_id = $2
  AND deleted_at IS NULL
    ",
        user_id,
        course_id,
        exercise_id
    )
    .fetch_one(conn)
    .await?;
    Ok(res.count.unwrap_or(0))
}

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

pub async fn get_users_submission_count_for_exercise_and_course_instance(
    conn: &mut PgConnection,
    user_id: Uuid,
    exercise_id: Uuid,
    course_id: Uuid,
) -> ModelResult<u32> {
    let res = sqlx::query!(
        "
SELECT COUNT(*) AS count
FROM peer_or_self_review_submissions
WHERE user_id = $1
  AND exercise_id = $2
  AND course_id = $3
  AND deleted_at IS NULL
        ",
        user_id,
        exercise_id,
        course_id
    )
    .fetch_one(conn)
    .await?;
    Ok(res.count.unwrap_or(0).try_into()?)
}

pub async fn get_last_time_user_submitted_peer_review(
    conn: &mut PgConnection,
    user_id: Uuid,
    exercise_id: Uuid,
    course_id: Uuid,
) -> ModelResult<Option<DateTime<Utc>>> {
    let res = sqlx::query!(
        "
SELECT MAX(created_at) as latest_submission_time
FROM peer_or_self_review_submissions
WHERE user_id = $1
  AND exercise_id = $2
  AND course_id = $3
  AND deleted_at IS NULL
        ",
        user_id,
        exercise_id,
        course_id
    )
    .fetch_optional(conn)
    .await?;
    Ok(res.and_then(|o| o.latest_submission_time))
}

pub async fn count_peer_or_self_review_submissions_for_exercise_slide_submission(
    conn: &mut PgConnection,
    exercise_slide_submission_id: Uuid,
    exclude_user_ids: &[Uuid],
) -> ModelResult<u32> {
    let res = sqlx::query!(
        "
SELECT COUNT(*) AS count
FROM peer_or_self_review_submissions
WHERE exercise_slide_submission_id = $1
  AND user_id != ALL($2)
  AND deleted_at IS NULL
        ",
        exercise_slide_submission_id,
        exclude_user_ids
    )
    .fetch_one(conn)
    .await?;
    Ok(res.count.unwrap_or(0).try_into()?)
}

pub async fn get_self_review_submission_by_user_and_exercise(
    conn: &mut PgConnection,
    user_id: Uuid,
    exercise_id: Uuid,
    course_id: Uuid,
) -> ModelResult<Option<PeerOrSelfReviewSubmission>> {
    let res = sqlx::query_as!(
        PeerOrSelfReviewSubmission,
        "
SELECT prs.*
FROM peer_or_self_review_submissions prs
JOIN exercise_slide_submissions ess ON (ess.id = prs.exercise_slide_submission_id)
WHERE ess.user_id = $1
  AND prs.exercise_id = $2
  AND prs.course_id = $3
  AND prs.deleted_at IS NULL
  AND ess.deleted_at IS NULL
        ",
        user_id,
        exercise_id,
        course_id
    )
    .fetch_optional(conn)
    .await?;
    Ok(res)
}

pub async fn get_received_peer_or_self_review_submissions_for_user_by_peer_or_self_review_config_id_and_exercise_slide_submission(
    conn: &mut PgConnection,
    user_id: Uuid,
    exercise_slide_submission_id: Uuid,
    peer_or_self_review_config_id: Uuid,
) -> ModelResult<Vec<PeerOrSelfReviewSubmission>> {
    let res = sqlx::query_as!(
        PeerOrSelfReviewSubmission,
        "
SELECT prs.*
FROM peer_or_self_review_submissions prs
  JOIN exercise_slide_submissions ess ON (ess.id = prs.exercise_slide_submission_id)
WHERE ess.user_id = $1
  AND ess.id = $2
  AND prs.peer_or_self_review_config_id = $3
  AND prs.deleted_at IS NULL
  AND ess.deleted_at IS NULL
        ",
        user_id,
        exercise_slide_submission_id,
        peer_or_self_review_config_id
    )
    .fetch_all(conn)
    .await?;
    Ok(res)
}

pub async fn get_mapping_from_peer_or_self_review_submission_ids_to_peer_review_giver_user_ids(
    conn: &mut PgConnection,
    peer_or_self_review_submission_ids: &[Uuid],
) -> ModelResult<HashMap<Uuid, Uuid>> {
    let full = get_by_ids(conn, peer_or_self_review_submission_ids).await?;
    Ok(full
        .into_iter()
        .map(|submission: PeerOrSelfReviewSubmission| (submission.id, submission.user_id))
        .collect())
}