headless_lms_models/

teacher_grading_decisions.rs

use std::collections::HashMap;

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

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

pub struct TeacherGradingDecision {
    pub id: Uuid,
    pub user_exercise_state_id: Uuid,
    pub user_id: Option<Uuid>,
    pub created_at: DateTime<Utc>,
    pub updated_at: DateTime<Utc>,
    pub deleted_at: Option<DateTime<Utc>>,
    pub score_given: f32,
    pub teacher_decision: TeacherDecisionType,
    pub justification: Option<String>,
    pub hidden: Option<bool>,
}

#[derive(Debug, Serialize, Deserialize, PartialEq, Eq, Clone, Copy, sqlx::Type, ToSchema)]
#[sqlx(type_name = "teacher_decision_type", rename_all = "kebab-case")]
pub enum TeacherDecisionType {
    FullPoints,
    ZeroPoints,
    CustomPoints,
    SuspectedPlagiarism,
    RejectAndReset,
    UnauthorizedAiUse,
    BadAnswer,
    Other,
}

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

pub struct NewTeacherGradingDecision {
    pub user_exercise_state_id: Uuid,
    pub exercise_id: Uuid,
    pub action: TeacherDecisionType,
    pub manual_points: Option<f32>,
    pub justification: Option<String>,
    pub hidden: bool,
    /// Resets the student's progress on the exercise so they can answer it again. Independent of
    /// `action`, so a decision can record why the answer was rejected and still reopen it.
    /// Requires the exercise to belong to a course.
    pub reset_exercise: bool,
}

pub async fn add_teacher_grading_decision(
    conn: &mut PgConnection,
    user_exercise_state_id: Uuid,
    action: TeacherDecisionType,
    score_given: f32,
    decision_maker_user_id: Option<Uuid>,
    justification: Option<String>,
    hidden: bool,
) -> ModelResult<TeacherGradingDecision> {
    let res = sqlx::query_as!(
        TeacherGradingDecision,
        r#"
INSERT INTO teacher_grading_decisions (
    user_exercise_state_id,
    teacher_decision,
    score_given,
    user_id,
    justification,
    hidden
  )
VALUES ($1, $2, $3, $4, $5, $6)
RETURNING *;
      "#,
        user_exercise_state_id,
        action as TeacherDecisionType,
        score_given,
        decision_maker_user_id,
        justification,
        hidden
    )
    .fetch_one(conn)
    .await?;
    Ok(res)
}

#[allow(clippy::too_many_arguments)]
pub async fn upsert_by_state_id_and_exercise_id(
    conn: &mut PgConnection,
    user_exercise_state_id: Uuid,
    exercise_id: Uuid,
    action: TeacherDecisionType,
    score_given: f32,
    decision_maker_user_id: Option<Uuid>,
    justification: Option<String>,
    hidden: bool,
) -> ModelResult<TeacherGradingDecision> {
    let res = sqlx::query_as!(
        TeacherGradingDecision,
        r#"
INSERT INTO teacher_grading_decisions (
    user_exercise_state_id,
    teacher_decision,
    score_given,
    user_id,
    justification,
    hidden
)
SELECT ues.id, $3, $4, $5, $6, $7
FROM user_exercise_states ues
WHERE ues.id = $1
  AND ues.exercise_id = $2
  AND ues.deleted_at IS NULL
RETURNING id,
  user_exercise_state_id,
  user_id,
  created_at,
  updated_at,
  deleted_at,
  score_given,
  teacher_decision,
  justification,
  hidden;
      "#,
        user_exercise_state_id,
        exercise_id,
        action as TeacherDecisionType,
        score_given,
        decision_maker_user_id,
        justification,
        hidden
    )
    .fetch_one(conn)
    .await?;
    Ok(res)
}

pub async fn try_to_get_latest_grading_decision_by_user_exercise_state_id(
    conn: &mut PgConnection,
    user_exercise_state_id: Uuid,
) -> ModelResult<Option<TeacherGradingDecision>> {
    let res = sqlx::query_as!(
        TeacherGradingDecision,
        r#"
SELECT *
FROM teacher_grading_decisions
WHERE user_exercise_state_id = $1
  AND deleted_at IS NULL
ORDER BY created_at DESC
LIMIT 1
      "#,
        user_exercise_state_id,
    )
    .fetch_optional(conn)
    .await?;
    Ok(res)
}

