310 lines
10 KiB
Rust
310 lines
10 KiB
Rust
|
// The connection strings are:
|
||
|
|
// PostgreSQL - "postgres://root:root@localhost:5432"
|
||
|
|
// SQLite - "sqlite::memory:"
|
||
|
|
// const DATABASE_URL: &str = "sqlite::memory:";
|
||
|
|
// const DB_NAME: &str = "cm_tavern_db";
|
||
|
|
use std::path::Path;
|
||
|
|
|
||
|
|
use rusqlite::{params, Connection, Result};
|
||
|
|
#[cfg(not(feature = "publisher"))]
|
||
|
|
use rusqlite::Statement;
|
||
|
|
|
||
|
|
use crate::adventurer::Adventurer;
|
||
|
|
#[cfg(feature = "publisher")]
|
||
|
|
use crate::converter::Converter;
|
||
|
|
#[cfg(not(feature = "publisher"))]
|
||
|
|
use crate::tale::FrontMatter;
|
||
|
|
use crate::tale::Tale;
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
pub struct Database
|
||
|
|
{
|
||
|
|
connection: Connection
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
impl Database
|
||
|
|
{
|
||
|
|
/// Opens a connection to the SQLite database and creates the necessary
|
||
|
|
/// tables.
|
||
|
|
pub fn open(db_path: &Path) -> Result<Self>
|
||
|
|
{
|
||
|
|
let connection = Connection::open(db_path)?;
|
||
|
|
|
||
|
|
#[cfg(feature = "publisher")]
|
||
|
|
Self::create_tables(&connection)?;
|
||
|
|
|
||
|
|
Ok(Database { connection })
|
||
|
|
}
|
||
|
|
|
||
|
|
/// Creates the 'tales' and 'adventurers' tables if they don't exist.
|
||
|
|
#[cfg(feature = "publisher")]
|
||
|
|
fn create_tables(conn: &Connection) -> Result<()>
|
||
|
|
{
|
||
|
|
conn.execute(
|
||
|
|
"CREATE TABLE IF NOT EXISTS adventurers (
|
||
|
|
handle TEXT PRIMARY KEY,
|
||
|
|
name TEXT NOT NULL,
|
||
|
|
profile TEXT,
|
||
|
|
image TEXT,
|
||
|
|
blurb TEXT
|
||
|
|
)",
|
||
|
|
[]
|
||
|
|
)?;
|
||
|
|
conn.execute(
|
||
|
|
"CREATE TABLE IF NOT EXISTS tales (
|
||
|
|
slug TEXT PRIMARY KEY,
|
||
|
|
title TEXT NOT NULL,
|
||
|
|
author TEXT NOT NULL,
|
||
|
|
summary TEXT,
|
||
|
|
publish_date TEXT NOT NULL,
|
||
|
|
content TEXT
|
||
|
|
)",
|
||
|
|
[]
|
||
|
|
)?;
|
||
|
|
conn.execute(
|
||
|
|
"CREATE TABLE IF NOT EXISTS tags (
|
||
|
|
id INTEGER PRIMARY KEY,
|
||
|
|
name TEXT NOT NULL UNIQUE
|
||
|
|
)",
|
||
|
|
[]
|
||
|
|
)?;
|
||
|
|
conn.execute(
|
||
|
|
"CREATE TABLE IF NOT EXISTS tale_tags (
|
||
|
|
tale_slug TEXT,
|
||
|
|
tag_id INTEGER,
|
||
|
|
FOREIGN KEY(tale_slug) REFERENCES tales(slug),
|
||
|
|
FOREIGN KEY(tag_id) REFERENCES tags(id),
|
||
|
|
UNIQUE(tale_slug, tag_id)
|
||
|
|
)",
|
||
|
|
[]
|
||
|
|
)?;
|
||
|
|
conn.execute(
|
||
|
|
"CREATE TABLE IF NOT EXISTS tavern (
|
||
|
|
key TEXT PRIMARY KEY,
|
||
|
|
value TEXT NOT NULL
|
||
|
|
)",
|
||
|
|
[],
|
||
|
|
)?;
|
||
|
|
Ok(())
|
||
|
|
}
|
||
|
|
|
||
|
|
/// Inserts a single tale into the database.
|
||
|
|
#[cfg(feature = "publisher")]
|
||
|
|
pub fn insert_tale(&self, tale: &Tale) -> Result<()>
|
||
|
|
{
|
||
|
|
// Read the markdown content from the file
|
||
|
|
let markdown_content = std::fs::read_to_string(&tale.content)
|
||
|
|
.map_err(|e| rusqlite::Error::ToSqlConversionFailure(e.into()))?;
|
||
|
|
|
||
|
|
// Convert the markdown to HTML
|
||
|
|
let html_content = Converter::markdown_to_html(&markdown_content);
|
||
|
|
|
||
|
|
self.connection.execute(
|
||
|
|
"INSERT OR REPLACE INTO tales (
|
||
|
|
slug, title, author, summary, publish_date, content
|
||
|
|
) VALUES (?1, ?2, ?3, ?4, ?5, ?6)",
|
||
|
|
params![
|
||
|
|
tale.front_matter.slug,
|
||
|
|
tale.front_matter.title,
|
||
|
|
tale.front_matter.author,
|
||
|
|
tale.front_matter.summary,
|
||
|
|
tale.front_matter.publish_date.to_string(),
|
||
|
|
html_content
|
||
|
|
]
|
||
|
|
)?;
|
||
|
|
|
||
|
|
// Insert tags and link them to the tale
|
||
|
|
for tag_name in &tale.front_matter.tags
|
||
|
|
{
|
||
|
|
let tag_id = self.insert_and_get_tag_id(tag_name)?;
|
||
|
|
self.connection.execute("INSERT OR IGNORE INTO tale_tags \
|
||
|
|
(tale_slug, tag_id) VALUES (?1, ?2)",
|
||
|
|
params![tale.front_matter.slug, tag_id])?;
|
||
|
|
}
|
||
|
|
|
||
|
|
Ok(())
|
||
|
|
}
|
||
|
|
|
||
|
|
/// Inserts a tag and returns its ID. If the tag already exists, it returns
|
||
|
|
/// the existing ID.
|
||
|
|
#[cfg(feature = "publisher")]
|
||
|
|
fn insert_and_get_tag_id(&self, tag_name: &str) -> Result<i64>
|
||
|
|
{
|
||
|
|
self.connection
|
||
|
|
.execute("INSERT OR IGNORE INTO tags (name) VALUES (?1)",
|
||
|
|
params![tag_name])?;
|
||
|
|
let id: i64 = self.connection
|
||
|
|
.query_row("SELECT id FROM tags WHERE name = ?1",
|
||
|
|
params![tag_name],
|
||
|
|
|row| row.get(0))?;
|
||
|
|
Ok(id)
|
||
|
|
}
|
||
|
|
|
||
|
|
/// Inserts a single adventurer into the database.
|
||
|
|
#[cfg(feature = "publisher")]
|
||
|
|
pub fn insert_adventurer(&self, adventurer: &Adventurer) -> Result<()>
|
||
|
|
{
|
||
|
|
self.connection.execute(
|
||
|
|
"INSERT OR REPLACE INTO adventurers (
|
||
|
|
handle, name, profile, image, blurb
|
||
|
|
) VALUES (?1, ?2, ?3, ?4, ?5)",
|
||
|
|
params![
|
||
|
|
adventurer.handle,
|
||
|
|
adventurer.name,
|
||
|
|
adventurer.profile,
|
||
|
|
adventurer.image,
|
||
|
|
adventurer.blurb
|
||
|
|
]
|
||
|
|
)?;
|
||
|
|
Ok(())
|
||
|
|
}
|
||
|
|
|
||
|
|
/// Inserts the site-wide settings like title and description.
|
||
|
|
#[cfg(feature = "publisher")]
|
||
|
|
pub fn insert_tavern(&self, title: &str, description: &str) -> Result<()> {
|
||
|
|
self.connection.execute_batch(&format!(
|
||
|
|
"BEGIN;
|
||
|
|
INSERT OR REPLACE INTO tavern (key, value) VALUES ('title', '{}');
|
||
|
|
INSERT OR REPLACE INTO tavern (key, value) VALUES ('description', '{}');
|
||
|
|
COMMIT;",
|
||
|
|
title, description
|
||
|
|
))?;
|
||
|
|
Ok(())
|
||
|
|
}
|
||
|
|
|
||
|
|
/// Fetches a vector of lightweight FrontMatter objects from the database.
|
||
|
|
#[cfg(not(feature = "publisher"))]
|
||
|
|
pub fn get_tales_summary(&self, categories: &[String]) -> Result<Vec<FrontMatter>> {
|
||
|
|
let mut query = String::from(
|
||
|
|
"SELECT
|
||
|
|
t.title,
|
||
|
|
t.slug,
|
||
|
|
t.summary,
|
||
|
|
t.author,
|
||
|
|
t.publish_date,
|
||
|
|
GROUP_CONCAT(tg.name, ',') AS tags
|
||
|
|
FROM tales AS t
|
||
|
|
JOIN tale_tags AS tt ON t.slug = tt.tale_slug
|
||
|
|
JOIN tags AS tg ON tt.tag_id = tg.id"
|
||
|
|
);
|
||
|
|
|
||
|
|
// If categories are provided, filter the results
|
||
|
|
if !categories.is_empty() {
|
||
|
|
query.push_str(" WHERE tg.name IN (");
|
||
|
|
// Add a placeholder for each category
|
||
|
|
let placeholders: Vec<_> = (0..categories.len()).map(|_| "?").collect();
|
||
|
|
query.push_str(&placeholders.join(", "));
|
||
|
|
query.push_str(")");
|
||
|
|
}
|
||
|
|
|
||
|
|
// Group by tale to get all tags for each tale
|
||
|
|
query.push_str(" GROUP BY t.slug");
|
||
|
|
|
||
|
|
query.push_str(" ORDER BY t.publish_date DESC");
|
||
|
|
|
||
|
|
let mut stmt: Statement = self.connection.prepare(&query)?;
|
||
|
|
|
||
|
|
let tales_iter = stmt.query_map(rusqlite::params_from_iter(categories), |row| {
|
||
|
|
let date_str: String = row.get(4)?;
|
||
|
|
let tags_str: String = row.get(5)?;
|
||
|
|
let tags: Vec<String> = tags_str.split(',').map(|s| s.to_string()).collect();
|
||
|
|
Ok(FrontMatter {
|
||
|
|
title: row.get(0)?,
|
||
|
|
slug: row.get(1)?,
|
||
|
|
summary: row.get(2)?,
|
||
|
|
author: row.get(3)?,
|
||
|
|
publish_date: chrono::NaiveDateTime::parse_from_str(&date_str, "%Y-%m-%dT%H:%M:%S").map_err(|e| rusqlite::Error::ToSqlConversionFailure(e.into()))?,
|
||
|
|
tags,
|
||
|
|
})
|
||
|
|
})?;
|
||
|
|
|
||
|
|
let summaries: Result<Vec<_>, _> = tales_iter.collect();
|
||
|
|
summaries
|
||
|
|
}
|
||
|
|
|
||
|
|
/// Fetches a single tale from the database by its slug.
|
||
|
|
/// This function is only available in the 'reader' build.
|
||
|
|
#[cfg(not(feature = "publisher"))]
|
||
|
|
pub fn get_tale_by_slug(&self, slug: &str) -> Result<Option<Tale>> {
|
||
|
|
let query = String::from(
|
||
|
|
"SELECT
|
||
|
|
t.title,
|
||
|
|
t.slug,
|
||
|
|
t.summary,
|
||
|
|
t.author,
|
||
|
|
t.publish_date,
|
||
|
|
t.content,
|
||
|
|
GROUP_CONCAT(tg.name, ',') AS tags
|
||
|
|
FROM tales AS t
|
||
|
|
LEFT JOIN tale_tags AS tt ON t.slug = tt.tale_slug
|
||
|
|
LEFT JOIN tags AS tg ON tt.tag_id = tg.id
|
||
|
|
WHERE t.slug = ?1
|
||
|
|
GROUP BY t.slug"
|
||
|
|
);
|
||
|
|
|
||
|
|
// Prepare the statement and execute a query for a single row.
|
||
|
|
let result = self.connection.query_row(
|
||
|
|
&query,
|
||
|
|
params![slug],
|
||
|
|
|row| {
|
||
|
|
// Parse the tags string into a vector of strings.
|
||
|
|
let tags_str: Option<String> = row.get(6)?;
|
||
|
|
let tags = tags_str.map(|s| s.split(',').map(|tag| tag.to_string()).collect()).unwrap_or_default();
|
||
|
|
|
||
|
|
// Parse the date string into a NaiveDateTime.
|
||
|
|
let date_str: String = row.get(4)?;
|
||
|
|
let publish_date = chrono::NaiveDateTime::parse_from_str(&date_str, "%Y-%m-%dT%H:%M:%S")
|
||
|
|
.map_err(|e| rusqlite::Error::ToSqlConversionFailure(e.into()))?;
|
||
|
|
|
||
|
|
// Construct the FrontMatter and the full Tale struct.
|
||
|
|
Ok(Tale {
|
||
|
|
front_matter: FrontMatter {
|
||
|
|
title: row.get(0)?,
|
||
|
|
slug: row.get(1)?,
|
||
|
|
summary: row.get(2)?,
|
||
|
|
author: row.get(3)?,
|
||
|
|
publish_date,
|
||
|
|
tags,
|
||
|
|
},
|
||
|
|
content: row.get(5)?,
|
||
|
|
})
|
||
|
|
}
|
||
|
|
);
|
||
|
|
|
||
|
|
// Handle the result: if no rows were returned, return `None`.
|
||
|
|
match result {
|
||
|
|
Ok(tale) => Ok(Some(tale)),
|
||
|
|
Err(rusqlite::Error::QueryReturnedNoRows) => Ok(None),
|
||
|
|
Err(e) => Err(e),
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/// Fetches a single adventurer from the database by their handle.
|
||
|
|
/// This function is only available in the 'reader' build.
|
||
|
|
#[cfg(not(feature = "publisher"))]
|
||
|
|
pub fn get_adventurer(&self, handle: &str) -> Result<Option<Adventurer>> {
|
||
|
|
let result = self.connection.query_row(
|
||
|
|
"SELECT handle, name, profile, image, blurb FROM adventurers WHERE handle = ?1",
|
||
|
|
params![handle],
|
||
|
|
|row| {
|
||
|
|
Ok(Adventurer {
|
||
|
|
handle: row.get(0)?,
|
||
|
|
name: row.get(1)?,
|
||
|
|
profile: row.get(2)?,
|
||
|
|
image: row.get(3)?,
|
||
|
|
blurb: row.get(4)?,
|
||
|
|
})
|
||
|
|
}
|
||
|
|
);
|
||
|
|
|
||
|
|
match result {
|
||
|
|
Ok(adventurer) => Ok(Some(adventurer)),
|
||
|
|
Err(rusqlite::Error::QueryReturnedNoRows) => Ok(None),
|
||
|
|
Err(e) => Err(e),
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|