headless_lms_models/

peer_or_self_review_configs.rs

use futures::future::BoxFuture;
use url::Url;
use utoipa::ToSchema;

use crate::error::{ensure_version, missing_model_error};
use crate::{
    exercise_service_info::ExerciseServiceInfoApi,
    exercises::{self, Exercise},
    library::{self, peer_or_self_reviewing::CourseMaterialPeerOrSelfReviewData},
    peer_or_self_review_questions::{
        CmsPeerOrSelfReviewQuestion,
        delete_peer_or_self_review_questions_by_peer_or_self_review_config_ids,
        upsert_multiple_peer_or_self_review_questions,
    },
    prelude::*,
    user_exercise_states::{self, ReviewingStage},
};

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

pub struct PeerOrSelfReviewConfig {
    pub id: Uuid,
    pub created_at: DateTime<Utc>,
    pub updated_at: DateTime<Utc>,
    pub deleted_at: Option<DateTime<Utc>>,
    pub course_id: Uuid,
    pub exercise_id: Option<Uuid>,
    pub peer_reviews_to_give: i32,
    pub peer_reviews_to_receive: i32,
    pub accepting_threshold: f32,
    pub processing_strategy: PeerReviewProcessingStrategy,
    pub manual_review_cutoff_in_days: i32,
    pub points_are_all_or_nothing: bool,
    pub reset_answer_if_zero_points_from_review: bool,
    pub review_instructions: Option<serde_json::Value>,
}

/// Like `PeerOrSelfReviewConfig` but only the fields it's fine to show to all users.
#[derive(Debug, Serialize, Deserialize, PartialEq, Clone, ToSchema)]

pub struct CourseMaterialPeerOrSelfReviewConfig {
    pub id: Uuid,
    pub course_id: Uuid,
    pub exercise_id: Option<Uuid>,
    pub peer_reviews_to_give: i32,
    pub peer_reviews_to_receive: i32,
}

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

pub struct CmsPeerOrSelfReviewConfig {
    pub id: Uuid,
    pub course_id: Uuid,
    pub exercise_id: Option<Uuid>,
    pub peer_reviews_to_give: i32,
    pub peer_reviews_to_receive: i32,
    pub accepting_threshold: f32,
    pub processing_strategy: PeerReviewProcessingStrategy,
    pub points_are_all_or_nothing: bool,
    pub reset_answer_if_zero_points_from_review: bool,
    pub review_instructions: Option<serde_json::Value>,
}

impl CmsPeerOrSelfReviewConfig {
    /// The names of the review settings that differ from `other`'s: every field but the ids, the
    /// course and the review instructions.
    pub fn settings_differing_from(&self, other: &CmsPeerOrSelfReviewConfig) -> Vec<&'static str> {
        let CmsPeerOrSelfReviewConfig {
            id: _,
            course_id: _,
            exercise_id: _,
            peer_reviews_to_give,
            peer_reviews_to_receive,
            accepting_threshold,
            processing_strategy,
            points_are_all_or_nothing,
            reset_answer_if_zero_points_from_review,
            review_instructions: _,
        } = self;
        [
            (
                "peer_reviews_to_give",
                *peer_reviews_to_give != other.peer_reviews_to_give,
            ),
            (
                "peer_reviews_to_receive",
                *peer_reviews_to_receive != other.peer_reviews_to_receive,
            ),
            (
                "accepting_threshold",
                *accepting_threshold != other.accepting_threshold,
            ),
            (
                "processing_strategy",
                *processing_strategy != other.processing_strategy,
            ),
            (
                "points_are_all_or_nothing",
                *points_are_all_or_nothing != other.points_are_all_or_nothing,
            ),
            (
                "reset_answer_if_zero_points_from_review",
                *reset_answer_if_zero_points_from_review
                    != other.reset_answer_if_zero_points_from_review,
            ),
        ]
        .into_iter()
        .filter(|(_, differs)| *differs)
        .map(|(name, _)| name)
        .collect()
    }
}

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

pub struct CmsPeerOrSelfReviewConfiguration {
    pub peer_or_self_review_config: CmsPeerOrSelfReviewConfig,
    pub peer_or_self_review_questions: Vec<CmsPeerOrSelfReviewQuestion>,
}

