tiempo-rs/src/database.rs

use std::path::Path;

use rusqlite::{Connection, ToSql};
use chrono::{DateTime, Utc};

use crate::error::{Error, Result};
use crate::models::{Entry, Meta};

pub enum DBVersion {
    Timetrap,
    Version(u16),
}

pub trait Database {
    /// This is used to create tables and insert rows
    fn execute(&mut self, query: &str, params: &[&dyn ToSql]) -> Result<()>;

    /// And this is used to retrieve data
    fn entry_query(&self, query: &str, params: &[&dyn ToSql]) -> Result<Vec<Entry>>;
    fn meta_query(&self, query: &str, params: &[&dyn ToSql]) -> Result<Vec<Meta>>;

    // ----------
    // Migrations
    // ----------
    fn init(&mut self) -> Result<()> {
        self.execute("CREATE TABLE `entries`
            (
                `id` integer NOT NULL PRIMARY KEY AUTOINCREMENT,\
                `note` varchar(255),
                `start` timestamp,
                `end` timestamp,
                `sheet` varchar(255)
            )
        ", &[])?;
        self.execute("CREATE TABLE `meta`
            (
                `id` integer NOT NULL PRIMARY KEY AUTOINCREMENT,
                `key` varchar(255),
                `value` varchar(255)
            )
        ", &[])?;
        self.execute("INSERT INTO meta (key, value) VALUES ('database_version', 1)", &[])?;

        Ok(())
    }

    // -------------
    // Entry queries
    // -------------
    fn entries_by_sheet(&self, sheet: &str, start: Option<DateTime<Utc>>, end: Option<DateTime<Utc>>) -> Result<Vec<Entry>> {
        match (start, end) {
            (Some(start), Some(end)) => {
                self.entry_query(
                    "select * from entries where sheet=?1 and start >= ?2 and end <= ?2 order by start asc",
                    &[&sheet, &start, &end]
                )
            }
            (Some(start), None) => {
                self.entry_query(
                    "select * from entries where sheet=?1 and start >= ?2 order by start asc",
                    &[&sheet, &start]
                )
            }
            (None, Some(end)) => {
                self.entry_query(
                    "select * from entries where sheet=?1 and end <= ?2 order by start asc",
                    &[&sheet, &end]
                )
            }
            (None, None) => {
                self.entry_query(
                    "select * from entries where sheet=?1 order by start asc",
                    &[&sheet]
                )
            }
        }
    }

    fn entries_all_visible(&self, start: Option<DateTime<Utc>>, end: Option<DateTime<Utc>>) -> Result<Vec<Entry>> {
        match (start, end) {
            (Some(start), Some(end)) => {
                self.entry_query(
                    "select * from entries where sheet not like '!_%' escape \"!\"  and start >= ?2 and end <= ?2 order by start asc",
                    &[&start, &end]
                )
            }
            (Some(start), None) => {
                self.entry_query(
                    "select * from entries where sheet not like '!_%' escape \"!\"  and start >= ?2 order by start asc",
                    &[&start]
                )
            }
            (None, Some(end)) => {
                self.entry_query(
                    "select * from entries where sheet not like '!_%' escape \"!\"  and end <= ?2 order by start asc",
                    &[&end]
                )
            }
            (None, None) => {
                self.entry_query(
                    "select * from entries where sheet not like '!_%' escape \"!\"  order by start asc",
                    &[]
                )
            }
        }
    }

    fn entries_full(&self, start: Option<DateTime<Utc>>, end: Option<DateTime<Utc>>) -> Result<Vec<Entry>> {
        match (start, end) {
            (Some(start), Some(end)) => {
                self.entry_query(
                    "select * from entries where start >= ?2 and end <= ?2 order by start asc",
                    &[&start, &end]
                )
            }
            (Some(start), None) => {
                self.entry_query(
                    "select * from entries where start >= ?2 order by start asc",
                    &[&start]
                )
            }
            (None, Some(end)) => {
                self.entry_query(
                    "select * from entries where end <= ?2 order by start asc",
                    &[&end]
                )
            }
            (None, None) => {
                self.entry_query(
                    "select * from entries where sheet=?1 order by start asc",
                    &[]
                )
            }
        }
    }

    fn entry_insert(&mut self, start: DateTime<Utc>, end: Option<DateTime<Utc>>, note: Option<String>, sheet: String) -> Result<()> {
        self.execute("insert into entries (start, end, note, sheet) values (?1, ?2, ?3, ?4)", &[
            &start, &end, &note, &sheet,
        ])
    }

    // Meta queries
    fn current_sheet(&self) -> Result<Option<String>> {
        let results = self.meta_query("select * from meta where key='current_sheet'", &[])?;

        Ok(results.into_iter().next().map(|m| m.value))
    }

    fn version(&self) -> Result<DBVersion> {
        let results = self.meta_query("select * from meta where key='database_version'", &[])?;

        if let Some(v) = results.into_iter().next().map(|m| m.value) {
            Ok(DBVersion::Version(v.parse().map_err(|_| {
                Error::CorruptedData(format!(
                    "Found value '{}' for key 'database_version' in meta table, which is not a valid integer",
                    v
                ))
            })?))
        } else {
            Ok(DBVersion::Timetrap)
        }
    }
}

pub struct SqliteDatabase {
    connection:  Connection,
}

impl SqliteDatabase {
    pub fn from_memory() -> Result<impl Database> {
        Ok(SqliteDatabase {
            connection: Connection::open_in_memory()?,
        })
    }

    pub fn from_path<P: AsRef<Path>>(path: P) -> Result<impl Database> {
        Ok(SqliteDatabase {
            connection: Connection::open(path)?,
        })
    }
}

impl Database for SqliteDatabase {
    fn execute(&mut self, query: &str, params: &[&dyn ToSql]) -> Result<()> {
        self.connection.execute(query, params)?;

        Ok(())
    }

    fn entry_query(&self, query: &str, params: &[&dyn ToSql]) -> Result<Vec<Entry>> {
        let mut stmt = self.connection.prepare(query)?;

        let results = stmt.query_map(params, |row| {
            Ok(Entry {
                id: row.get("id")?,
                note: row.get("note")?,
                start: row.get("start")?,
                end: row.get("end")?,
                sheet: row.get("sheet")?,
            })
        })?.filter_map(|r| r.ok()).collect();

        Ok(results)
    }

    fn meta_query(&self, query: &str, params: &[&dyn ToSql]) -> Result<Vec<Meta>> {
        let mut stmt = self.connection.prepare(query)?;

        let results = stmt.query_map(params, |row| Ok(Meta {
            id: row.get("id")?,
            key: row.get("key")?,
            value: row.get("value")?,
        }))?.filter_map(|r| r.ok()).collect();

        Ok(results)
    }
}