Posts management widget

src/routes/admin/dashboard.rs

@@ -1,4 +1,4 @@
-use crate::routes::get_users;
+use crate::routes::{POSTS_PER_PAGE, SUBS_PER_PAGE, get_posts_count, get_posts_page, get_users};
 use crate::{
     authentication::AuthenticatedUser,
     routes::{AppError, get_max_page, get_subs, get_total_subs},
@@ -45,10 +45,18 @@ pub async fn admin_dashboard(
     let count = get_total_subs(&connection_pool)
         .await
         .context("Could not fetch total subscribers count from the database.")?;
-    let max_page = get_max_page(count);
+    let max_page = get_max_page(count, SUBS_PER_PAGE);
     let users = get_users(&connection_pool)
         .await
         .context("Could not fetch users")?;
+    let posts = get_posts_page(&connection_pool, 1)
+        .await
+        .context("Could not fetch posts.")?;
+    let posts_current_page = 1;
+    let count = get_posts_count(&connection_pool)
+        .await
+        .context("Could not fetch posts count.")?;
+    let posts_max_page = get_max_page(count, POSTS_PER_PAGE);
     let template = DashboardTemplate {
         user,
         idempotency_key_1,
@@ -58,6 +66,9 @@ pub async fn admin_dashboard(
         current_page,
         max_page,
         users,
+        posts,
+        posts_current_page,
+        posts_max_page,
     };
     Ok(Html(template.render().unwrap()).into_response())
 }

src/routes/admin/subscribers.rs

@@ -13,7 +13,7 @@ use axum::{
 use sqlx::PgPool;
 use uuid::Uuid;
 
-const SUBS_PER_PAGE: i64 = 5;
+pub const SUBS_PER_PAGE: i64 = 5;
 
 #[tracing::instrument(name = "Retrieving subscribers from database", skip(connection_pool))]
 pub async fn get_subscribers_page(
@@ -26,7 +26,7 @@ pub async fn get_subscribers_page(
         .await
         .context("Could not fetch total subscribers count from the database.")
         .map_err(AppError::unexpected_message)?;
-    let max_page = get_max_page(count);
+    let max_page = get_max_page(count, SUBS_PER_PAGE);
     let subscribers = get_subs(&connection_pool, page)
         .await
         .context("Could not fetch subscribers data.")
@@ -102,9 +102,9 @@ pub async fn get_total_subs(connection_pool: &PgPool) -> Result<i64, sqlx::Error
     Ok(count)
 }
 
-pub fn get_max_page(count: i64) -> i64 {
-    let mut max_page = count.div_euclid(SUBS_PER_PAGE);
-    if count % SUBS_PER_PAGE > 0 {
+pub fn get_max_page(count: i64, num_per_page: i64) -> i64 {
+    let mut max_page = count.div_euclid(num_per_page);
+    if count % num_per_page > 0 {
         max_page += 1;
     }
     max_page

src/routes/posts.rs

@@ -1,3 +1,5 @@
+use crate::routes::get_max_page;
+use crate::templates::PostsPageDashboardTemplate;
 use crate::{
     domain::PostEntry,
     routes::{
@@ -16,7 +18,7 @@ use axum::{
 use sqlx::PgPool;
 use uuid::Uuid;
 
-const NUM_PER_PAGE: i64 = 3;
+pub const POSTS_PER_PAGE: i64 = 3;
 
 #[tracing::instrument(name = "Fetching most recent posts from database", skip_all)]
 pub async fn list_posts(
@@ -24,12 +26,16 @@ pub async fn list_posts(
         connection_pool, ..
     }): State<AppState>,
 ) -> Result<Response, AppError> {
-    let count = get_posts_table_size(&connection_pool)
+    let count = get_posts_count(&connection_pool)
         .await
         .context("Could not fetch posts table size.")
         .map_err(AppError::unexpected_page)?;
-    let next_page = if count > NUM_PER_PAGE { Some(2) } else { None };
-    let posts = get_posts(&connection_pool, NUM_PER_PAGE, None)
+    let next_page = if count > POSTS_PER_PAGE {
+        Some(2)
+    } else {
+        None
+    };
+    let posts = get_posts(&connection_pool, POSTS_PER_PAGE, None)
         .await
         .context("Could not fetch latest posts")
         .map_err(AppError::unexpected_page)?;
@@ -37,6 +43,29 @@ pub async fn list_posts(
     Ok(Html(template.render().unwrap()).into_response())
 }
 
+#[tracing::instrument(name = "Fetching next posts from database", skip_all)]
+pub async fn get_posts_page_dashboard(
+    State(AppState {
+        connection_pool, ..
+    }): State<AppState>,
+    Query(LoadMoreParams { page }): Query<LoadMoreParams>,
+) -> Result<Response, AppError> {
+    let posts = get_posts_page(&connection_pool, page)
+        .await
+        .context("Could not fetch next posts page.")?;
+    let posts_current_page = page;
+    let count = get_posts_count(&connection_pool)
+        .await
+        .context("Could not fetch number of posts.")?;
+    let posts_max_page = get_max_page(count, POSTS_PER_PAGE);
+    let template = HtmlTemplate(PostsPageDashboardTemplate {
+        posts,
+        posts_current_page,
+        posts_max_page,
+    });
+    Ok(template.into_response())
+}
+
 async fn get_posts(
     connection_pool: &PgPool,
     n: i64,
@@ -59,7 +88,29 @@ async fn get_posts(
     .await
 }
 
-async fn get_posts_table_size(connection_pool: &PgPool) -> Result<i64, sqlx::Error> {
+pub async fn get_posts_page(
+    connection_pool: &PgPool,
+    page: i64,
+) -> Result<Vec<PostEntry>, sqlx::Error> {
+    let offset = (page - 1) * POSTS_PER_PAGE;
+    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
+        OFFSET $2
+        "#,
+        POSTS_PER_PAGE,
+        offset
+    )
+    .fetch_all(connection_pool)
+    .await
+}
+
+pub async fn get_posts_count(connection_pool: &PgPool) -> Result<i64, sqlx::Error> {
     sqlx::query!("SELECT count(*) FROM posts")
         .fetch_one(connection_pool)
         .await
@@ -156,15 +207,14 @@ pub async fn load_more(
     }): State<AppState>,
     Query(LoadMoreParams { page }): Query<LoadMoreParams>,
 ) -> Result<Response, AppError> {
-    let offset = (page - 1) * NUM_PER_PAGE;
-    let posts = get_posts(&connection_pool, NUM_PER_PAGE, Some(offset))
+    let posts = get_posts_page(&connection_pool, page)
         .await
         .context("Could not fetch posts from database.")?;
     let count = posts.len();
     Ok(Html(
         PostListTemplate {
             posts,
-            next_page: if count as i64 == NUM_PER_PAGE {
+            next_page: if count as i64 == POSTS_PER_PAGE {
                 Some(page + 1)
             } else {
                 None

src/startup.rs

@@ -87,6 +87,7 @@ pub fn app(
     let admin_routes = Router::new()
         .route("/subscribers", get(get_subscribers_page))
         .route("/subscribers/{subscriber_id}", delete(delete_subscriber))
+        .route("/posts", get(get_posts_page_dashboard))
         .route("/posts/{post_id}", delete(delete_post))
         .route("/users", post(create_user))
         .route("/users/{user_id}", delete(delete_user))

src/templates.rs

@@ -65,6 +65,17 @@ pub struct DashboardTemplate {
     pub current_page: i64,
     pub max_page: i64,
     pub users: Vec<UserEntry>,
+    pub posts: Vec<PostEntry>,
+    pub posts_current_page: i64,
+    pub posts_max_page: i64,
+}
+
+#[derive(Template)]
+#[template(path = "dashboard/posts/list.html", block = "posts")]
+pub struct PostsPageDashboardTemplate {
+    pub posts: Vec<PostEntry>,
+    pub posts_current_page: i64,
+    pub posts_max_page: i64,
 }
 
 #[derive(Template)]