/// A course's default configuration as the CMS loaded it. `updated_at` is the version the editor
/// sends back on save.
#[derive(Debug, Serialize, Deserialize, PartialEq, Clone, ToSchema)]
pub struct VersionedCmsPeerOrSelfReviewConfiguration {
    #[serde(flatten)]
    pub configuration: CmsPeerOrSelfReviewConfiguration,
    pub updated_at: DateTime<Utc>,
}

/// Save of a course's default configuration. A save is refused as stale when `expected_updated_at`
/// is set and the configuration has changed since that version; leave it unset to overwrite.
#[derive(Debug, Serialize, Deserialize, PartialEq, Clone, ToSchema)]
pub struct CmsPeerOrSelfReviewConfigurationSave {
    #[serde(flatten)]
    pub configuration: CmsPeerOrSelfReviewConfiguration,
    pub expected_updated_at: Option<DateTime<Utc>>,
}

/**
Determines how we will treat the answer being peer reviewed once it has received enough reviews and the student has given enough peer reviews.

Some strategies compare the overall received peer review likert answer (1-5) average to peer_reviews.accepting threshold.
*/
#[derive(Debug, Serialize, Deserialize, PartialEq, Eq, Clone, Copy, sqlx::Type, ToSchema)]
#[sqlx(
    type_name = "peer_review_processing_strategy",
    rename_all = "snake_case"
)]
pub enum PeerReviewProcessingStrategy {
    /// If the average of the peer review likert answers is greater than the threshold, the peer review is accepted, otherwise it is rejected.
    AutomaticallyGradeByAverage,
    /// If the average of the peer review likert answers is greater than the threshold, the peer review is accepted, otherwise it is sent to be manually reviewed by the teacher.
    AutomaticallyGradeOrManualReviewByAverage,
    /// All answers will be sent to be manually reviewed by the teacher once they have received and given enough peer reviews.
    ManualReviewEverything,
}

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

pub async fn upsert_with_id(
    conn: &mut PgConnection,
    pkey_policy: PKeyPolicy<Uuid>,
    cms_peer_review: &CmsPeerOrSelfReviewConfig,
) -> ModelResult<CmsPeerOrSelfReviewConfig> {
    let res = sqlx::query_as!(
        CmsPeerOrSelfReviewConfig,
        r#"
    INSERT INTO peer_or_self_review_configs (
    id,
    course_id,
    exercise_id,
    peer_reviews_to_give,
    peer_reviews_to_receive,
    accepting_threshold,
    processing_strategy,
    points_are_all_or_nothing,
    review_instructions,
    reset_answer_if_zero_points_from_review
  )
VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10) ON CONFLICT (id) DO
UPDATE
SET course_id = excluded.course_id,
  exercise_id = excluded.exercise_id,
  peer_reviews_to_give = excluded.peer_reviews_to_give,
  peer_reviews_to_receive = excluded.peer_reviews_to_receive,
  accepting_threshold = excluded.accepting_threshold,
  processing_strategy = excluded.processing_strategy,
  points_are_all_or_nothing = excluded.points_are_all_or_nothing,
  reset_answer_if_zero_points_from_review = excluded.reset_answer_if_zero_points_from_review,
  review_instructions = excluded.review_instructions
RETURNING id,
  course_id,
  exercise_id,
  peer_reviews_to_give,
  peer_reviews_to_receive,
  accepting_threshold,
  processing_strategy,
  points_are_all_or_nothing,
  review_instructions,
  reset_answer_if_zero_points_from_review
"#,
        pkey_policy.into_uuid(),
        cms_peer_review.course_id,
        cms_peer_review.exercise_id,
        cms_peer_review.peer_reviews_to_give,
        cms_peer_review.peer_reviews_to_receive,
        cms_peer_review.accepting_threshold,
        cms_peer_review.processing_strategy as _,
        cms_peer_review.points_are_all_or_nothing,
        cms_peer_review.review_instructions,
        cms_peer_review.reset_answer_if_zero_points_from_review,
    )
    .fetch_one(conn)
    .await?;
    Ok(res)
}

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

