headless_lms_models/

code_giveaway_codes.rs

use futures::Stream;
use sqlx::{QueryBuilder, Row};
use utoipa::ToSchema;

use crate::prelude::*;

#[derive(Debug, Serialize, Deserialize, Clone, ToSchema)]
pub struct CodeGiveawayCode {
    pub id: Uuid,
    pub created_at: DateTime<Utc>,
    pub updated_at: DateTime<Utc>,
    pub deleted_at: Option<DateTime<Utc>>,
    pub code_giveaway_id: Uuid,
    pub code_given_to_user_id: Option<Uuid>,
    pub added_by_user_id: Uuid,
    #[schema(value_type = String)]
    pub code: OutboundSecret,
}

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

pub async fn insert_many(
    conn: &mut PgConnection,
    code_giveaway_id: Uuid,
    input: &[String],
    added_by_user_id: Uuid,
) -> ModelResult<Vec<CodeGiveawayCode>> {
    if input.is_empty() {
        return Ok(vec![]);
    }
    let mut query_builder = QueryBuilder::new(
        "INSERT INTO code_giveaway_codes (code_giveaway_id, code, added_by_user_id) ",
    );

    query_builder.push_values(input, |mut b, code| {
        b.push_bind(code_giveaway_id)
            .push_bind(code.trim())
            .push_bind(added_by_user_id);
    });

    query_builder.push(" RETURNING id");

    let query = query_builder.build();

    let ids: Vec<Uuid> = query
        .fetch_all(&mut *conn)
        .await?
        .iter()
        .map(|row| row.get("id"))
        .collect();

    // Fetch the inserted rows to return them
    let res = sqlx::query_as!(
        CodeGiveawayCode,
        r#"
SELECT *
FROM code_giveaway_codes
WHERE code_giveaway_id = $1
  AND added_by_user_id = $2
  AND id = ANY($3)
    "#,
        code_giveaway_id,
        added_by_user_id,
        &ids
    )
    .fetch_all(&mut *conn)
    .await?;

    Ok(res)
}

pub async fn get_all_by_code_giveaway_id(
    conn: &mut PgConnection,
    code_giveaway_id: Uuid,
) -> ModelResult<Vec<CodeGiveawayCode>> {
    let res = sqlx::query_as!(
        CodeGiveawayCode,
        r#"
SELECT *
FROM code_giveaway_codes
WHERE code_giveaway_id = $1
  AND deleted_at IS NULL
        "#,
        code_giveaway_id
    )
    .fetch_all(conn)
    .await?;
    Ok(res)
}

pub async fn get_code_given_to_user(
    conn: &mut PgConnection,
    code_giveaway_id: Uuid,
    user_id: Uuid,
) -> ModelResult<Option<CodeGiveawayCode>> {
    let res = sqlx::query_as!(
        CodeGiveawayCode,
        r#"
SELECT *
FROM code_giveaway_codes
WHERE code_giveaway_id = $1
  AND code_given_to_user_id = $2
  AND deleted_at IS NULL
        "#,
        code_giveaway_id,
        user_id
    )
    .fetch_optional(conn)
    .await?;
    Ok(res)
}

pub async fn give_some_code_to_user(
    conn: &mut PgConnection,
    code_giveaway_id: Uuid,
    user_id: Uuid,
) -> ModelResult<CodeGiveawayCode> {
    let res = sqlx::query_as!(
        CodeGiveawayCode,
        r#"
WITH to_update AS (
    SELECT *
    FROM code_giveaway_codes
    WHERE code_giveaway_id = $1
      AND code_given_to_user_id IS NULL
      AND deleted_at IS NULL
    LIMIT 1
)
UPDATE code_giveaway_codes cgc
SET code_given_to_user_id = $2
FROM to_update
WHERE cgc.id = to_update.id
RETURNING cgc.*
        "#,
        code_giveaway_id,
        user_id
    )
    .fetch_one(conn)
    .await?;
    Ok(res)
}

#[allow(clippy::needless_lifetimes)]
pub async fn stream_given_code_giveaway_codes<'a>(
    conn: &'a mut PgConnection,
    code_giveaway_id: Uuid,
) -> impl Stream<Item = sqlx::Result<CodeGiveawayCode>> + 'a {
    sqlx::query_as!(
        CodeGiveawayCode,
        r#"
SELECT *
FROM code_giveaway_codes
WHERE code_giveaway_id = $1
  AND deleted_at IS NULL
  AND code_given_to_user_id IS NOT NULL
            "#,
        code_giveaway_id
    )
    .fetch(conn)
}

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

pub async fn are_any_codes_left(
    conn: &mut PgConnection,
    code_giveaway_id: Uuid,
) -> ModelResult<bool> {
    let res = sqlx::query!(
        r#"
SELECT EXISTS(
    SELECT 1
    FROM code_giveaway_codes
    WHERE code_giveaway_id = $1
      AND code_given_to_user_id IS NULL
      AND deleted_at IS NULL
    LIMIT 1
  )
        "#,
        code_giveaway_id
    )
    .fetch_one(conn)
    .await?;
    res.exists.ok_or_else(|| {
        ModelError::new(
            ModelErrorType::Database,
            "EXISTS query returned None - this should never happen".to_string(),
            None,
        )
    })
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::{code_giveaways::NewCodeGiveaway, test_helper::*};
    use secrecy::ExposeSecret;

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

        let code_giveaway = crate::code_giveaways::insert(
            tx.as_mut(),
            &NewCodeGiveaway {
                course_id: course,
                name: "Test giveaway".to_string(),
                course_module_id: None,
                require_course_specific_consent_form_question_id: None,
            },
        )
        .await
        .unwrap();

        let insert_result = insert_many(tx.as_mut(), code_giveaway.id, &[], user)
            .await
            .unwrap();

        assert!(insert_result.is_empty());
    }

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

        let code_giveaway = crate::code_giveaways::insert(
            tx.as_mut(),
            &NewCodeGiveaway {
                course_id: course,
                name: "Test giveaway".to_string(),
                course_module_id: None,
                require_course_specific_consent_form_question_id: None,
            },
        )
        .await
        .unwrap();

        let codes = vec![
            "code1".to_string(),
            "code2".to_string(),
            "code3".to_string(),
        ];

        let insert_result = insert_many(tx.as_mut(), code_giveaway.id, &codes, user)
            .await
            .unwrap();

        assert_eq!(insert_result.len(), codes.len());
        for code in &codes {
            let found = insert_result
                .iter()
                .find(|c| c.code.expose_secret() == code.as_str());
            assert!(found.is_some());
        }
        // Double checking
        let all_codes = get_all_by_code_giveaway_id(tx.as_mut(), code_giveaway.id)
            .await
            .unwrap();
        assert_eq!(all_codes.len(), codes.len());
        for code in &codes {
            let found = all_codes
                .iter()
                .find(|c| c.code.expose_secret() == code.as_str());
            assert!(found.is_some());
        }
    }
}