395 lines
12 KiB
Rust
395 lines
12 KiB
Rust
use std::{
|
|
collections::hash_map::DefaultHasher,
|
|
hash::{Hash, Hasher},
|
|
};
|
|
|
|
use ::rss::{
|
|
extension::atom::{AtomExtension, Link},
|
|
Category, Channel, Guid, Image, Item,
|
|
};
|
|
use actix_web::{get, http::header::ContentType, routes, web, 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,
|
|
utils::{
|
|
date::Date,
|
|
markdown::{get_metadata, get_options, File, FileMetadataBlog, TypeFileMetadata},
|
|
misc::{get_url, make_kw, read_file, Html},
|
|
},
|
|
template::{InfosPage, NavBar},
|
|
};
|
|
|
|
const MIME_TYPE_RSS: &str = "application/rss+xml";
|
|
const BLOG_DIR: &str = "blog";
|
|
const POST_DIR: &str = "posts";
|
|
|
|
#[get("/blog")]
|
|
pub async fn index(config: web::Data<Config>) -> impl Responder {
|
|
Html(build_index(config.get_ref().to_owned()))
|
|
}
|
|
|
|
#[derive(Content, Debug)]
|
|
struct BlogIndexTemplate {
|
|
navbar: NavBar,
|
|
about: Option<File>,
|
|
posts: Vec<Post>,
|
|
no_posts: bool,
|
|
}
|
|
|
|
#[once(time = 60)]
|
|
fn build_index(config: Config) -> String {
|
|
let blog_dir = format!("{}/{}", config.locations.data_dir, BLOG_DIR);
|
|
let mut posts = get_posts(&format!("{blog_dir}/{POST_DIR}"));
|
|
|
|
// Get about
|
|
let about: Option<File> =
|
|
read_file(&format!("{blog_dir}/about.md"), &TypeFileMetadata::Generic);
|
|
|
|
// 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 {
|
|
navbar: NavBar {
|
|
blog: true,
|
|
..NavBar::default()
|
|
},
|
|
about,
|
|
no_posts: posts.is_empty(),
|
|
posts,
|
|
},
|
|
InfosPage {
|
|
title: Some("Blog".into()),
|
|
desc: Some(format!(
|
|
"Liste des posts d'{}",
|
|
config.fc.name.unwrap_or_default()
|
|
)),
|
|
kw: Some(make_kw(&["blog", "blogging"])),
|
|
},
|
|
)
|
|
}
|
|
|
|
#[derive(Content, Debug)]
|
|
struct Post {
|
|
title: String,
|
|
date: Date,
|
|
url: String,
|
|
desc: Option<String>,
|
|
content: Option<String>,
|
|
tags: Vec<String>,
|
|
}
|
|
|
|
impl Post {
|
|
// Fetch the file content
|
|
fn fetch_content(&mut self, data_dir: &str) {
|
|
let blog_dir = format!("{data_dir}/{BLOG_DIR}/{POST_DIR}");
|
|
let ext = ".md";
|
|
|
|
if let Some(file) = read_file(
|
|
&format!("{blog_dir}/{}{ext}", self.url),
|
|
&TypeFileMetadata::Blog,
|
|
) {
|
|
self.content = Some(file.content);
|
|
}
|
|
}
|
|
}
|
|
|
|
impl Hash for Post {
|
|
fn hash<H: Hasher>(&self, state: &mut H) {
|
|
if let Some(content) = &self.content {
|
|
content.hash(state);
|
|
}
|
|
}
|
|
}
|
|
|
|
fn get_posts(location: &str) -> Vec<Post> {
|
|
let entries = std::fs::read_dir(location).map_or_else(
|
|
|_| vec![],
|
|
|res| {
|
|
res.flatten()
|
|
.filter(|f| f.path().extension().map_or(false, |ext| ext == "md"))
|
|
.collect::<Vec<std::fs::DirEntry>>()
|
|
},
|
|
);
|
|
|
|
entries
|
|
.iter()
|
|
.filter_map(|f| {
|
|
let fname = f.file_name();
|
|
let filename = fname.to_string_lossy();
|
|
let file_without_ext = filename.split_at(filename.len() - 3).0;
|
|
|
|
let file_metadata = std::fs::read_to_string(format!("{location}/{filename}"))
|
|
.map_or_else(
|
|
|_| FileMetadataBlog {
|
|
title: Some(file_without_ext.into()),
|
|
..FileMetadataBlog::default()
|
|
},
|
|
|text| {
|
|
let arena = Arena::new();
|
|
|
|
let options = get_options();
|
|
let root = parse_document(&arena, &text, &options);
|
|
let mut metadata =
|
|
get_metadata(root, &TypeFileMetadata::Blog).blog.unwrap();
|
|
|
|
// Always have a title
|
|
metadata.title = metadata
|
|
.title
|
|
.map_or_else(|| Some(file_without_ext.into()), Some);
|
|
|
|
metadata
|
|
},
|
|
);
|
|
|
|
if file_metadata.publish == Some(true) {
|
|
Some(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_else(|_| m.created().unwrap()),
|
|
)
|
|
.date_naive();
|
|
|
|
Date {
|
|
day: date.day(),
|
|
month: date.month(),
|
|
year: date.year(),
|
|
}
|
|
}),
|
|
desc: file_metadata.description,
|
|
content: None,
|
|
tags: file_metadata
|
|
.tags
|
|
.unwrap_or_default()
|
|
.iter()
|
|
.map(|t| t.name.clone())
|
|
.collect(),
|
|
})
|
|
} else {
|
|
None
|
|
}
|
|
})
|
|
.collect::<Vec<Post>>()
|
|
}
|
|
|
|
#[derive(Content, Debug)]
|
|
struct BlogPostTemplate {
|
|
navbar: NavBar,
|
|
post: Option<File>,
|
|
toc: String,
|
|
}
|
|
|
|
#[get("/blog/p/{id}")]
|
|
pub async fn page(path: web::Path<(String,)>, config: web::Data<Config>) -> impl Responder {
|
|
Html(build_post(
|
|
&path.into_inner().0,
|
|
config.get_ref().to_owned(),
|
|
))
|
|
}
|
|
|
|
fn build_post(file: &str, config: Config) -> String {
|
|
let mut post = None;
|
|
let (infos, toc) = get_post(
|
|
&mut post,
|
|
file,
|
|
&config.fc.name.unwrap_or_default(),
|
|
&config.locations.data_dir,
|
|
);
|
|
|
|
config.tmpl.render(
|
|
"blog/post.html",
|
|
BlogPostTemplate {
|
|
navbar: NavBar {
|
|
blog: true,
|
|
..NavBar::default()
|
|
},
|
|
post,
|
|
toc,
|
|
},
|
|
infos,
|
|
)
|
|
}
|
|
|
|
fn get_post(
|
|
post: &mut Option<File>,
|
|
filename: &str,
|
|
name: &str,
|
|
data_dir: &str,
|
|
) -> (InfosPage, String) {
|
|
let blog_dir = format!("{data_dir}/{BLOG_DIR}/{POST_DIR}");
|
|
let ext = ".md";
|
|
|
|
*post = read_file(
|
|
&format!("{blog_dir}/{filename}{ext}"),
|
|
&TypeFileMetadata::Blog,
|
|
);
|
|
|
|
let default = (
|
|
filename,
|
|
&format!("Blog d'{name}"),
|
|
Vec::new(),
|
|
String::new(),
|
|
);
|
|
let (title, desc, tags, toc) = match post {
|
|
Some(data) => (
|
|
match &data.metadata.info.blog.as_ref().unwrap().title {
|
|
Some(text) => text,
|
|
None => default.0,
|
|
},
|
|
match &data.metadata.info.blog.as_ref().unwrap().description {
|
|
Some(desc) => desc,
|
|
None => default.1,
|
|
},
|
|
match &data.metadata.info.blog.as_ref().unwrap().tags {
|
|
Some(tags) => tags.clone(),
|
|
None => default.2,
|
|
},
|
|
match &data.metadata.info.blog.as_ref().unwrap().toc {
|
|
// TODO: Generate TOC
|
|
Some(true) => String::new(),
|
|
_ => default.3,
|
|
},
|
|
),
|
|
None => default,
|
|
};
|
|
|
|
(
|
|
InfosPage {
|
|
title: Some(format!("Post: {title}")),
|
|
desc: Some(desc.clone()),
|
|
kw: Some(make_kw(
|
|
&["blog", "blogging", "write", "writing"]
|
|
.into_iter()
|
|
.chain(tags.iter().map(|t| t.name.as_str()))
|
|
.collect::<Vec<_>>(),
|
|
)),
|
|
},
|
|
toc,
|
|
)
|
|
}
|
|
|
|
#[routes]
|
|
#[get("/blog/blog.rss")]
|
|
#[get("/blog/rss")]
|
|
pub async fn rss(config: web::Data<Config>) -> impl Responder {
|
|
HttpResponse::Ok()
|
|
.content_type(ContentType(MIME_TYPE_RSS.parse().unwrap()))
|
|
.body(build_rss(config.get_ref().to_owned()))
|
|
}
|
|
|
|
#[once(time = 10800)] // 3h
|
|
fn build_rss(config: Config) -> String {
|
|
let mut posts = get_posts(&format!(
|
|
"{}/{}/{}",
|
|
config.locations.data_dir, BLOG_DIR, POST_DIR
|
|
));
|
|
|
|
// 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 = get_url(config.fc.clone());
|
|
let author = if let (Some(mail), Some(name)) = (config.fc.mail, config.fc.fullname.clone()) {
|
|
Some(format!("{mail} ({name})"))
|
|
} else {
|
|
None
|
|
};
|
|
let title = format!("Blog d'{}", config.fc.name.unwrap_or_default());
|
|
let lang = "fr";
|
|
let channel = Channel {
|
|
title: title.clone(),
|
|
link: link_to_site.clone(),
|
|
description: "Un fil qui parle d'informatique notamment".into(),
|
|
language: Some(lang.into()),
|
|
managing_editor: author.clone(),
|
|
webmaster: author,
|
|
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!("{link_to_site}/icons/favicon-32x32.png"),
|
|
title: title.clone(),
|
|
link: link_to_site.clone(),
|
|
..Image::default()
|
|
}),
|
|
items: posts
|
|
.iter_mut()
|
|
.map(|p| {
|
|
// Get post data
|
|
p.fetch_content(&config.locations.data_dir);
|
|
|
|
// Build item
|
|
Item {
|
|
title: Some(p.title.clone()),
|
|
link: Some(format!("{}/blog/p/{}", link_to_site, p.url)),
|
|
description: p.content.clone(),
|
|
categories: p
|
|
.tags
|
|
.iter()
|
|
.map(|c| Category {
|
|
name: c.to_owned(),
|
|
..Category::default()
|
|
})
|
|
.collect(),
|
|
guid: Some(Guid {
|
|
value: format!("urn:hash:{}", {
|
|
let mut hasher = DefaultHasher::new();
|
|
p.hash(&mut hasher);
|
|
hasher.finish()
|
|
}),
|
|
permalink: false,
|
|
}),
|
|
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(),
|
|
atom_ext: Some(AtomExtension {
|
|
links: vec![Link {
|
|
href: format!("{link_to_site}/blog/rss"),
|
|
rel: "self".into(),
|
|
hreflang: Some(lang.into()),
|
|
mime_type: Some(MIME_TYPE_RSS.into()),
|
|
title: Some(title),
|
|
length: None,
|
|
}],
|
|
}),
|
|
..Channel::default()
|
|
};
|
|
|
|
std::str::from_utf8(&channel.write_to(Vec::new()).unwrap())
|
|
.unwrap()
|
|
.into()
|
|
}
|