118 lines
3.1 KiB
Rust
118 lines
3.1 KiB
Rust
use serde::{Deserialize, Serialize};
|
|
use std::collections::HashMap;
|
|
use std::error::Error;
|
|
use std::sync;
|
|
use warp::Filter;
|
|
|
|
use crate::domain;
|
|
|
|
pub mod http_tpl;
|
|
|
|
/*
|
|
* POST /domain/config (domain, config, secret, init?) -> token?
|
|
* GET /domain/config (domain) -> config
|
|
* GET /domains
|
|
*/
|
|
|
|
type Handlebars<'a> = sync::Arc<handlebars::Handlebars<'a>>;
|
|
|
|
struct RenderContext<'a> {
|
|
handlebars: Handlebars<'a>,
|
|
query_args: HashMap<String, String>,
|
|
}
|
|
|
|
// TODO make this use an io::Write, rather than warp::Reply
|
|
fn render<'a, T>(handlebars: Handlebars<'a>, name: &'a str, value: T) -> impl warp::Reply
|
|
where
|
|
T: Serialize,
|
|
{
|
|
// TODO deal with 404
|
|
let render = handlebars
|
|
.render(name, &value)
|
|
.unwrap_or_else(|err| err.to_string());
|
|
|
|
let content_type = mime_guess::from_path(name)
|
|
.first_or_octet_stream()
|
|
.to_string();
|
|
|
|
let reply = warp::reply::html(render);
|
|
|
|
warp::reply::with_header(reply, "Content-Type", content_type)
|
|
}
|
|
|
|
fn render_page<'a, T>(render_ctx: RenderContext<'a>, name: String, data: T) -> impl warp::Reply
|
|
where
|
|
T: Serialize,
|
|
{
|
|
#[derive(Serialize)]
|
|
struct Presenter<T> {
|
|
page_name: String,
|
|
query_args: HashMap<String, String>,
|
|
data: T,
|
|
}
|
|
|
|
let presenter = Presenter {
|
|
page_name: name,
|
|
query_args: render_ctx.query_args,
|
|
data,
|
|
};
|
|
|
|
render(render_ctx.handlebars, "/base.html", presenter)
|
|
}
|
|
|
|
pub fn new(
|
|
_manager: impl domain::manager::Manager,
|
|
) -> Result<
|
|
impl warp::Filter<Extract = impl warp::Reply, Error = warp::Rejection> + Clone,
|
|
Box<dyn Error>,
|
|
> {
|
|
let hbs = sync::Arc::new(self::http_tpl::get()?);
|
|
let with_render_ctx = warp::any()
|
|
.and(warp::query::<HashMap<String, String>>())
|
|
.map(move |query_args: HashMap<String, String>| RenderContext {
|
|
handlebars: hbs.clone(),
|
|
query_args,
|
|
});
|
|
|
|
let static_dir = warp::get()
|
|
.and(with_render_ctx.clone())
|
|
.and(warp::path("static"))
|
|
.and(warp::path::full())
|
|
.map(
|
|
|render_ctx: RenderContext<'_>, full: warp::path::FullPath| {
|
|
render(render_ctx.handlebars, full.as_str(), ())
|
|
},
|
|
);
|
|
|
|
let index = warp::get()
|
|
.and(with_render_ctx.clone())
|
|
.and(warp::path::end())
|
|
.map(|render_ctx: RenderContext<'_>| {
|
|
render_page(render_ctx, String::from("/index.html"), ())
|
|
});
|
|
|
|
#[derive(Deserialize)]
|
|
struct DomainGetNewRequest {
|
|
domain: String,
|
|
}
|
|
|
|
let domain_get = warp::get()
|
|
.and(with_render_ctx.clone())
|
|
.and(warp::path("domain.html"))
|
|
.and(warp::query::<DomainGetNewRequest>())
|
|
.map(|render_ctx: RenderContext<'_>, req: DomainGetNewRequest| {
|
|
#[derive(Serialize)]
|
|
struct DomainGetNewResponse {
|
|
domain: String,
|
|
}
|
|
|
|
render_page(
|
|
render_ctx,
|
|
String::from("/domain_get_new.html"),
|
|
DomainGetNewResponse { domain: req.domain },
|
|
)
|
|
});
|
|
|
|
Ok(static_dir.or(index).or(domain_get))
|
|
}
|