402 lines
14 KiB
Rust
402 lines
14 KiB
Rust
use crate::{
|
|
datasources::posts::PostsDatasource,
|
|
state::AppState,
|
|
utils::{
|
|
datetime::*,
|
|
rss,
|
|
sitemap::{self, SitemapEntry},
|
|
},
|
|
};
|
|
use axum::http::{HeaderMap, HeaderValue};
|
|
use axum::{
|
|
extract::{Path, State},
|
|
http::{header, StatusCode},
|
|
response::IntoResponse,
|
|
routing::get,
|
|
Json, Router,
|
|
};
|
|
use chrono::Utc;
|
|
use fred::types::Expiration;
|
|
use serde::{Deserialize, Serialize};
|
|
use std::collections::HashMap;
|
|
|
|
#[derive(sqlx::FromRow, Deserialize, Serialize, Debug, Clone)]
|
|
pub struct Post {
|
|
pub post_id: i32,
|
|
pub author_id: Option<i32>,
|
|
pub first_name: Option<String>,
|
|
pub last_name: Option<String>,
|
|
pub title: String,
|
|
pub body: String,
|
|
#[serde(serialize_with = "serialize_datetime")]
|
|
#[serde(deserialize_with = "deserialize_datetime")]
|
|
pub created_at: Option<chrono::DateTime<Utc>>,
|
|
}
|
|
|
|
#[derive(sqlx::FromRow, Deserialize, Serialize, Debug, Clone)]
|
|
pub struct PostFeaturedVariant {
|
|
pub post_id: i32,
|
|
pub author_id: Option<i32>,
|
|
pub first_name: Option<String>,
|
|
pub last_name: Option<String>,
|
|
pub title: String,
|
|
pub body: String,
|
|
#[serde(serialize_with = "serialize_datetime")]
|
|
#[serde(deserialize_with = "deserialize_datetime")]
|
|
pub created_at: Option<chrono::DateTime<Utc>>,
|
|
pub is_featured: Option<bool>,
|
|
}
|
|
|
|
#[derive(Deserialize)]
|
|
pub struct PostGetOneParams {
|
|
pub id: i32,
|
|
}
|
|
|
|
pub struct PostsRoute;
|
|
impl PostsRoute {
|
|
pub fn routes(app_state: &AppState) -> Router {
|
|
// add more post routes here!
|
|
Router::new()
|
|
.route("/all", get(PostsRoute::get_all))
|
|
.route("/:id", get(PostsRoute::get_one))
|
|
.route("/recent", get(PostsRoute::get_recent_posts))
|
|
.route("/popular", get(PostsRoute::get_popular_posts))
|
|
.route("/hot", get(PostsRoute::get_hot_posts))
|
|
.route("/featured", get(PostsRoute::get_featured_posts))
|
|
.route("/rss", get(PostsRoute::get_rss_posts))
|
|
.route("/sitemap", get(PostsRoute::get_sitemap))
|
|
.with_state(app_state.clone())
|
|
}
|
|
|
|
// get all posts
|
|
async fn get_all(State(app_state): State<AppState>) -> impl IntoResponse {
|
|
let mut state = app_state.lock().await;
|
|
let cached: Option<Vec<Post>> = state
|
|
.cache
|
|
.get(String::from("posts:all"))
|
|
.await
|
|
.unwrap_or(None);
|
|
|
|
if let Some(posts) = cached {
|
|
tracing::info!("grabbing all posts from cache");
|
|
return Ok(Json(posts));
|
|
};
|
|
|
|
match PostsDatasource::get_all(&state.database).await {
|
|
Ok(posts) => {
|
|
tracing::info!("grabbing all posts from database");
|
|
if let p = &posts {
|
|
let posts = p.clone();
|
|
let state = app_state.clone();
|
|
|
|
tracing::info!("storing database data in cache");
|
|
tokio::spawn(async move {
|
|
let mut s = state.lock().await;
|
|
let _ = s
|
|
.cache
|
|
.set(
|
|
String::from("posts:all"),
|
|
&posts,
|
|
Some(Expiration::EX(10)),
|
|
None,
|
|
false,
|
|
)
|
|
.await;
|
|
});
|
|
};
|
|
|
|
Ok(Json(posts))
|
|
}
|
|
Err(e) => Err((StatusCode::INTERNAL_SERVER_ERROR, e.to_string())),
|
|
}
|
|
}
|
|
|
|
// get one post
|
|
async fn get_one(
|
|
State(app_state): State<AppState>,
|
|
Path(params): Path<PostGetOneParams>,
|
|
) -> impl IntoResponse {
|
|
let mut state = app_state.lock().await;
|
|
let cached: Option<PostFeaturedVariant> = state
|
|
.cache
|
|
.get(format!("posts:{}", params.id))
|
|
.await
|
|
.unwrap_or(None);
|
|
|
|
if let Some(post) = cached {
|
|
tracing::info!("grabbing one post from cache");
|
|
return Ok(Json(post));
|
|
};
|
|
|
|
match PostsDatasource::get_one(&state.database, params.id).await {
|
|
Ok(post) => {
|
|
tracing::info!("grabbing one post from database");
|
|
if let p = &post {
|
|
let post = p.clone();
|
|
let state = app_state.clone();
|
|
|
|
tracing::info!("storing database data in cache");
|
|
tokio::spawn(async move {
|
|
let mut s = state.lock().await;
|
|
let _ = s
|
|
.cache
|
|
.set(
|
|
format!("posts:{}", params.id),
|
|
&post,
|
|
Some(Expiration::EX(10)),
|
|
None,
|
|
false,
|
|
)
|
|
.await;
|
|
});
|
|
};
|
|
|
|
Ok(Json(post))
|
|
}
|
|
Err(e) => Err((StatusCode::INTERNAL_SERVER_ERROR, e.to_string())),
|
|
}
|
|
}
|
|
|
|
// get recent posts
|
|
async fn get_recent_posts(State(app_state): State<AppState>) -> impl IntoResponse {
|
|
let mut state = app_state.lock().await;
|
|
let cached: Option<Vec<Post>> = state
|
|
.cache
|
|
.get(String::from("posts:recent"))
|
|
.await
|
|
.unwrap_or(None);
|
|
|
|
if let Some(posts) = cached {
|
|
tracing::info!("grabbing recent posts from cache");
|
|
return Ok(Json(posts));
|
|
};
|
|
|
|
match PostsDatasource::get_recent(&state.database).await {
|
|
Ok(posts) => {
|
|
tracing::info!("grabbing recent posts from database");
|
|
if let p = &posts {
|
|
let posts = p.clone();
|
|
let state = app_state.clone();
|
|
|
|
tracing::info!("storing database data in cache");
|
|
tokio::spawn(async move {
|
|
let mut s = state.lock().await;
|
|
let _ = s
|
|
.cache
|
|
.set(
|
|
String::from("posts:recent"),
|
|
&posts,
|
|
Some(Expiration::EX(5)),
|
|
None,
|
|
false,
|
|
)
|
|
.await;
|
|
});
|
|
};
|
|
|
|
Ok(Json(posts))
|
|
}
|
|
Err(e) => Err((StatusCode::INTERNAL_SERVER_ERROR, e.to_string())),
|
|
}
|
|
}
|
|
|
|
// get the top three posts with the highest view count
|
|
async fn get_popular_posts(State(app_state): State<AppState>) -> impl IntoResponse {
|
|
let mut state = app_state.lock().await;
|
|
let cached: Option<Vec<Post>> = state
|
|
.cache
|
|
.get(String::from("posts:popular"))
|
|
.await
|
|
.unwrap_or(None);
|
|
|
|
if let Some(posts) = cached {
|
|
tracing::info!("grabbing popular posts from cache");
|
|
return Ok(Json(posts));
|
|
};
|
|
|
|
match PostsDatasource::get_popular(&state.database).await {
|
|
Ok(posts) => {
|
|
tracing::info!("grabbing popular posts from database");
|
|
if let p = &posts {
|
|
let posts = p.clone();
|
|
let state = app_state.clone();
|
|
|
|
tracing::info!("storing database data in cache");
|
|
tokio::spawn(async move {
|
|
let mut s = state.lock().await;
|
|
let _ = s
|
|
.cache
|
|
.set(
|
|
String::from("posts:popular"),
|
|
&posts,
|
|
Some(Expiration::EX(5)),
|
|
None,
|
|
false,
|
|
)
|
|
.await;
|
|
});
|
|
};
|
|
|
|
Ok(Json(posts))
|
|
}
|
|
Err(e) => Err((StatusCode::INTERNAL_SERVER_ERROR, e.to_string())),
|
|
}
|
|
}
|
|
|
|
// get the top three posts with the most comments
|
|
async fn get_hot_posts(State(app_state): State<AppState>) -> impl IntoResponse {
|
|
let mut state = app_state.lock().await;
|
|
let cached: Option<Vec<Post>> = state
|
|
.cache
|
|
.get(String::from("posts:hot"))
|
|
.await
|
|
.unwrap_or(None);
|
|
|
|
if let Some(posts) = cached {
|
|
tracing::info!("grabbing hot posts from cache");
|
|
return Ok(Json(posts));
|
|
};
|
|
|
|
match PostsDatasource::get_hot(&state.database).await {
|
|
Ok(posts) => {
|
|
tracing::info!("grabbing hot posts from database");
|
|
if let p = &posts {
|
|
let posts = p.clone();
|
|
let state = app_state.clone();
|
|
|
|
tracing::info!("storing database data in cache");
|
|
tokio::spawn(async move {
|
|
let mut s = state.lock().await;
|
|
let _ = s
|
|
.cache
|
|
.set(
|
|
String::from("posts:hot"),
|
|
&posts,
|
|
Some(Expiration::EX(5)),
|
|
None,
|
|
false,
|
|
)
|
|
.await;
|
|
});
|
|
};
|
|
|
|
Ok(Json(posts))
|
|
}
|
|
Err(e) => Err((StatusCode::INTERNAL_SERVER_ERROR, e.to_string())),
|
|
}
|
|
}
|
|
|
|
// get posts that are featured
|
|
async fn get_featured_posts(State(app_state): State<AppState>) -> impl IntoResponse {
|
|
let mut state = app_state.lock().await;
|
|
let cached: Option<Vec<Post>> = state
|
|
.cache
|
|
.get(String::from("posts:featured"))
|
|
.await
|
|
.unwrap_or(None);
|
|
|
|
if let Some(posts) = cached {
|
|
tracing::info!("grabbing featured posts from cache");
|
|
return Ok(Json(posts));
|
|
};
|
|
|
|
match PostsDatasource::get_featured(&state.database).await {
|
|
Ok(posts) => {
|
|
tracing::info!("grabbing featured posts from database");
|
|
if let p = &posts {
|
|
let posts = p.clone();
|
|
let state = app_state.clone();
|
|
|
|
tracing::info!("storing database data in cache");
|
|
tokio::spawn(async move {
|
|
let mut s = state.lock().await;
|
|
let _ = s
|
|
.cache
|
|
.set(
|
|
String::from("posts:featured"),
|
|
&posts,
|
|
Some(Expiration::EX(5)),
|
|
None,
|
|
false,
|
|
)
|
|
.await;
|
|
});
|
|
};
|
|
|
|
Ok(Json(posts))
|
|
}
|
|
Err(e) => Err((StatusCode::INTERNAL_SERVER_ERROR, e.to_string())),
|
|
}
|
|
}
|
|
|
|
// get rss posts
|
|
async fn get_rss_posts(State(app_state): State<AppState>) -> impl IntoResponse {
|
|
let state = app_state.lock().await;
|
|
|
|
match PostsDatasource::get_all(&state.database).await {
|
|
Ok(posts) => {
|
|
let web_url =
|
|
std::env::var("BASE_URI_WEB").expect("Environment BASE_URI_WEB variable found");
|
|
let mapped_posts: HashMap<String, Post> = posts
|
|
.into_iter()
|
|
.map(|post| (post.post_id.to_string(), post))
|
|
.collect();
|
|
let xml: String = rss::generate_rss(
|
|
"Wyatt's blog",
|
|
"Wyatt and friends",
|
|
web_url.as_str(),
|
|
&mapped_posts,
|
|
);
|
|
let mut headers = HeaderMap::new();
|
|
headers.insert(
|
|
header::CONTENT_TYPE,
|
|
HeaderValue::from_static("application/xml"),
|
|
);
|
|
(headers, xml)
|
|
}
|
|
Err(e) => {
|
|
let mut headers = HeaderMap::new();
|
|
headers.insert("Content-Type", HeaderValue::from_static("text/plain"));
|
|
(headers, e.to_string())
|
|
}
|
|
}
|
|
}
|
|
|
|
async fn get_sitemap(State(app_state): State<AppState>) -> impl IntoResponse {
|
|
let state = app_state.lock().await;
|
|
// let cached: Option<Vec<Post>> = None; // TODO: maybe implement cache, later??
|
|
|
|
match PostsDatasource::get_all(&state.database).await {
|
|
Ok(posts) => {
|
|
let web_url =
|
|
std::env::var("BASE_URI_WEB").expect("Environment BASE_URI_WEB variable found");
|
|
let mut entries: HashMap<String, SitemapEntry> = posts
|
|
.into_iter()
|
|
.map(|p| {
|
|
(
|
|
p.post_id.to_string(),
|
|
SitemapEntry {
|
|
location: format!("{}/posts/{}", web_url, p.post_id.to_string()),
|
|
lastmod: p.created_at.unwrap_or_else(|| chrono::Utc::now()),
|
|
},
|
|
)
|
|
})
|
|
.collect();
|
|
sitemap::get_static_pages(&mut entries, &web_url);
|
|
let xml: String = sitemap::generate_sitemap(&entries);
|
|
let mut headers = HeaderMap::new();
|
|
headers.insert(
|
|
header::CONTENT_TYPE,
|
|
HeaderValue::from_static("application/xml"),
|
|
);
|
|
(headers, xml)
|
|
}
|
|
Err(e) => {
|
|
let mut headers = HeaderMap::new();
|
|
headers.insert("Content-Type", HeaderValue::from_static("text/plain"));
|
|
(headers, e.to_string())
|
|
}
|
|
}
|
|
}
|
|
}
|