/// The configs with the ids that aren't deleted, in no particular order.
pub async fn get_by_ids(
    conn: &mut PgConnection,
    ids: &[Uuid],
) -> ModelResult<Vec<PeerOrSelfReviewConfig>> {
    let res = sqlx::query_as!(
        PeerOrSelfReviewConfig,
        r#"
SELECT *
FROM peer_or_self_review_configs
WHERE id = ANY($1)
  AND deleted_at IS NULL
        "#,
        ids
    )
    .fetch_all(conn)
    .await?;
    Ok(res)
}

/// Usually you want to use `get_by_exercise_or_course_id` instead of this one.
pub async fn get_by_exercise_id(
    conn: &mut PgConnection,
    exercise_id: Uuid,
) -> ModelResult<PeerOrSelfReviewConfig> {
    let res = sqlx::query_as!(
        PeerOrSelfReviewConfig,
        r#"
SELECT *
FROM peer_or_self_review_configs
WHERE exercise_id = $1
  AND deleted_at IS NULL
        "#,
        exercise_id
    )
    .fetch_one(conn)
    .await?;
    Ok(res)
}

/// Returns the correct peer review config depending on `exercise.use_course_default_peer_or_self_review_config`.
pub async fn get_by_exercise_or_course_id(
    conn: &mut PgConnection,
    exercise: &Exercise,
    course_id: Uuid,
) -> ModelResult<PeerOrSelfReviewConfig> {
    if exercise.use_course_default_peer_or_self_review_config {
        get_default_for_course_by_course_id(conn, course_id).await
    } else {
        get_by_exercise_id(conn, exercise.id).await
    }
}

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

pub async fn delete(conn: &mut PgConnection, id: Uuid) -> ModelResult<Uuid> {
    let res = sqlx::query!(
        "
UPDATE peer_or_self_review_configs
SET deleted_at = now()
WHERE id = $1
AND deleted_at IS NULL
RETURNING *
    ",
        id
    )
    .fetch_one(conn)
    .await?;
    Ok(res.id)
}

pub async fn get_course_material_peer_or_self_review_data(
    conn: &mut PgConnection,
    user_id: Uuid,
    exercise_id: Uuid,
    fetch_service_info: impl Fn(Url) -> BoxFuture<'static, ModelResult<ExerciseServiceInfoApi>>,
    file_store: &dyn FileStore,
    app_conf: &ApplicationConfiguration,
) -> ModelResult<CourseMaterialPeerOrSelfReviewData> {
    let exercise = exercises::get_by_id(conn, exercise_id).await?;
    let (_current_exercise_slide, instance_or_exam_id) = exercises::get_or_select_exercise_slide(
        &mut *conn,
        Some(user_id),
        &exercise,
        &fetch_service_info,
        file_store,
        app_conf,
    )
    .await?;

    let user_exercise_state = match instance_or_exam_id {
        Some(course_or_exam_id) => {
            user_exercise_states::get_user_exercise_state_if_exists(
                conn,
                user_id,
                exercise.id,
                course_or_exam_id,
            )
            .await?
        }
        _ => None,
    };

    match user_exercise_state {
        Some(ref user_exercise_state) => {
            if matches!(
                user_exercise_state.reviewing_stage,
                ReviewingStage::PeerReview | ReviewingStage::WaitingForPeerReviews
            ) {
                // Calling library inside a model function. Maybe should be refactored by moving
                // complicated logic to own library file?
                let res = library::peer_or_self_reviewing::try_to_select_exercise_slide_submission_for_peer_review(
                    conn,
                    &exercise,
                    user_exercise_state,
                    &fetch_service_info,
                    file_store,
                    app_conf,
                )
                .await?;
                Ok(res)
            } else if user_exercise_state.reviewing_stage == ReviewingStage::SelfReview {
                let res = library::peer_or_self_reviewing::select_own_submission_for_self_review(
                    conn,
                    &exercise,
                    user_exercise_state,
                    &fetch_service_info,
                    file_store,
                    app_conf,
                )
                .await?;
                Ok(res)
            } else {
                Err(ModelError::new(
                    ModelErrorType::PreconditionFailed,
                    "You cannot peer review yet".to_string(),
                    None,
                ))
            }
        }
        None => Err(ModelError::new(
            ModelErrorType::InvalidRequest,
            "You haven't answered this exercise".to_string(),
            None,
        )),
    }
}

