jap_learn/src/data_provider/settings.rs

use crate::notification::NotificationData::{DbLoadError, DbSaveError};
use crate::notification::{MaybeError, NotificationData};
use rusqlite::Connection;

pub fn get_setting(key: String, connection: &Connection) -> Option<String> {
    let mut stmt = connection
        .prepare("SELECT value FROM settings WHERE id = ?1")
        .expect("Failed to prepare statement.");
    let mut iter = stmt.query_map((key,), |row| row.get(0)).ok()?;

    if let Some(row) = iter.next()
        && let Ok(value) = row
    {
        return Some(value);
    }

    None
}

pub fn set_setting(key: String, value: String, connection: &Connection) -> MaybeError {
    let current = get_settings_list(connection)?;
    if current.contains(&key) {
        update_settings(key, value, connection)?;
    } else {
        create_settings(key, value, connection)?;
    }

    Ok(())
}

pub fn delete_settings(key: String, connection: &Connection) -> MaybeError {
    connection
        .execute("DELETE FROM settings WHERE id = ?1", (&key,))
        .map_err(|_| DbSaveError)?;
    Ok(())
}

fn create_settings(key: String, value: String, connection: &Connection) -> MaybeError {
    connection
        .execute(
            "INSERT into settings (id, value) VALUES (?1, ?2)",
            (key, value),
        )
        .map_err(|_| DbSaveError)?;
    Ok(())
}

fn update_settings(key: String, value: String, connection: &Connection) -> MaybeError {
    connection
        .execute(
            "update settings
set value = ?2
where id = ?1",
            (key, value),
        )
        .map_err(|_| DbSaveError)?;
    Ok(())
}

fn get_settings_list(connection: &Connection) -> Result<Vec<String>, NotificationData> {
    let mut stmt = connection
        .prepare("SELECT id FROM settings")
        .expect("prepare stmt failed");
    let iter = stmt
        .query_map((), |row| row.get(0))
        .map_err(|_| DbLoadError)?;
    Ok(iter.filter_map(|i| i.ok()).collect())
}