little-hesinde/calibre-db/src/data/book.rs

use rusqlite::{named_params, Connection, Row};
use serde::Serialize;

use super::{
    error::DataStoreError,
    pagination::{Pagination, SortOrder},
};

#[derive(Debug, Serialize)]
pub struct Book {
    pub id: u64,
    pub title: String,
    pub sort: String,
    pub path: String,
}

impl Book {
    fn from_row(row: &Row<'_>) -> Result<Self, rusqlite::Error> {
        Ok(Self {
            id: row.get(0)?,
            title: row.get(1)?,
            sort: row.get(2)?,
            path: row.get(3)?,
        })
    }

    pub fn multiple(
        conn: &Connection,
        limit: u64,
        cursor: Option<&str>,
        sort_order: &SortOrder,
    ) -> Result<Vec<Self>, DataStoreError> {
        let pagination = Pagination::new("sort", cursor, limit, *sort_order);
        pagination.paginate(
            conn,
            "SELECT id, title, sort, path FROM books",
            &[],
            Self::from_row,
        )
    }

    pub fn author_books(
        conn: &Connection,
        author_id: u64,
        limit: u64,
        cursor: Option<&str>,
        sort_order: SortOrder,
    ) -> Result<Vec<Self>, DataStoreError> {
        let pagination = Pagination::new("books.sort", cursor, limit, sort_order);
        pagination.paginate(
            conn,
            "SELECT books.id, books.title, books.sort, books.path FROM books \
                INNER JOIN books_authors_link ON books.id = books_authors_link.book \
                WHERE books_authors_link.author = (:author_id) AND",
            &[(":author_id", &author_id)],
            Self::from_row,
        )
    }

    pub fn recents(conn: &Connection, limit: u64) -> Result<Vec<Self>, DataStoreError> {
        let mut stmt = conn.prepare(
            "SELECT id, title, sort, path FROM books ORDER BY timestamp DESC LIMIT (:limit)",
        )?;
        let params = named_params! { ":limit": limit };
        let iter = stmt.query_map(params, Self::from_row)?;
        Ok(iter.filter_map(Result::ok).collect())
    }

    pub fn scalar_book(conn: &Connection, id: u64) -> Result<Self, DataStoreError> {
        let mut stmt = conn.prepare("SELECT id, title, sort, path FROM books WHERE id = (:id)")?;
        let params = named_params! { ":id": id };
        Ok(stmt.query_row(params, Self::from_row)?)
    }

    pub fn has_previous_books(conn: &Connection, sort_title: &str) -> Result<bool, DataStoreError> {
        let mut stmt = conn
            .prepare("SELECT Count(1) FROM books WHERE sort < (:sort_title) ORDER BY sort DESC")?;
        let params = named_params! { ":sort_title": sort_title};
        let count: u64 = stmt.query_row(params, |x| x.get(0))?;

        Ok(count > 0)
    }

    pub fn has_more_books(conn: &Connection, sort_title: &str) -> Result<bool, DataStoreError> {
        let mut stmt = conn
            .prepare("SELECT Count(1) FROM books WHERE sort > (:sort_title) ORDER BY sort ASC")?;
        let params = named_params! { ":sort_title": sort_title};
        let count: u64 = stmt.query_row(params, |x| x.get(0))?;

        Ok(count > 0)
    }
}