/// The review configs of the undeleted exercises on the pages.
pub async fn get_peer_reviews_by_page_ids(
    conn: &mut PgConnection,
    page_ids: &[Uuid],
) -> ModelResult<Vec<CmsPeerOrSelfReviewConfig>> {
    let res = sqlx::query_as!(
        CmsPeerOrSelfReviewConfig,
        r#"
SELECT pr.id as id,
  pr.course_id as course_id,
  pr.exercise_id as exercise_id,
  pr.peer_reviews_to_give as peer_reviews_to_give,
  pr.peer_reviews_to_receive as peer_reviews_to_receive,
  pr.accepting_threshold as accepting_threshold,
  pr.processing_strategy,
  points_are_all_or_nothing,
  pr.reset_answer_if_zero_points_from_review,
  pr.review_instructions
from pages p
  join exercises e on p.id = e.page_id
  join peer_or_self_review_configs pr on e.id = pr.exercise_id
where p.id = ANY($1)
  AND p.deleted_at IS NULL
  AND e.deleted_at IS NULL
  AND pr.deleted_at IS NULL;
    "#,
        page_ids,
    )
    .fetch_all(conn)
    .await?;

    Ok(res)
}

pub async fn delete_peer_reviews_by_exrcise_ids(
    conn: &mut PgConnection,
    exercise_ids: &[Uuid],
) -> ModelResult<Vec<Uuid>> {
    let res = sqlx::query!(
        "
UPDATE peer_or_self_review_configs
SET deleted_at = now()
WHERE exercise_id = ANY ($1)
AND deleted_at IS NULL
RETURNING *;
    ",
        exercise_ids
    )
    .fetch_all(conn)
    .await?
    .into_iter()
    .map(|x| x.id)
    .collect();
    Ok(res)
}

pub async fn get_course_default_cms_peer_review(
    conn: &mut PgConnection,
    course_id: Uuid,
) -> ModelResult<CmsPeerOrSelfReviewConfig> {
    let res = sqlx::query_as!(
        CmsPeerOrSelfReviewConfig,
        r#"
SELECT id,
  course_id,
  exercise_id,
  peer_reviews_to_give,
  peer_reviews_to_receive,
  accepting_threshold,
  processing_strategy,
  points_are_all_or_nothing,
  reset_answer_if_zero_points_from_review,
  review_instructions
FROM peer_or_self_review_configs
WHERE course_id = $1
  AND exercise_id IS NULL
  AND deleted_at IS NULL;
"#,
        course_id
    )
    .fetch_one(conn)
    .await?;
    Ok(res)
}

/// Sets the review instructions of the course's default config, leaving its other settings as
/// they are. Errors with `PreconditionFailed` if `config_id` isn't the course's default config.
pub async fn set_course_default_review_instructions(
    conn: &mut PgConnection,
    config_id: Uuid,
    course_id: Uuid,
    review_instructions: Option<&serde_json::Value>,
) -> ModelResult<()> {
    let updated = sqlx::query!(
        r#"
UPDATE peer_or_self_review_configs
SET review_instructions = $3
WHERE id = $1
  AND course_id = $2
  AND exercise_id IS NULL
  AND deleted_at IS NULL
        "#,
        config_id,
        course_id,
        review_instructions,
    )
    .execute(conn)
    .await?;
    if updated.rows_affected() == 0 {
        return Err(model_err!(
            PreconditionFailed,
            "The course default review config doesn't exist".to_string()
        ));
    }
    Ok(())
}

pub async fn get_cms_peer_review_by_id(
    conn: &mut PgConnection,
    peer_or_self_review_config_id: Uuid,
) -> ModelResult<CmsPeerOrSelfReviewConfig> {
    let res = sqlx::query_as!(
        CmsPeerOrSelfReviewConfig,
        r#"
SELECT id,
  course_id,
  exercise_id,
  peer_reviews_to_give,
  peer_reviews_to_receive,
  accepting_threshold,
  processing_strategy,
  points_are_all_or_nothing,
  reset_answer_if_zero_points_from_review,
  review_instructions
FROM peer_or_self_review_configs
WHERE id = $1;
    "#,
        peer_or_self_review_config_id
    )
    .fetch_one(conn)
    .await?;
    Ok(res)
}

