58 lines
1.7 KiB
Rust
58 lines
1.7 KiB
Rust
use std::sync::Arc;
|
|
|
|
use diesel::r2d2::{ConnectionManager, Pool};
|
|
use diesel::SqliteConnection;
|
|
use minijinja_autoreload::AutoReloader;
|
|
use thiserror::Error;
|
|
|
|
use crate::handler::internal_server_error;
|
|
use crate::prelude::*;
|
|
|
|
pub type ConnectionPool = Pool<ConnectionManager<SqliteConnection>>;
|
|
pub type PooledConnection = diesel::r2d2::PooledConnection<ConnectionManager<SqliteConnection>>;
|
|
|
|
#[derive(Clone)]
|
|
pub struct Provider {
|
|
pub db_pool: ConnectionPool,
|
|
template_loader: Arc<AutoReloader>,
|
|
}
|
|
|
|
#[derive(Error, Debug)]
|
|
pub enum ProviderError {
|
|
#[error("Error while using the connection pool: {0}")]
|
|
R2D2Error(#[from] diesel::r2d2::PoolError),
|
|
}
|
|
|
|
impl Provider {
|
|
pub fn new(db: ConnectionPool, template_loader: AutoReloader) -> Provider {
|
|
Provider {
|
|
db_pool: db,
|
|
template_loader: Arc::new(template_loader),
|
|
}
|
|
}
|
|
|
|
pub fn db_conn(&self) -> Result<PooledConnection, ProviderError> {
|
|
let conn = self.db_pool.get()?;
|
|
Ok(conn)
|
|
}
|
|
|
|
pub fn render<T: Serialize>(&self, path: &str, data: T) -> anyhow::Result<String> {
|
|
// TODO: more graceful handling of the potential errors here; this should not
|
|
// use anyhow
|
|
let env = self.template_loader.acquire_env().unwrap();
|
|
let template = env.get_template(path)?;
|
|
let rendered = template.render(data)?;
|
|
Ok(rendered)
|
|
}
|
|
|
|
pub fn render_resp<T: Serialize>(&self, path: &str, data: T) -> Response {
|
|
let rendered = self.render(path, data);
|
|
match rendered {
|
|
Ok(rendered) => Html(rendered).into_response(),
|
|
Err(err) => {
|
|
error!(?err, "error while rendering template");
|
|
internal_server_error()
|
|
}
|
|
}
|
|
}
|
|
}
|