feat: add donation wall page with photos

Adds a "Donation Wall" page (reachable from a new Main page card) that
lists recent donations with their photo, falling back to the Guy
Fawkes icon for anonymous donations or when no photo is available.
Tapping a thumbnail toggles a fullscreen view of the same picture.

Donations are now recorded in a new donation_log SQLite table
(timestamp, username, amount, fund) whenever a donation succeeds, on
both the manual "Done" and inactivity auto-approve paths. The photo
filename is now deterministic (camera::photo_filename) so the wall
can re-associate a logged donation with its saved photo without a
separate DB column.

Author: eupn

src/camera.rs

@@ -7,16 +7,36 @@ use nokhwa::utils::{
 use std::path::PathBuf;
 use std::sync::mpsc::{Receiver, SyncSender, TryRecvError};
 use std::thread;
-use std::time::{Duration, Instant, SystemTime, UNIX_EPOCH};
+use std::time::{Duration, Instant};
+
+/// Deterministic filename for a donation photo. Shared with `donation_log` so
+/// a logged donation (timestamp, username) can be re-associated with the
+/// photo file that `capture_donation_photo` saved for it, without needing to
+/// store the path separately.
+pub fn photo_filename(timestamp: u64, username: &str) -> String {
+    let safe_username: String = username
+        .chars()
+        .map(|c| {
+            if c.is_ascii_alphanumeric() || c == '_' || c == '-' {
+                c
+            } else {
+                '_'
+            }
+        })
+        .collect();
+    format!("{timestamp}_{safe_username}.jpg")
+}
 
 /// Captures a single frame from the default webcam and saves it as a JPEG
 /// under `photos_dir`, running on a dedicated thread so it never blocks the UI.
-pub fn capture_donation_photo(photos_dir: &str, username: &str) {
+/// `timestamp` is supplied by the caller (rather than generated here) so it
+/// can match the timestamp recorded in the donation log.
+pub fn capture_donation_photo(photos_dir: &str, username: &str, timestamp: u64) {
     let photos_dir = photos_dir.to_string();
     let username = username.to_string();
 
     thread::spawn(move || {
-        if let Err(e) = capture_and_save(&photos_dir, &username) {
+        if let Err(e) = capture_and_save(&photos_dir, &username, timestamp) {
             error!("📷 Failed to take donation photo: {}", e);
         }
     });
@@ -56,7 +76,7 @@ fn open_preview_camera() -> Result<Camera, String> {
     open_camera()
 }
 
-fn capture_and_save(photos_dir: &str, username: &str) -> Result<(), String> {
+fn capture_and_save(photos_dir: &str, username: &str, timestamp: u64) -> Result<(), String> {
     let mut camera = open_camera()?;
 
     // Discard the first couple of frames to let auto-exposure/white-balance settle.
@@ -74,21 +94,7 @@ fn capture_and_save(photos_dir: &str, username: &str) -> Result<(), String> {
     std::fs::create_dir_all(photos_dir)
         .map_err(|e| format!("failed to create photos directory {photos_dir}: {e}"))?;
 
-    let timestamp = SystemTime::now()
-        .duration_since(UNIX_EPOCH)
-        .map(|d| d.as_secs())
-        .unwrap_or(0);
-    let safe_username: String = username
-        .chars()
-        .map(|c| {
-            if c.is_ascii_alphanumeric() || c == '_' || c == '-' {
-                c
-            } else {
-                '_'
-            }
-        })
-        .collect();
-    let path = PathBuf::from(photos_dir).join(format!("{timestamp}_{safe_username}.jpg"));
+    let path = PathBuf::from(photos_dir).join(photo_filename(timestamp, username));
 
     image
         .save(&path)

src/donation_log.rs

@@ -0,0 +1,79 @@
+use log::error;
+use rusqlite::{Connection, Result as SqlResult, params};
+use std::thread;
+use std::time::{SystemTime, UNIX_EPOCH};
+
+/// A single completed donation, as shown on the donation wall.
+#[derive(Debug, Clone)]
+pub struct DonationLogEntry {
+    pub timestamp: u64,
+    pub username: String,
+    pub amount: i32,
+    pub fund_name: String,
+}
+
+fn init_db(db: &Connection) -> SqlResult<()> {
+    db.execute(
+        "CREATE TABLE IF NOT EXISTS donation_log (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            timestamp INTEGER NOT NULL,
+            username TEXT NOT NULL,
+            amount INTEGER NOT NULL,
+            fund_name TEXT NOT NULL
+        )",
+        [],
+    )?;
+    Ok(())
+}
+
+/// Current unix timestamp, shared between a donation's log row and its photo
+/// filename (see `camera::photo_filename`) so the two can be re-associated.
+pub fn now_timestamp() -> u64 {
+    SystemTime::now()
+        .duration_since(UNIX_EPOCH)
+        .map(|d| d.as_secs())
+        .unwrap_or(0)
+}
+
+/// Records a completed donation, running on a dedicated thread so it never
+/// blocks the donation flow. Best-effort: a DB hiccup is logged and dropped.
+pub fn record(db_path: &str, timestamp: u64, username: &str, amount: i32, fund_name: &str) {
+    let db_path = db_path.to_string();
+    let username = username.to_string();
+    let fund_name = fund_name.to_string();
+
+    thread::spawn(move || {
+        let result = (|| -> SqlResult<()> {
+            let db = Connection::open(&db_path)?;
+            init_db(&db)?;
+            db.execute(
+                "INSERT INTO donation_log (timestamp, username, amount, fund_name) VALUES (?1, ?2, ?3, ?4)",
+                params![timestamp as i64, username, amount, fund_name],
+            )?;
+            Ok(())
+        })();
+
+        if let Err(e) = result {
+            error!("Failed to record donation log entry: {}", e);
+        }
+    });
+}
+
+/// Fetches the most recent donations, newest first. Blocking — call off the UI thread.
+pub fn fetch_recent(db_path: &str, limit: i64) -> SqlResult<Vec<DonationLogEntry>> {
+    let db = Connection::open(db_path)?;
+    init_db(&db)?;
+
+    let mut stmt = db.prepare(
+        "SELECT timestamp, username, amount, fund_name FROM donation_log ORDER BY timestamp DESC LIMIT ?1",
+    )?;
+    let rows = stmt.query_map([limit], |row| {
+        Ok(DonationLogEntry {
+            timestamp: row.get::<_, i64>(0)? as u64,
+            username: row.get(1)?,
+            amount: row.get(2)?,
+            fund_name: row.get(3)?,
+        })
+    })?;
+    rows.collect()
+}

src/main.rs

@@ -9,6 +9,7 @@ mod cctalk;
 mod config;
 mod diag_logger;
 mod donation;
+mod donation_log;
 mod error;
 mod funds;
 mod home_assistant;
@@ -69,6 +70,7 @@ pub fn main() {
     donation_handler::init(&main_window, &config, cashcode_tx, cctalk_tx);
     home_assistant_handler::init(&main_window, &config);
     game_handler::init(&main_window, &config);
+    logs_handler::init(&main_window, &config);
 
     main_window.run().unwrap();
 }
@@ -599,6 +601,7 @@ mod donation_handler {
         cashcode_tx: Sender<bill_acceptor::CashCodeCommand>,
         token: Option<String>,
         photos_dir: String,
+        stats_db_path: String,
     ) -> slint::Timer {
         let timer = slint::Timer::default();
         timer.start(
@@ -638,18 +641,32 @@ mod donation_handler {
                         if let Some(ref tok) = token {
                             let username = window.get_session_username().to_string();
                             let fund_id = window.get_session_fund_id();
+                            let fund_name = window.get_session_fund_name().to_string();
                             let tok = tok.clone();
                             let photos_dir = photos_dir.clone();
+                            let stats_db_path = stats_db_path.clone();
                             slint::spawn_local(async move {
                                 match donation::send_donation(&tok, fund_id, &username, amount)
                                     .await
                                 {
                                     Ok(_) => {
                                         sound::play_yippee();
                                         info!("✅ Auto-approved donation sent successfully!");
+                                        let timestamp = donation_log::now_timestamp();
                                         if username != "anon" {
-                                            camera::capture_donation_photo(&photos_dir, &username);
+                                            camera::capture_donation_photo(
+                                                &photos_dir,
+                                                &username,
+                                                timestamp,
+                                            );
                                         }
+                                        donation_log::record(
+                                            &stats_db_path,
+                                            timestamp,
+                                            &username,
+                                            amount,
+                                            &fund_name,
+                                        );
                                     }
                                     Err(e) => {
                                         error!("❌ Auto-approve: failed to send donation: {}", e)
@@ -687,6 +704,8 @@ mod donation_handler {
             let cctalk_tx = cctalk_tx.clone();
             let token = config.token.clone();
             let photos_dir = config.photos_dir.clone();
+            let stats_db_path = config.stats_db_path.clone();
+            let weak = app.as_weak();
             move |username, fund_id, amount| {
                 info!(
                     "💰 Processing donation: {} AMD from {} to fund {}",
@@ -711,15 +730,32 @@ mod donation_handler {
                     let token = token.clone();
                     let username_str = username.to_string();
                     let photos_dir = photos_dir.clone();
+                    let stats_db_path = stats_db_path.clone();
+                    let fund_name = weak
+                        .upgrade()
+                        .map(|w| w.get_session_fund_name().to_string())
+                        .unwrap_or_default();
                     slint::spawn_local(async move {
                         match donation::send_donation(&token, fund_id, &username_str, amount).await
                         {
                             Ok(_) => {
                                 sound::play_yippee();
                                 info!("✅ Donation sent successfully!");
+                                let timestamp = donation_log::now_timestamp();
                                 if username_str != "anon" {
-                                    camera::capture_donation_photo(&photos_dir, &username_str);
+                                    camera::capture_donation_photo(
+                                        &photos_dir,
+                                        &username_str,
+                                        timestamp,
+                                    );
                                 }
+                                donation_log::record(
+                                    &stats_db_path,
+                                    timestamp,
+                                    &username_str,
+                                    amount,
+                                    &fund_name,
+                                );
                             }
                             Err(e) => error!("❌ Failed to send donation: {}", e),
                         }
@@ -736,6 +772,7 @@ mod donation_handler {
         let cashcode_tx_enter = cashcode_tx.clone();
         let token_enter = config.token.clone();
         let photos_dir_enter = config.photos_dir.clone();
+        let stats_db_path_enter = config.stats_db_path.clone();
         let timer_enter = inactivity_timer.clone();
         let ticker_enter = countdown_ticker.clone();
         app.on_enter_insert_money(move || {
@@ -753,6 +790,7 @@ mod donation_handler {
                 cashcode_tx_enter.clone(),
                 token_enter.clone(),
                 photos_dir_enter.clone(),
+                stats_db_path_enter.clone(),
             );
             *timer_enter.borrow_mut() = Some(timer);
             // Countdown ticker (1-second decrement)
@@ -778,6 +816,7 @@ mod donation_handler {
         let cashcode_tx_activity = cashcode_tx.clone();
         let token_activity = config.token.clone();
         let photos_dir_activity = config.photos_dir.clone();
+        let stats_db_path_activity = config.stats_db_path.clone();
         let timer_activity = inactivity_timer.clone();
         let ticker_activity = countdown_ticker.clone();
         app.on_activity_on_insert_money(move || {
@@ -792,6 +831,7 @@ mod donation_handler {
                 cashcode_tx_activity.clone(),
                 token_activity.clone(),
                 photos_dir_activity.clone(),
+                stats_db_path_activity.clone(),
             );
             *timer_activity.borrow_mut() = Some(timer);
             // Replace countdown ticker
@@ -867,6 +907,82 @@ mod donation_handler {
     }
 }
 
+mod logs_handler {
+    use super::*;
+    use slint::{Image, ModelRc, VecModel};
+
+    /// How many past donations to show on the wall. Each entry with a photo
+    /// loads that photo into memory at full resolution, so this is kept modest.
+    const LOG_LIMIT: i64 = 24;
+
+    fn format_relative_time(timestamp: u64) -> String {
+        let diff = donation_log::now_timestamp().saturating_sub(timestamp);
+        if diff < 60 {
+            "just now".to_string()
+        } else if diff < 3600 {
+            format!("{}m ago", diff / 60)
+        } else if diff < 86400 {
+            format!("{}h ago", diff / 3600)
+        } else {
+            format!("{}d ago", diff / 86400)
+        }
+    }
+
+    pub fn init(app: &MainWindow, config: &Config) {
+        let stats_db_path = config.stats_db_path.clone();
+        let photos_dir = config.photos_dir.clone();
+        let weak = app.as_weak();
+
+        app.on_fetch_logs(move || {
+            let stats_db_path = stats_db_path.clone();
+            let photos_dir = photos_dir.clone();
+            let weak = weak.clone();
+
+            thread::spawn(move || {
+                // The DB read is the slow part, so it happens off the UI thread.
+                // `slint::Image` isn't `Send`, though, so it can't be built here —
+                // loading each photo has to happen after we hop back to the UI thread.
+                let entries = match donation_log::fetch_recent(&stats_db_path, LOG_LIMIT) {
+                    Ok(entries) => entries,
+                    Err(e) => {
+                        error!("Failed to fetch donation log: {}", e);
+                        Vec::new()
+                    }
+                };
+
+                let _ = slint::invoke_from_event_loop(move || {
+                    let Some(window) = weak.upgrade() else {
+                        return;
+                    };
+                    let items: Vec<DonationLogItem> = entries
+                        .into_iter()
+                        .map(|entry| {
+                            let is_anon = entry.username == "anon";
+                            let photo = if is_anon {
+                                None
+                            } else {
+                                let path = std::path::Path::new(&photos_dir)
+                                    .join(camera::photo_filename(entry.timestamp, &entry.username));
+                                Image::load_from_path(&path).ok()
+                            };
+                            DonationLogItem {
+                                username: entry.username.into(),
+                                amount: entry.amount,
+                                fund_name: entry.fund_name.into(),
+                                when: format_relative_time(entry.timestamp).into(),
+                                is_anon,
+                                has_photo: photo.is_some(),
+                                photo: photo.unwrap_or_default(),
+                            }
+                        })
+                        .collect();
+                    window.set_donation_logs(ModelRc::new(VecModel::from(items)));
+                });
+            });
+        });
+    }
+}
+
 mod diagnostics_handler {
     use super::*;
     use slint::{ModelRc, Timer, TimerMode, VecModel};