pub async fn upsert_course_default_cms_peer_review_and_questions(
    conn: &mut PgConnection,
    peer_or_self_review_configuration: &CmsPeerOrSelfReviewConfiguration,
) -> ModelResult<CmsPeerOrSelfReviewConfiguration> {
    // Upsert peer review
    let peer_or_self_review_config = upsert_with_id(
        conn,
        PKeyPolicy::Fixed(
            peer_or_self_review_configuration
                .peer_or_self_review_config
                .id,
        ),
        &peer_or_self_review_configuration.peer_or_self_review_config,
    )
    .await?;

    // Upsert peer review questions
    let previous_peer_or_self_review_question_ids =
        delete_peer_or_self_review_questions_by_peer_or_self_review_config_ids(
            conn,
            &[peer_or_self_review_config.id],
        )
        .await?;
    let peer_or_self_review_questions = upsert_multiple_peer_or_self_review_questions(
        conn,
        &peer_or_self_review_configuration
            .peer_or_self_review_questions
            .iter()
            .map(|prq| {
                let id = if previous_peer_or_self_review_question_ids.contains(&prq.id) {
                    prq.id
                } else {
                    Uuid::new_v4()
                };
                CmsPeerOrSelfReviewQuestion { id, ..prq.clone() }
            })
            .collect::<Vec<_>>(),
    )
    .await?;

    Ok(CmsPeerOrSelfReviewConfiguration {
        peer_or_self_review_config,
        peer_or_self_review_questions,
    })
}

/// With `expected_updated_at` set, refuses with [ModelErrorType::StaleVersion] unless the config
/// row still has that `updated_at`. The check runs under the row lock.
pub async fn upsert_for_course_id(
    conn: &mut PgConnection,
    course_id: Uuid,
    peer_or_self_review_configuration: &CmsPeerOrSelfReviewConfiguration,
    expected_updated_at: Option<DateTime<Utc>>,
) -> ModelResult<VersionedCmsPeerOrSelfReviewConfiguration> {
    let input = &peer_or_self_review_configuration.peer_or_self_review_config;
    if input.course_id != course_id {
        return Err(model_err!(
            PreconditionFailed,
            "Peer review config course does not match expected course".to_string()
        ));
    }
    if peer_or_self_review_configuration
        .peer_or_self_review_questions
        .iter()
        .any(|q| q.peer_or_self_review_config_id != input.id)
    {
        return Err(model_err!(
            PreconditionFailed,
            "Peer review questions do not belong to the peer review config".to_string()
        ));
    }

    let mut tx = conn.begin().await?;
    if expected_updated_at.is_some() {
        let current_updated_at = sqlx::query_scalar!(
            "
SELECT updated_at
FROM peer_or_self_review_configs
WHERE id = $1
  AND course_id = $2
  AND deleted_at IS NULL
FOR UPDATE
",
            input.id,
            course_id
        )
        .fetch_optional(&mut *tx)
        .await?;
        ensure_version(
            current_updated_at,
            expected_updated_at,
            "The default peer review settings were changed after they were opened.",
        )?;
    }
    let peer_or_self_review_config = sqlx::query_as!(
        CmsPeerOrSelfReviewConfig,
        r#"
INSERT INTO peer_or_self_review_configs (
    id,
    course_id,
    exercise_id,
    peer_reviews_to_give,
    peer_reviews_to_receive,
    accepting_threshold,
    processing_strategy,
    points_are_all_or_nothing,
    review_instructions,
    reset_answer_if_zero_points_from_review
)
SELECT $1, $2, $3, $4, $5, $6, $7, $8, $9, $10
WHERE (
    $3::uuid IS NULL
    OR EXISTS (
      SELECT 1
      FROM exercises
      WHERE id = $3
        AND course_id = $2
        AND deleted_at IS NULL
    )
)
ON CONFLICT (id) DO UPDATE
SET course_id = excluded.course_id,
  exercise_id = excluded.exercise_id,
  peer_reviews_to_give = excluded.peer_reviews_to_give,
  peer_reviews_to_receive = excluded.peer_reviews_to_receive,
  accepting_threshold = excluded.accepting_threshold,
  processing_strategy = excluded.processing_strategy,
  points_are_all_or_nothing = excluded.points_are_all_or_nothing,
  reset_answer_if_zero_points_from_review = excluded.reset_answer_if_zero_points_from_review,
  review_instructions = excluded.review_instructions,
  deleted_at = NULL
WHERE peer_or_self_review_configs.course_id = $2
RETURNING id,
  course_id,
  exercise_id,
  peer_reviews_to_give,
  peer_reviews_to_receive,
  accepting_threshold,
  processing_strategy,
  points_are_all_or_nothing,
  review_instructions,
  reset_answer_if_zero_points_from_review
        "#,
        input.id,
        course_id,
        input.exercise_id,
        input.peer_reviews_to_give,
        input.peer_reviews_to_receive,
        input.accepting_threshold,
        input.processing_strategy as _,
        input.points_are_all_or_nothing,
        input.review_instructions,
        input.reset_answer_if_zero_points_from_review,
    )
    .fetch_optional(&mut *tx)
    .await?;
    let Some(peer_or_self_review_config) = peer_or_self_review_config else {
        return Err(model_err!(
            PreconditionFailed,
            "Peer review config exercise does not belong to the expected course".to_string()
        ));
    };

    let previous_peer_or_self_review_question_ids =
        delete_peer_or_self_review_questions_by_peer_or_self_review_config_ids(
            &mut tx,
            &[peer_or_self_review_config.id],
        )
        .await?;
    let peer_or_self_review_questions = upsert_multiple_peer_or_self_review_questions(
        &mut tx,
        &peer_or_self_review_configuration
            .peer_or_self_review_questions
            .iter()
            .map(|prq| {
                let id = if previous_peer_or_self_review_question_ids.contains(&prq.id) {
                    prq.id
                } else {
                    Uuid::new_v4()
                };
                CmsPeerOrSelfReviewQuestion { id, ..prq.clone() }
            })
            .collect::<Vec<_>>(),
    )
    .await?;

    let updated_at = get_by_id(&mut tx, peer_or_self_review_config.id)
        .await?
        .updated_at;
    tx.commit().await?;

    Ok(VersionedCmsPeerOrSelfReviewConfiguration {
        configuration: CmsPeerOrSelfReviewConfiguration {
            peer_or_self_review_config,
            peer_or_self_review_questions,
        },
        updated_at,
    })
}

