jap_learn/src/data_provider/history.rs

use crate::core::srs::WordOpenMode;
use crate::data::entities::HistoryNote;
use crate::data::repositories::{DataRepository, DataRepositoryInner};
use crate::data_provider::{SqliteDbLayer, TableAccessQuerySet};
use rusqlite::types::{FromSql, FromSqlResult, ToSqlOutput, ValueRef};
use rusqlite::{Error, Params, Row, ToSql};

pub type HistoryRepository = DataRepository<HistoryNote, HistoryDataLayer>;
pub type HistoryRepositoryInner = DataRepositoryInner<HistoryNote, HistoryDataLayer>;
pub type HistoryDataLayer = SqliteDbLayer<HistoryNote, HistoryQuerySet>;

#[derive(Clone)]
pub struct HistoryQuerySet;
impl TableAccessQuerySet<HistoryNote> for HistoryQuerySet {
    fn load() -> &'static str {
        "SELECT rowid, deck_id, word_id, timestamp, answer, before, after, fsrs FROM history"
    }

    fn save() -> &'static str {
        todo!("History is readonly")
    }

    fn add() -> &'static str {
        "INSERT INTO history (deck_id, state_id, timestamp, answer, before, after, fsrs) VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7)"
    }

    fn name() -> &'static str {
        "history"
    }

    fn from_sql(row: &Row) -> Result<HistoryNote, Error> {
        Ok(HistoryNote {
            id: row.get(0)?,
            timestamp: row.get(3)?,
            deck_id: row.get(1)?,
            word_id: row.get(2)?,
            answer: row.get(4)?,
            before: row.get(5)?,
            after: row.get(6)?,
            fsrs: row.get(7)?,
        })
    }

    fn insert_params(entity: &HistoryNote) -> impl Params {
        (
            entity.deck_id,
            entity.word_id,
            entity.timestamp,
            entity.answer,
            entity.before,
            entity.after,
            entity.fsrs,
        )
    }

    fn update_params(entity: &HistoryNote) -> impl Params {
        (
            entity.deck_id,
            entity.word_id,
            entity.timestamp,
            entity.answer,
            entity.before,
            entity.after,
            entity.fsrs,
        )
    }
}

impl FromSql for WordOpenMode {
    fn column_result(value: ValueRef<'_>) -> FromSqlResult<Self> {
        if let ValueRef::Integer(s) = value {
            return match s {
                1 => Ok(WordOpenMode::Hard),
                2 => Ok(WordOpenMode::Ok),
                3 => Ok(WordOpenMode::Easy),
                _ => Ok(WordOpenMode::None),
            }
        }
        Ok(WordOpenMode::None)
    }
}

impl ToSql for WordOpenMode {
    fn to_sql(&self) -> rusqlite::Result<ToSqlOutput<'_>> {
        Ok(ToSqlOutput::from(match self {
            WordOpenMode::Easy => 3,
            WordOpenMode::Ok => 2,
            WordOpenMode::Hard => 1,
            WordOpenMode::None => 0
        }))
    }
}