jap_learn/src/data_provider/decks.rs

use crate::core::srs::OrderMode;
use crate::data::entities::DeckSettings;
use crate::notification::NotificationData::{DbLoadError, DbSaveError};
use crate::notification::{MaybeError, NotificationData};
use rusqlite::Connection;

pub fn load_sets(connection: &Connection) -> Result<Vec<DeckSettings>, NotificationData> {
    let mut stmt = connection
        .prepare("SELECT id, name, forward, backward, filter FROM decks")
        .expect("Failed to prepare state query");
    let iter = stmt
        .query_map([], |row| {
            Ok(DeckSettings {
                id: row.get(0)?,
                name: row.get(1)?,
                forward: row.get(2)?,
                backward: row.get(3)?,
                filter: row.get(4)?,
                count: None,
                open_mode: OrderMode::Default,
            })
        })
        .map_err(|_| DbLoadError)?;

    let mut buffer = Vec::with_capacity(16);
    iter.filter_map(|res| res.ok()).for_each(|i| buffer.push(i));
    Ok(buffer)
}

pub fn add_set(set: &mut DeckSettings, connection: &Connection) -> MaybeError {
    let index : u32 = connection
        .query_row(
            "INSERT INTO decks (name, forward, backward, filter) VALUES (?1, ?2, ?3, ?4) RETURNING id",
            (
                &set.name,
                &set.forward,
                &set.backward,
                &set.filter,
            ),
            |row| row.get(0)
        )
        .map_err(|_| DbSaveError)?;

    set.id = index.into();
    Ok(())
}

pub fn update_deck(set: &mut DeckSettings, connection: &Connection) -> MaybeError {
    if !set.id.is_valid() {
        add_set(set, connection)?;
    } else {
        connection
            .execute(
                "UPDATE decks SET name = ?1, forward = ?2, backward = ?3, filter = ?4 WHERE id = ?5",
                (
                    &set.name,
                    &set.forward,
                    &set.backward,
                    &set.filter,
                    &set.id
                ),
            )
            .map_err(|_| DbSaveError)?;
    }
    Ok(())
}

pub fn delete_set(set: &DeckSettings, connection: &Connection) -> MaybeError {
    if !set.id.is_valid() {
        return Err(DbSaveError);
    }
    connection
        .execute("DELETE FROM decks WHERE id = ?1", (&set.id,))
        .map_err(|_| DbSaveError)?;
    Ok(())
}