/// The student's latest grading decision that still describes where they stand.
///
/// Unlike [`try_to_get_latest_grading_decision_by_user_exercise_state_id`], this looks the decision
/// up by student and exercise, so it survives a reset replacing the user_exercise_state it was made
/// against. A decision stops applying once the student answers again, or once anyone resets the
/// exercise after it -- a later reset means the decision no longer describes the student's
/// situation, while a reset made just before it is the one the decision itself ordered.
pub async fn try_to_get_latest_grading_decision_still_addressed_to_student(
    conn: &mut PgConnection,
    user_id: Uuid,
    exercise_id: Uuid,
) -> ModelResult<Option<TeacherGradingDecision>> {
    let res = sqlx::query_as!(
        TeacherGradingDecision,
        r#"
SELECT tgd.id,
  tgd.user_exercise_state_id,
  tgd.user_id,
  tgd.created_at,
  tgd.updated_at,
  tgd.deleted_at,
  tgd.score_given,
  tgd.teacher_decision AS "teacher_decision: _",
  tgd.justification,
  tgd.hidden
FROM teacher_grading_decisions tgd
  JOIN user_exercise_states ues ON ues.id = tgd.user_exercise_state_id
WHERE ues.user_id = $1
  AND ues.exercise_id = $2
  AND tgd.deleted_at IS NULL
  AND NOT EXISTS (
    SELECT 1
    FROM exercise_slide_submissions ess
    WHERE ess.user_id = $1
      AND ess.exercise_id = $2
      AND ess.deleted_at IS NULL
      AND ess.created_at > tgd.created_at
  )
  AND NOT EXISTS (
    SELECT 1
    FROM exercise_reset_logs erl
    WHERE erl.reset_for = $1
      AND erl.exercise_id = $2
      AND erl.deleted_at IS NULL
      AND erl.reset_at > tgd.created_at
  )
ORDER BY tgd.created_at DESC
LIMIT 1
      "#,
        user_id,
        exercise_id,
    )
    .fetch_optional(conn)
    .await?;
    Ok(res)
}

pub async fn try_to_get_latest_grading_decision_by_user_exercise_state_id_for_users(
    conn: &mut PgConnection,
    user_exercise_state_ids: &[Uuid],
) -> ModelResult<HashMap<Uuid, TeacherGradingDecision>> {
    let decisions = sqlx::query_as!(
        TeacherGradingDecision,
        r#"
SELECT DISTINCT ON (user_exercise_state_id) id,
  user_exercise_state_id,
  user_id,
  created_at,
  updated_at,
  deleted_at,
  score_given,
  teacher_decision,
  justification,
  hidden
FROM teacher_grading_decisions
WHERE user_exercise_state_id = ANY($1)
  AND deleted_at IS NULL
ORDER BY user_exercise_state_id,
  created_at DESC
      "#,
        user_exercise_state_ids,
    )
    .fetch_all(conn)
    .await?;

    let mut res: HashMap<Uuid, TeacherGradingDecision> = HashMap::new();
    for item in decisions.into_iter() {
        res.insert(item.user_exercise_state_id, item);
    }

    Ok(res)
}

pub async fn get_all_latest_grading_decisions_by_user_id_and_course_id(
    conn: &mut PgConnection,
    user_id: Uuid,
    course_id: Uuid,
) -> ModelResult<Vec<TeacherGradingDecision>> {
    let res = sqlx::query_as!(
        TeacherGradingDecision,
        r#"
SELECT DISTINCT ON (user_exercise_state_id)
  id,
  user_exercise_state_id,
  user_id,
  created_at,
  updated_at,
  deleted_at,
  score_given,
  teacher_decision,
  justification,
  hidden
FROM teacher_grading_decisions
WHERE user_exercise_state_id IN (
    SELECT user_exercise_states.id
    FROM user_exercise_states
    WHERE user_exercise_states.user_id = $1
      AND user_exercise_states.course_id = $2
      AND user_exercise_states.deleted_at IS NULL
  )
  AND deleted_at IS NULL
  ORDER BY user_exercise_state_id, created_at DESC
      "#,
        user_id,
        course_id,
    )
    .fetch_all(conn)
    .await?;
    Ok(res)
}

pub async fn get_all_latest_grading_decisions_by_user_id_and_exam_id(
    conn: &mut PgConnection,
    user_id: Uuid,
    exam_id: Uuid,
) -> ModelResult<Vec<TeacherGradingDecision>> {
    let res = sqlx::query_as!(
        TeacherGradingDecision,
        r#"
SELECT DISTINCT ON (user_exercise_state_id)
  id,
  user_exercise_state_id,
  user_id,
  created_at,
  updated_at,
  deleted_at,
  score_given,
  teacher_decision,
  justification,
  hidden
FROM teacher_grading_decisions
WHERE user_exercise_state_id IN (
    SELECT user_exercise_states.id
    FROM user_exercise_states
    WHERE user_exercise_states.user_id = $1
      AND user_exercise_states.exam_id = $2
      AND user_exercise_states.deleted_at IS NULL
  )
  AND deleted_at IS NULL
  ORDER BY user_exercise_state_id, created_at DESC
      "#,
        user_id,
        exam_id,
    )
    .fetch_all(conn)
    .await?;
    Ok(res)
}

pub async fn update_teacher_grading_decision_hidden_field(
    conn: &mut PgConnection,
    teacher_grading_decision_id: Uuid,
    hidden: bool,
) -> ModelResult<TeacherGradingDecision> {
    let res = sqlx::query_as!(
        TeacherGradingDecision,
        r#"
        UPDATE teacher_grading_decisions
        SET hidden = $1
        WHERE id = $2
        RETURNING *;
              "#,
        hidden,
        teacher_grading_decision_id
    )
    .fetch_one(conn)
    .await?;
    Ok(res)
}

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