/// The course's default configuration with its questions; `None` if the course has none.
pub async fn get_course_default_cms_peer_review_configuration(
    conn: &mut PgConnection,
    course_id: Uuid,
) -> ModelResult<Option<CmsPeerOrSelfReviewConfiguration>> {
    let mut tx = conn.begin().await?;
    let Some(peer_or_self_review_config) = get_course_default_cms_peer_review(&mut tx, course_id)
        .await
        .optional()?
    else {
        tx.rollback().await?;
        return Ok(None);
    };
    let peer_or_self_review_questions =
        crate::peer_or_self_review_questions::get_course_default_cms_peer_or_self_review_questions(
            &mut tx,
            peer_or_self_review_config.id,
        )
        .await?;
    tx.commit().await?;
    Ok(Some(CmsPeerOrSelfReviewConfiguration {
        peer_or_self_review_config,
        peer_or_self_review_questions,
    }))
}

/// The course default configuration with its questions, as the CMS edits it.
pub async fn get_course_default_versioned_cms_peer_review(
    conn: &mut PgConnection,
    course_id: Uuid,
) -> ModelResult<VersionedCmsPeerOrSelfReviewConfiguration> {
    let mut tx = conn.begin().await?;
    let configuration = get_course_default_cms_peer_review_configuration(&mut tx, course_id)
        .await?
        .ok_or_else(missing_model_error(
            ModelErrorType::RecordNotFound,
            "The course has no default peer review config",
        ))?;
    let updated_at = get_by_id(&mut tx, configuration.peer_or_self_review_config.id)
        .await?
        .updated_at;
    tx.commit().await?;
    Ok(VersionedCmsPeerOrSelfReviewConfiguration {
        configuration,
        updated_at,
    })
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::test_helper::*;

    #[tokio::test]
    async fn only_one_default_peer_review_per_course() {
        insert_data!(:tx, :user, :org, :course);

        let peer_review_1 = insert(tx.as_mut(), PKeyPolicy::Generate, course, None).await;
        assert!(peer_review_1.is_err());
    }
}