Posts dedicated page with cards linking to specific post

src/routes/login.rs

@@ -9,6 +9,7 @@ use askama::Template;
 use axum::{
     Form, Json,
     extract::State,
+    http::HeaderMap,
     response::{Html, IntoResponse, Response},
 };
 use axum::{http::StatusCode, response::Redirect};
@@ -114,11 +115,9 @@ pub async fn post_login(
                 .await
                 .map_err(|e| LoginError::UnexpectedError(e.into()))?;
 
-            let mut response = Redirect::to("/admin/dashboard").into_response();
-            response
-                .headers_mut()
-                .insert("HX-Redirect", "/admin/dashboard".parse().unwrap());
-            Ok(response)
+            let mut headers = HeaderMap::new();
+            headers.insert("HX-Redirect", "/admin/dashboard".parse().unwrap());
+            Ok((StatusCode::OK, headers).into_response())
         }
     }
 }

src/routes/posts.rs

@@ -0,0 +1,103 @@
+use crate::startup::AppState;
+use askama::Template;
+use axum::{
+    extract::{Path, State},
+    response::{Html, IntoResponse, Response},
+};
+use chrono::{DateTime, Utc};
+use reqwest::StatusCode;
+use sqlx::PgPool;
+use uuid::Uuid;
+
+struct PostEntry {
+    post_id: Uuid,
+    author: Option<String>,
+    title: String,
+    content: String,
+    published_at: DateTime<Utc>,
+}
+
+impl PostEntry {
+    #[allow(dead_code)]
+    fn formatted_date(&self) -> String {
+        self.published_at.format("%B %d, %Y").to_string()
+    }
+}
+
+#[derive(Template)]
+#[template(path = "../templates/posts.html")]
+struct PostsTemplate {
+    posts: Vec<PostEntry>,
+}
+
+#[derive(Template)]
+#[template(path = "../templates/post.html")]
+struct PostTemplate {
+    post: PostEntry,
+}
+
+pub async fn list_posts(
+    State(AppState {
+        connection_pool, ..
+    }): State<AppState>,
+) -> Response {
+    match get_latest_posts(&connection_pool, 5).await {
+        Err(e) => {
+            tracing::error!("Could not fetch latest posts: {}", e);
+            StatusCode::INTERNAL_SERVER_ERROR.into_response()
+        }
+        Ok(posts) => {
+            let template = PostsTemplate { posts };
+            Html(template.render().unwrap()).into_response()
+        }
+    }
+}
+
+async fn get_latest_posts(connection_pool: &PgPool, n: i64) -> Result<Vec<PostEntry>, sqlx::Error> {
+    sqlx::query_as!(
+        PostEntry,
+        r#"
+        SELECT p.post_id, u.username AS author, p.title, p.content, p.published_at
+        FROM posts p
+        LEFT JOIN users u ON p.author_id = u.user_id
+        ORDER BY p.published_at DESC
+        LIMIT $1
+        "#,
+        n
+    )
+    .fetch_all(connection_pool)
+    .await
+}
+
+pub async fn see_post(
+    State(AppState {
+        connection_pool, ..
+    }): State<AppState>,
+    Path(post_id): Path<Uuid>,
+) -> Response {
+    match get_post(&connection_pool, post_id).await {
+        Err(e) => {
+            tracing::error!("Could not fetch post #{}: {}", post_id, e);
+            StatusCode::INTERNAL_SERVER_ERROR.into_response()
+        }
+        Ok(post) => {
+            let template = PostTemplate { post };
+            Html(template.render().unwrap()).into_response()
+        }
+    }
+}
+
+async fn get_post(connection_pool: &PgPool, post_id: Uuid) -> Result<PostEntry, sqlx::Error> {
+    sqlx::query_as!(
+        PostEntry,
+        r#"
+        SELECT p.post_id, u.username AS author, p.title, p.content, p.published_at
+        FROM posts p
+        LEFT JOIN users u ON p.author_id = u.user_id
+        WHERE p.post_id = $1
+        "#,
+        post_id
+    )
+    .fetch_one(connection_pool)
+    .await
+}