mylloon.fr/src/routes/blog.rs

use ::rss::{Category, Channel, Image, Item};
use actix_web::{dev::ConnectionInfo, get, web, HttpRequest, HttpResponse, Responder};
use cached::proc_macro::once;
use chrono::{DateTime, Datelike, Local, NaiveDateTime, Utc};
use chrono_tz::Europe;
use comrak::{parse_document, Arena};
use ramhorns::Content;

use crate::{
    config::Config,
    misc::{
        date::Date,
        markdown::{get_metadata, get_options, read_file, File, FileMetadata},
    },
    template::Infos,
};

#[get("/blog")]
pub async fn index(config: web::Data<Config>) -> impl Responder {
    HttpResponse::Ok().body(build_index(config.get_ref().to_owned()))
}

#[derive(Content)]
struct BlogIndexTemplate {
    posts: Vec<Post>,
    no_posts: bool,
}

#[once(time = 120)]
pub fn build_index(config: Config) -> String {
    let mut posts = get_posts("data/blog");

    // Sort from newest to oldest
    posts.sort_by_cached_key(|p| (p.date.year, p.date.month, p.date.day));
    posts.reverse();

    config.tmpl.render(
        "blog/index.html",
        BlogIndexTemplate {
            no_posts: posts.is_empty(),
            posts,
        },
        Infos {
            page_title: Some("Blog".into()),
            page_desc: Some("Liste des posts d'Anri".into()),
            page_kw: Some(["blog", "blogging"].join(", ")),
        },
    )
}

#[derive(Content)]
struct Post {
    title: String,
    date: Date,
    url: String,
    desc: Option<String>,
}

fn get_posts(location: &str) -> Vec<Post> {
    let entries = match std::fs::read_dir(location) {
        Ok(res) => res
            .flatten()
            .filter(|f| f.path().extension().unwrap() == "md")
            .collect::<Vec<std::fs::DirEntry>>(),
        Err(_) => vec![],
    };

    entries
        .iter()
        .map(|f| {
            let _filename = f.file_name();
            let filename = _filename.to_string_lossy();
            let file_without_ext = filename.split_at(filename.len() - 3).0;

            let file_metadata = match std::fs::read_to_string(format!("{location}/{filename}")) {
                Ok(text) => {
                    let arena = Arena::new();

                    let options = get_options();
                    let root = parse_document(&arena, &text, &options);
                    let mut metadata = get_metadata(root);

                    metadata.title = match metadata.title {
                        Some(title) => Some(title),
                        None => Some(file_without_ext.into()),
                    };

                    metadata
                }
                Err(_) => FileMetadata {
                    title: Some(file_without_ext.into()),
                    ..FileMetadata::default()
                },
            };

            Post {
                url: file_without_ext.into(),
                title: file_metadata.title.unwrap(),
                date: file_metadata.date.unwrap_or({
                    let m = f.metadata().unwrap();
                    let date = std::convert::Into::<DateTime<Utc>>::into(
                        m.modified().unwrap_or(m.created().unwrap()),
                    )
                    .date_naive();

                    Date {
                        day: date.day(),
                        month: date.month(),
                        year: date.year(),
                    }
                }),
                desc: file_metadata.description,
            }
        })
        .collect::<Vec<Post>>()
}

#[derive(Content)]
struct BlogPostTemplate {
    post: Option<File>,
}

#[get("/blog/p/{id}")]
pub async fn page(path: web::Path<(String,)>, config: web::Data<Config>) -> impl Responder {
    HttpResponse::Ok().body(build_post(path.into_inner().0, config.get_ref().to_owned()))
}

fn build_post(file: String, config: Config) -> String {
    let mut post = None;
    let infos = get_post(&mut post, file);

    config
        .tmpl
        .render("blog/post.html", BlogPostTemplate { post }, infos)
}

fn get_post(post: &mut Option<File>, filename: String) -> Infos {
    let blog_dir = "data/blog";
    let ext = ".md";

    *post = read_file(&format!("{blog_dir}/{filename}{ext}"));

    let title = match post {
        Some(data) => match &data.metadata.info.title {
            Some(text) => text,
            None => &filename,
        },
        None => &filename,
    };

    Infos {
        page_title: Some(format!("Post: {}", title)),
        page_desc: Some("Blog d'Anri".into()),
        page_kw: Some(["blog", "blogging", "write", "writing"].join(", ")),
    }
}

#[get("/blog/rss")]
pub async fn rss(req: HttpRequest, config: web::Data<Config>) -> impl Responder {
    HttpResponse::Ok().body(build_rss(
        config.get_ref().to_owned(),
        req.connection_info().to_owned(),
    ))
}

//#[once(time = 10800)] // 3h
fn build_rss(config: Config, info: ConnectionInfo) -> String {
    let mut posts = get_posts("data/blog");

    // Sort from newest to oldest
    posts.sort_by_cached_key(|p| (p.date.year, p.date.month, p.date.day));
    posts.reverse();

    // Only the 20 newest
    let max = 20;
    if posts.len() > max {
        posts.drain(max..);
    }

    let link_to_site = format!("{}://{}", info.scheme(), info.host());
    let channel = Channel {
        title: "Blog d'Anri".into(),
        link: link_to_site.to_owned(),
        description: "Un fil qui parle d'informatique notamment".into(),
        language: Some("fr".into()),
        managing_editor: config.fc.mail.to_owned(),
        webmaster: config.fc.mail,
        pub_date: Some(Local::now().to_rfc2822()),
        categories: ["blog", "blogging", "write", "writing"]
            .iter()
            .map(|&c| Category {
                name: c.into(),
                ..Category::default()
            })
            .collect(),
        generator: Some("ewp with rss crate".into()),
        docs: Some("https://www.rssboard.org/rss-specification".into()),
        image: Some(Image {
            url: format!("{}/icons/favicon-32x32.png", link_to_site),
            title: "Favicon".into(),
            link: link_to_site.to_owned(),
            ..Image::default()
        }),
        items: posts
            .iter()
            .map(|p| Item {
                title: Some(p.title.to_owned()),
                link: Some(format!("{}/blog/p/{}", link_to_site, p.url)),
                description: p.desc.to_owned(),
                pub_date: Some(
                    NaiveDateTime::parse_from_str(
                        &format!("{}-{}-{} 13:12:00", p.date.day, p.date.month, p.date.year),
                        "%d-%m-%Y %H:%M:%S",
                    )
                    .unwrap()
                    .and_local_timezone(Europe::Paris)
                    .unwrap()
                    .to_rfc2822(),
                ),
                ..Item::default()
            })
            .collect(),
        ..Channel::default()
    };

    std::str::from_utf8(&channel.write_to(Vec::new()).unwrap())
        .unwrap()
        .into()
}