175 lines
4.3 KiB
Rust
175 lines
4.3 KiB
Rust
#[macro_use]
|
|
extern crate rocket;
|
|
|
|
use rocket::fs::FileServer;
|
|
use rocket::response::Redirect;
|
|
use rocket::State;
|
|
use rocket_dyn_templates::tera;
|
|
use rocket_dyn_templates::Template;
|
|
|
|
use rand::distributions::Uniform;
|
|
use rand::Rng;
|
|
|
|
use std::ops::Deref;
|
|
use std::sync::Arc;
|
|
|
|
use chgk_ledb_lib::async_db;
|
|
use chgk_ledb_lib::questions::Question;
|
|
|
|
use mini_moka::sync::Cache;
|
|
use std::time::Duration;
|
|
|
|
const DB_FILENAME: &str = "db.dat";
|
|
|
|
trait ErrorEmpty {
|
|
type Output;
|
|
fn err_empty(self) -> Result<Self::Output, ()>;
|
|
}
|
|
|
|
impl<T, E> ErrorEmpty for Result<T, E> {
|
|
type Output = T;
|
|
fn err_empty(self) -> Result<Self::Output, ()> {
|
|
self.map_err(|_| ())
|
|
}
|
|
}
|
|
|
|
#[derive(Clone)]
|
|
struct ArcTemplateData {
|
|
value: Arc<tera::Value>,
|
|
}
|
|
|
|
impl ArcTemplateData {
|
|
fn new(value: tera::Value) -> ArcTemplateData {
|
|
ArcTemplateData {
|
|
value: Arc::new(value),
|
|
}
|
|
}
|
|
fn render(&self, name: &'static str) -> Template {
|
|
Template::render(name, self.value.deref())
|
|
}
|
|
}
|
|
|
|
type TemplateCache = mini_moka::sync::Cache<usize, ArcTemplateData>;
|
|
|
|
type DataBaseInner = async_db::Reader<Question>;
|
|
type DataBase = Arc<DataBaseInner>;
|
|
struct AppState {
|
|
db: DataBase,
|
|
database_distribution: Uniform<usize>,
|
|
}
|
|
|
|
impl From<DataBaseInner> for AppState {
|
|
fn from(db: DataBaseInner) -> Self {
|
|
let last_id = db.len();
|
|
let database_distribution = rand::distributions::Uniform::new_inclusive(1usize, last_id);
|
|
let db = Arc::new(db);
|
|
|
|
Self {
|
|
db,
|
|
database_distribution,
|
|
}
|
|
}
|
|
}
|
|
|
|
fn random_question_id(database_distribution: &Uniform<usize>) -> usize {
|
|
let mut rng = rand::thread_rng();
|
|
rng.sample(database_distribution)
|
|
}
|
|
|
|
async fn get_question(db: &DataBase, id: usize) -> Result<Question, ()> {
|
|
db.get(id - 1).await.err_empty()
|
|
}
|
|
|
|
async fn show_question_details(
|
|
template_name: &'static str,
|
|
data: &AppState,
|
|
cache: &TemplateCache,
|
|
id: usize,
|
|
) -> Template {
|
|
if let Some(value) = cache.get(&id) {
|
|
return value.render(template_name);
|
|
}
|
|
|
|
match get_question(&data.db, id).await {
|
|
Ok(question) => {
|
|
let mut context = tera::to_value(question).expect("question serialize");
|
|
if context.is_object() {
|
|
let next_id = random_question_id(&data.database_distribution);
|
|
context["next"] = tera::to_value(next_id).expect("question id serialize");
|
|
}
|
|
|
|
let value = ArcTemplateData::new(context);
|
|
let result = value.render(template_name);
|
|
cache.insert(id, value);
|
|
|
|
result
|
|
}
|
|
Err(_) => {
|
|
use std::collections::HashMap;
|
|
let context: HashMap<String, String> = HashMap::new();
|
|
Template::render("404", context)
|
|
}
|
|
}
|
|
}
|
|
|
|
#[get("/q/<id>")]
|
|
async fn show_question(
|
|
data: &State<AppState>,
|
|
cache: &State<TemplateCache>,
|
|
id: usize,
|
|
) -> Template {
|
|
show_question_details("question", data.inner(), cache.inner(), id).await
|
|
}
|
|
|
|
#[get("/q/<id>/a")]
|
|
async fn show_answer(data: &State<AppState>, cache: &State<TemplateCache>, id: usize) -> Template {
|
|
show_question_details("answer", data.inner(), cache.inner(), id).await
|
|
}
|
|
|
|
#[get("/q/0")]
|
|
fn question0() -> Redirect {
|
|
Redirect::to("/")
|
|
}
|
|
|
|
#[get("/q/0/a")]
|
|
fn answer0() -> Redirect {
|
|
Redirect::to("/")
|
|
}
|
|
|
|
#[get("/")]
|
|
fn index(data: &State<AppState>) -> Redirect {
|
|
let id = random_question_id(&data.database_distribution);
|
|
Redirect::temporary(format!("/q/{}", id))
|
|
}
|
|
|
|
#[catch(404)]
|
|
fn not_found(_req: &rocket::Request) -> Template {
|
|
use std::collections::HashMap;
|
|
let context: HashMap<String, String> = HashMap::new();
|
|
Template::render("404", context)
|
|
}
|
|
|
|
#[launch]
|
|
async fn rocket() -> _ {
|
|
let state: AppState = async_db::Reader::new(DB_FILENAME)
|
|
.await
|
|
.expect("open db")
|
|
.into();
|
|
let cache: TemplateCache = Cache::builder()
|
|
.time_to_idle(Duration::from_secs(15 * 60))
|
|
.max_capacity(300)
|
|
.build();
|
|
|
|
rocket::build()
|
|
.manage(state)
|
|
.manage(cache)
|
|
.register("/", catchers![not_found])
|
|
.mount(
|
|
"/",
|
|
routes![index, show_question, show_answer, question0, answer0],
|
|
)
|
|
.mount("/q", routes![index])
|
|
.mount("/q/static", FileServer::from("static/"))
|
|
.attach(Template::fairing())
|
|
}
|