Merge pull request #1 from elsiribot/2026-03-global-scan-list

feat: add paginated admin scan log with daily scan graph

Author: elsirion

src/db.rs

@@ -1,7 +1,8 @@
 use crate::balance::{compute_balance_msats, BalanceConfig};
 use crate::models::{
-    AuthMethod, Claim, ClaimResult, Donation, Location, NfcCard, NfcScan, Photo, ScanWithLocation,
-    ScanWithUser, Stats, User, UserRole, UserTransaction, WithdrawalStatus,
+    AdminScan, AuthMethod, Claim, ClaimResult, DailyScanCount, Donation, Location, NfcCard,
+    NfcScan, Photo, ScanWithLocation, ScanWithUser, Stats, User, UserRole, UserTransaction,
+    WithdrawalStatus,
 };
 use anyhow::Result;
 use chrono::Utc;
@@ -612,6 +613,79 @@ impl Database {
         .map_err(Into::into)
     }
 
+    /// Get paginated global scan list for admin page
+    pub async fn get_admin_scans(&self, limit: i64, offset: i64) -> Result<Vec<AdminScan>> {
+        sqlx::query_as::<_, AdminScan>(
+            r#"
+            SELECT
+                s.id,
+                s.location_id,
+                s.user_id,
+                s.scanned_at,
+                s.claimed_at,
+                c.msats_claimed,
+                l.name AS location_name,
+                creator.username AS creator_username,
+                l.user_id AS creator_user_id,
+                scanner.username AS scanner_username
+            FROM scans s
+            LEFT JOIN claims c ON s.claim_id = c.id
+            JOIN locations l ON s.location_id = l.id
+            LEFT JOIN users creator ON l.user_id = creator.id
+            LEFT JOIN users scanner ON s.user_id = scanner.id
+            ORDER BY s.scanned_at DESC
+            LIMIT ? OFFSET ?
+            "#,
+        )
+        .bind(limit)
+        .bind(offset)
+        .fetch_all(&self.pool)
+        .await
+        .map_err(Into::into)
+    }
+
+    /// Get total scan count for pagination
+    pub async fn count_scans(&self) -> Result<i64> {
+        let row: (i64,) = sqlx::query_as("SELECT COUNT(*) FROM scans")
+            .fetch_one(&self.pool)
+            .await?;
+        Ok(row.0)
+    }
+
+    /// Get daily scan counts for a date range (inclusive)
+    pub async fn get_daily_scan_counts(
+        &self,
+        from_date: &str,
+        to_date: &str,
+    ) -> Result<Vec<DailyScanCount>> {
+        sqlx::query_as::<_, DailyScanCount>(
+            r#"
+            SELECT
+                DATE(scanned_at) AS date,
+                COUNT(*) AS count
+            FROM scans
+            WHERE DATE(scanned_at) >= ? AND DATE(scanned_at) <= ?
+            GROUP BY DATE(scanned_at)
+            ORDER BY date ASC
+            "#,
+        )
+        .bind(from_date)
+        .bind(to_date)
+        .fetch_all(&self.pool)
+        .await
+        .map_err(Into::into)
+    }
+
+    /// Get the date of the earliest scan (for "all time" graph range)
+    pub async fn get_earliest_scan_date(&self) -> Result<Option<chrono::NaiveDate>> {
+        let date: Option<chrono::NaiveDate> = sqlx::query_scalar(
+            "SELECT DATE(MIN(scanned_at)) FROM scans WHERE scanned_at IS NOT NULL",
+        )
+        .fetch_one(&self.pool)
+        .await?;
+        Ok(date)
+    }
+
     /// Claim sats from a previous scan
     /// Returns ClaimResult indicating success or reason for failure
     pub async fn claim_from_scan(

src/handlers/pages.rs

@@ -883,3 +883,82 @@ pub async fn admin_locations_page(
 
     Ok(Html(page.into_string()))
 }
+
+#[derive(Deserialize)]
+pub struct AdminScansQuery {
+    pub page: Option<i64>,
+    pub days: Option<i64>,
+}
+
+/// Admin scans page - global scan list with daily scan graph
+pub async fn admin_scans_page(
+    user: CookieUser,
+    State(state): State<Arc<AppState>>,
+    Query(query): Query<AdminScansQuery>,
+) -> Result<Html<String>, Response> {
+    let username = user.ensure_registered_with_role(UserRole::Admin)?;
+
+    let days = query.days.unwrap_or(30).max(0); // 0 = all time
+    let per_page: i64 = 50;
+
+    let total_scans = state.db.count_scans().await.map_err(|e| {
+        tracing::error!("Failed to count scans: {}", e);
+        StatusCode::INTERNAL_SERVER_ERROR.into_response()
+    })?;
+    let total_pages = (total_scans + per_page - 1) / per_page;
+    let page = query.page.unwrap_or(1).max(1).min(total_pages.max(1));
+    let offset = (page - 1) * per_page;
+
+    let scans = state
+        .db
+        .get_admin_scans(per_page, offset)
+        .await
+        .map_err(|e| {
+            tracing::error!("Failed to get admin scans: {}", e);
+            StatusCode::INTERNAL_SERVER_ERROR.into_response()
+        })?;
+
+    let today = chrono::Utc::now().date_naive();
+    let from_date = if days == 0 {
+        // All time: find earliest scan date, fall back to today
+        state
+            .db
+            .get_earliest_scan_date()
+            .await
+            .ok()
+            .flatten()
+            .unwrap_or(today)
+    } else {
+        today - chrono::Duration::days(days - 1)
+    };
+    let daily_counts = state
+        .db
+        .get_daily_scan_counts(&from_date.to_string(), &today.to_string())
+        .await
+        .map_err(|e| {
+            tracing::error!("Failed to get daily scan counts: {}", e);
+            StatusCode::INTERNAL_SERVER_ERROR.into_response()
+        })?;
+
+    // Fill in missing days with zero counts
+    let counts_map: std::collections::HashMap<String, i64> = daily_counts
+        .iter()
+        .map(|d| (d.date.clone(), d.count))
+        .collect();
+    let mut filled_counts = Vec::new();
+    let mut current = from_date;
+    while current <= today {
+        let date_str = current.to_string();
+        let count = counts_map.get(&date_str).copied().unwrap_or(0);
+        filled_counts.push(crate::models::DailyScanCount {
+            date: date_str,
+            count,
+        });
+        current += chrono::Duration::days(1);
+    }
+
+    let content = templates::admin_scans(&scans, &filled_counts, page, total_pages, days);
+    let page_html = templates::base_with_user("Scan Log", content, username, user.role(), true);
+
+    Ok(Html(page_html.into_string()))
+}

src/main.rs

@@ -128,6 +128,7 @@ async fn main() -> Result<()> {
             "/admin/locations",
             get(auth(handlers::admin_locations_page)),
         )
+        .route("/admin/scans", get(auth(handlers::admin_scans_page)))
         // API routes
         .route("/api/locations", post(handlers::create_location))
         .route(

src/models.rs

@@ -461,6 +461,54 @@ impl ScanWithLocation {
     }
 }
 
+/// A scan record with full context for the admin global scan list
+#[derive(Debug, Clone, FromRow, Serialize, Deserialize)]
+pub struct AdminScan {
+    pub id: String,
+    pub location_id: String,
+    pub user_id: String,
+    pub scanned_at: DateTime<Utc>,
+    pub claimed_at: Option<DateTime<Utc>>,
+    /// Amount claimed in msats (None if not claimed)
+    pub msats_claimed: Option<i64>,
+    /// Location name
+    pub location_name: String,
+    /// Location creator username
+    pub creator_username: Option<String>,
+    /// Location creator user ID (for fallback display)
+    pub creator_user_id: String,
+    /// Scanner username
+    pub scanner_username: Option<String>,
+}
+
+impl AdminScan {
+    pub fn sats_claimed(&self) -> i64 {
+        self.msats_claimed.unwrap_or(0) / 1000
+    }
+
+    pub fn scanner_display_name(&self) -> String {
+        self.scanner_username
+            .clone()
+            .unwrap_or_else(|| format!("anon_{}", &self.user_id[..8.min(self.user_id.len())]))
+    }
+
+    pub fn creator_display_name(&self) -> String {
+        self.creator_username.clone().unwrap_or_else(|| {
+            format!(
+                "anon_{}",
+                &self.creator_user_id[..8.min(self.creator_user_id.len())]
+            )
+        })
+    }
+}
+
+/// Daily scan count for the admin scan graph
+#[derive(Debug, Clone, FromRow, Serialize, Deserialize)]
+pub struct DailyScanCount {
+    pub date: String,
+    pub count: i64,
+}
+
 /// Result of attempting to claim sats from a scan
 #[derive(Debug)]
 pub enum ClaimResult {

src/templates/admin_scans.rs

@@ -0,0 +1,157 @@
+use crate::models::{AdminScan, DailyScanCount};
+use maud::{html, Markup};
+
+pub fn admin_scans(
+    scans: &[AdminScan],
+    daily_counts: &[DailyScanCount],
+    current_page: i64,
+    total_pages: i64,
+    days: i64,
+) -> Markup {
+    let max_count = daily_counts
+        .iter()
+        .map(|d| d.count)
+        .max()
+        .unwrap_or(1)
+        .max(1);
+
+    html! {
+        div class="mb-8" {
+            div class="flex justify-between items-center mb-8" {
+                h1 class="text-4xl font-black text-primary" style="letter-spacing: -0.02em;" {
+                    "SCAN LOG"
+                }
+            }
+
+            // Timeframe selector
+            div class="flex flex-wrap gap-2 mb-6" {
+                @for &d in &[30, 60, 90] {
+                    @if d == days {
+                        a href={"/admin/scans?days=" (d)} class="btn-brutal-fill" {
+                            (d) " DAYS"
+                        }
+                    } @else {
+                        a href={"/admin/scans?days=" (d)} class="btn-brutal" {
+                            (d) " DAYS"
+                        }
+                    }
+                }
+                @if days == 0 {
+                    a href="/admin/scans?days=0" class="btn-brutal-fill" { "ALL" }
+                } @else {
+                    a href="/admin/scans?days=0" class="btn-brutal" { "ALL" }
+                }
+            }
+
+            // Daily scan graph
+            div class="card-brutal mb-8" {
+                h2 class="text-xl font-black text-primary mb-4" {
+                    "DAILY SCANS"
+                }
+                @let num_days = daily_counts.len();
+                @let label_interval = if num_days <= 14 { 1 } else if num_days <= 31 { 7 } else if num_days <= 90 { 14 } else { 30 };
+                div style="overflow-x: auto;" {
+                    // Bars
+                    div style="display: flex; align-items: flex-end; height: 180px; gap: 1px; min-width: 100%;" {
+                        @for day in daily_counts {
+                            @let bar_height = if max_count > 0 { (day.count as f64 / max_count as f64 * 100.0).max(1.0) } else { 1.0 };
+                            div
+                                style={"flex: 1; min-width: 2px; height: " (bar_height as i64) "%; background: var(--highlight);"}
+                                title={(day.date) ": " (day.count) " scans"} {}
+                        }
+                    }
+                    // Date labels
+                    div style="display: flex; gap: 1px; min-width: 100%;" {
+                        @for (i, day) in daily_counts.iter().enumerate() {
+                            div style="flex: 1; min-width: 2px; text-align: center; overflow: visible; position: relative;" {
+                                @if i % label_interval == 0 {
+                                    span class="mono text-muted select-none" style="font-size: 0.55rem; position: absolute; left: 0; white-space: nowrap;" {
+                                        (&day.date[5..])
+                                    }
+                                }
+                            }
+                        }
+                    }
+                    // Spacer for labels
+                    div style="height: 14px;" {}
+                }
+            }
+
+            // Scan list table
+            @if scans.is_empty() {
+                div class="card-brutal-inset text-center" style="padding: 3rem;" {
+                    div class="text-6xl mb-6 text-muted" {
+                        i class="fa-solid fa-nfc-magnifying-glass" {}
+                    }
+                    h3 class="text-2xl font-black text-primary mb-3" { "NO SCANS" }
+                    p class="text-secondary mb-8 font-bold" {
+                        "NO SCANS RECORDED YET."
+                    }
+                }
+            } @else {
+                div class="card-brutal overflow-x-auto" {
+                    table class="w-full text-sm" style="border-collapse: collapse;" {
+                        thead {
+                            tr style="border-bottom: 3px solid var(--accent-muted);" {
+                                th class="text-left py-3 px-3 font-black text-primary" { "TIMESTAMP" }
+                                th class="text-left py-3 px-3 font-black text-primary" { "LOCATION" }
+                                th class="text-left py-3 px-3 font-black text-primary" { "SCANNER" }
+                                th class="text-right py-3 px-3 font-black text-primary" { "SATS" }
+                            }
+                        }
+                        tbody {
+                            @for scan in scans {
+                                tr style="border-bottom: 1px solid var(--accent-muted);" {
+                                    td class="py-2 px-3 mono text-secondary" style="white-space: nowrap;" {
+                                        (scan.scanned_at.format("%Y-%m-%dT%H:%M:%S").to_string())
+                                    }
+                                    td class="py-2 px-3" {
+                                        a href={"/locations/" (scan.location_id)} class="font-bold text-primary hover:text-highlight" {
+                                            (scan.location_name)
+                                        }
+                                        span class="text-xs text-muted ml-1" {
+                                            "by " (scan.creator_display_name())
+                                        }
+                                    }
+                                    td class="py-2 px-3 font-bold mono" {
+                                        (scan.scanner_display_name())
+                                    }
+                                    td class="py-2 px-3 text-right mono" {
+                                        @if scan.claimed_at.is_some() {
+                                            span class="text-highlight font-bold" {
+                                                (scan.sats_claimed())
+                                            }
+                                        } @else {
+                                            span class="text-muted" { "-" }
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+
+                // Pagination
+                @if total_pages > 1 {
+                    div class="flex justify-center items-center gap-2 mt-6" {
+                        @if current_page > 1 {
+                            a href={"/admin/scans?page=" (current_page - 1) "&days=" (days)} class="btn-brutal" {
+                                i class="fa-solid fa-chevron-left mr-1" {}
+                                "PREV"
+                            }
+                        }
+                        span class="px-4 py-2 font-bold mono text-secondary" {
+                            (current_page) " / " (total_pages)
+                        }
+                        @if current_page < total_pages {
+                            a href={"/admin/scans?page=" (current_page + 1) "&days=" (days)} class="btn-brutal" {
+                                "NEXT"
+                                i class="fa-solid fa-chevron-right ml-1" {}
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+}