website/src/handlers/posts.rs

use std::sync::Arc;

use axum::{
    extract::{Path, State},
    http::{header, HeaderMap, StatusCode},
    response::{Html, IntoResponse, Redirect, Response},
    routing::get,
    Router,
};

use serde_derive::Serialize;
use tracing::{instrument, log::warn};

use crate::{
    post::{render_post, Post},
    AppState, WebsiteError,
};

use super::should_return_304;

pub fn router() -> Router<Arc<AppState>> {
    Router::new()
        .route("/posts", get(|| async { Redirect::permanent("/") }))
        .route("/atom.xml", get(feed))
        .route("/posts/", get(index))
        .route("/posts/:slug", get(redirect))
        .route("/posts/:slug/", get(view))
        .route("/posts/:slug/index.md", get(super::not_found))
}

pub fn alias_router<'a>(posts: impl IntoIterator<Item = &'a Post>) -> Router<Arc<AppState>> {
    let mut router = Router::new();

    for post in posts {
        for alias in &post.aliases {
            let path = post.absolute_path.clone();
            router = router.route(
                alias,
                get(move || async {
                    let p = path;
                    Redirect::permanent(&p)
                }),
            );
        }
    }
    router
}

#[derive(Serialize, Debug)]
struct PageContext<'a> {
    title: &'a str,
}

#[instrument(skip(state))]
pub async fn index(
    State(state): State<Arc<AppState>>,
    headers: HeaderMap,
) -> Result<Response, WebsiteError> {
    let mut posts: Vec<&Post> = state
        .posts
        .values()
        .filter(|p| !p.draft && p.is_published())
        .collect();

    let last_changed = posts.iter().filter_map(|p| p.last_modified()).max();

    if should_return_304(&headers, last_changed) {
        return Ok(StatusCode::NOT_MODIFIED.into_response());
    }

    posts.sort_by_key(|p| &p.date);
    posts.reverse();

    let ctx = PageContext { title: "Posts" };

    let mut c = tera::Context::new();
    c.insert("page", &ctx);
    c.insert("posts", &posts);
    c.insert("base_url", &state.base_url.to_string());

    let res = state.tera.render("posts_index.html", &c)?;

    Ok((
        StatusCode::OK,
        [(
            header::LAST_MODIFIED,
            last_changed.map_or_else(|| state.startup_time.to_rfc2822(), |d| d.to_rfc2822()),
        )],
        Html(res),
    )
        .into_response())
}

#[instrument(skip(state))]
pub async fn view(
    Path(slug): Path<String>,
    State(state): State<Arc<AppState>>,
    headers: HeaderMap,
) -> Result<axum::response::Response, WebsiteError> {
    let post = state.posts.get(&slug).ok_or(WebsiteError::NotFound)?;

    let last_changed = post.last_modified();

    if should_return_304(&headers, last_changed) {
        return Ok(StatusCode::NOT_MODIFIED.into_response());
    }

    if !post.is_published() {
        warn!("attempted to view post before it has been published!");
        return Err(WebsiteError::NotFound);
    }

    let res = render_post(&state, post).await?;

    Ok((
        StatusCode::OK,
        [(
            header::LAST_MODIFIED,
            last_changed.map_or_else(|| state.startup_time.to_rfc2822(), |d| d.to_rfc2822()),
        )],
        Html(res),
    )
        .into_response())
}

#[instrument(skip(state))]
pub async fn feed(
    State(state): State<Arc<AppState>>,
    headers: HeaderMap,
) -> Result<Response, WebsiteError> {
    let mut posts: Vec<&Post> = state
        .posts
        .values()
        .filter(|p| !p.draft && p.is_published())
        .collect();

    let last_changed = posts.iter().filter_map(|p| p.last_modified()).max();

    if should_return_304(&headers, last_changed) {
        return Ok(StatusCode::NOT_MODIFIED.into_response());
    }

    posts.sort_by_key(|p| &p.date);
    posts.reverse();
    posts.truncate(10);

    Ok((
        StatusCode::OK,
        [
            (header::CONTENT_TYPE, "application/atom+xml"),
            (
                header::LAST_MODIFIED,
                &last_changed.map_or_else(|| state.startup_time.to_rfc2822(), |d| d.to_rfc2822()),
            ),
        ],
        crate::feed::render_atom_feed(&state)?,
    )
        .into_response())
}

#[instrument(skip(state))]
pub async fn redirect(
    Path(slug): Path<String>,
    State(state): State<Arc<AppState>>,
) -> Result<Redirect, WebsiteError> {
    if state.posts.contains_key(&slug) {
        Ok(Redirect::permanent(&format!("/posts/{slug}/")))
    } else {
        Err(WebsiteError::NotFound)
    }
}

#[cfg(test)]
mod tests {
    use chrono::DateTime;

    use crate::post::Post;

    use super::PageContext;

    #[test]
    fn render_index() {
        let posts = vec![
            Post {
                title: "test".into(),
                slug: "test".into(),
                tags: vec!["abc".into(), "def".into()],
                date: Some(DateTime::parse_from_rfc3339("2023-03-26T13:04:01+02:00").unwrap()),
                ..Default::default()
            },
            Post {
                title: "test2".into(),
                slug: "test2".into(),
                date: None,
                ..Default::default()
            },
        ];
        let page = PageContext { title: "Posts" };
        let mut ctx = tera::Context::new();
        ctx.insert("base_url", "http://localhost/");
        ctx.insert("page", &page);
        ctx.insert("posts", &posts);

        let tera = tera::Tera::new("templates/**/*").unwrap();
        let _res = tera.render("posts_index.html", &ctx).unwrap();
    }
}