Add result printer

Cargo.toml

@@ -15,12 +15,15 @@ dioxus-logger = "0.6.2"
 env_logger = "0.11.8"
 futures = "0.3.31"
 futures-util = "0.3.31"
+genpdf = "0.2.0"
 iconify = "0.3.1"
 log = "0.4.28"
 nom = "8.0.0"
+open = "3"
 reqwest = { version = "0.12.23", default-features = false, features = ["json", "rustls-tls"] }
 serde = { version = "1.0.225", features = ["derive"] }
 serde_json = "1.0.145"
+shellexpand = "2"
 tokio = "1.47.1"
 tokio-serial = "5.4.5"
 tokio-util = { version = "0.7.16", features = ["codec"] }

rustpolnak.toml.example

@@ -3,6 +3,8 @@ rfid_devices = [
     "stubs/dev/rfid1",
 ]
 
+results_path = "~/.rustpolnak/results.pdf"
+
 [api]
 url = "http://localhost:8000"
 username = "user"

src/components/app.rs

@@ -1,15 +1,18 @@
+use std::path::PathBuf;
+
 use chrono::{DateTime, Utc};
 use dioxus::prelude::*;
 use futures_util::StreamExt;
 use tokio::sync::broadcast;
-use tracing::info;
+use tracing::{info, trace};
 
 use crate::{
     components::{
         manual_start_number_input::ManualStartNumberInput, racers::Racers, races_list::RacesList,
         track_start::TrackStart, upload_results::UploadResults,
     },
     config::Config,
+    printer::print_result,
     race::{Race, StartNumber, Track},
     rfid_reader,
 };
@@ -65,6 +68,8 @@ pub fn App() -> Element {
     let mut selected_race = use_signal(|| SelectedRace::None);
     let config = use_context::<Config>();
     let mut show_starts = use_signal(|| true);
+    let results_output_path =
+        PathBuf::from(shellexpand::tilde(&config.results_path.clone()).to_string());
 
     use_coroutine(move |mut actions_rx: UnboundedReceiver<Action>| {
         let config = config.clone();
@@ -89,6 +94,12 @@ pub fn App() -> Element {
         }
     });
 
+    let race = selected_race
+        .read()
+        .as_ref()
+        .and_then(|r| r.as_ref().ok())
+        .cloned();
+
     rsx! {
         div { class: "d-flex flex-column", style: "height: 100vh",
             div { class: "d-flex column-gap-1 mb-1",
@@ -100,9 +111,23 @@ pub fn App() -> Element {
                     },
                 }
                 RacesList { selected_race }
-                match &*selected_race.read() {
-                    Some(Ok(race)) => rsx! {
+                match race {
+                    Some(race) => rsx! {
                         UploadResults { race: race.clone() }
+                        button {
+                            class: "btn btn-primary",
+                            onclick: move |_| {
+                                info!("Printing results for race {}", race.id);
+                                match print_result(&race, results_output_path.clone()) {
+                                    Ok(()) => {
+                                        info!("Print job completed successfully.");
+                                        open::that(&results_output_path).ok();
+                                    }
+                                    Err(e) => trace!("Print job failed: {}", e),
+                                }
+                            },
+                            dangerous_inner_html: iconify::svg!("mdi:printer"),
+                        }
                     },
                     _ => rsx! {},
                 }

src/components/racers.rs

@@ -19,7 +19,7 @@ fn format_time(datetime: Option<DateTime<Utc>>) -> String {
     }
 }
 
-fn format_time_delta(delta: Option<TimeDelta>) -> String {
+pub fn format_time_delta(delta: Option<TimeDelta>) -> String {
     let delta = match delta {
         Some(delta) => delta,
         _ => return "".to_string(),

src/config.rs

@@ -16,6 +16,7 @@ pub struct RestAPIConfig {
 pub struct Config {
     pub api: RestAPIConfig,
     pub rfid_devices: Vec<String>,
+    pub results_path: String,
 }
 
 pub fn app_dir() -> PathBuf {

src/main.rs

@@ -9,6 +9,7 @@ use crate::restclient::RaceRestAPI;
 
 mod components;
 mod config;
+mod printer;
 mod race;
 mod race_events;
 mod restclient;

src/printer.rs

@@ -0,0 +1,167 @@
+use crate::components::racers::format_time_delta;
+use crate::race::{Race, Racer};
+use std::path::PathBuf;
+use tracing::{error, info};
+
+use genpdf::Alignment;
+use genpdf::Document;
+use genpdf::Element as _;
+use genpdf::{elements, fonts, style};
+
+const FONT_DIR: &str = "./assets/fonts";
+const DEFAULT_FONT_NAME: &str = "DejaVuSansCondensed";
+
+pub fn print_result(race: &Race, output_file: PathBuf) -> Result<(), Box<dyn std::error::Error>> {
+    if !std::path::Path::new(FONT_DIR).exists() {
+        return Err(format!("Font directory {} not found", FONT_DIR).into());
+    }
+
+    let font_dir = FONT_DIR;
+    let default_font = fonts::from_files(font_dir, DEFAULT_FONT_NAME, None)
+        .expect("Failed to load the default font family");
+
+    let mut doc = genpdf::Document::new(default_font);
+    doc.set_title("Race results");
+
+    let mut decorator = genpdf::SimplePageDecorator::new();
+    decorator.set_margins(10);
+    doc.set_page_decorator(decorator);
+
+    print_heading(&mut doc, "Race results");
+    print_tracks(&mut doc, race);
+    print_categories(&mut doc, race);
+
+    match doc.render_to_file(&output_file) {
+        Ok(()) => {
+            info!("Successfully wrote output file: {}", &output_file.display());
+            Ok(())
+        }
+        Err(e) => {
+            error!("Failed to write output file: {}", e);
+            Err(Box::<dyn std::error::Error>::from(e))
+        }
+    }
+}
+
+fn print_heading(doc: &mut Document, text: &str) {
+    let mut heading = elements::Paragraph::new(text);
+    heading.set_alignment(Alignment::Center);
+    heading.clone().styled(style::Effect::Bold);
+    doc.push(heading);
+    doc.push(elements::Break::new(1));
+}
+
+fn print_table_header(table: &mut elements::TableLayout) {
+    table.set_cell_decorator(elements::FrameCellDecorator::new(true, true, false));
+    table
+        .row()
+        .element(
+            elements::Paragraph::new("Start number")
+                .styled(style::Effect::Bold)
+                .padded(1),
+        )
+        .element(
+            elements::Paragraph::new("First name")
+                .styled(style::Effect::Bold)
+                .padded(1),
+        )
+        .element(
+            elements::Paragraph::new("Last name")
+                .styled(style::Effect::Bold)
+                .padded(1),
+        )
+        .element(
+            elements::Paragraph::new("Time")
+                .styled(style::Effect::Bold)
+                .padded(1),
+        )
+        .element(
+            elements::Paragraph::new("Rank")
+                .styled(style::Effect::Bold)
+                .padded(1),
+        )
+        .push()
+        .expect("Invalid table row");
+}
+
+fn print_tracks(doc: &mut Document, race: &Race) {
+    for track in &race.tracks {
+        let mut finished: Vec<&Racer> = race
+            .racers
+            .iter()
+            .filter(|r| r.track == *track)
+            .filter(|r| r.finish.is_some())
+            .collect();
+
+        if finished.is_empty() {
+            continue;
+        }
+
+        finished.sort_by(|a, b| a.track_rank.cmp(&b.track_rank));
+
+        doc.push(elements::PageBreak::new());
+
+        let mut table = elements::TableLayout::new(vec![1, 2, 2, 2, 1]);
+
+        print_heading(doc, format!("Track: {}", track.0).as_str());
+        print_table_header(&mut table);
+
+        for racer in finished {
+            table
+                .row()
+                .element(elements::Paragraph::new(format!("{}", racer.start_number)).padded(1))
+                .element(elements::Paragraph::new(&racer.first_name).padded(1))
+                .element(elements::Paragraph::new(&racer.last_name).padded(1))
+                .element(elements::Paragraph::new(format_time_delta(racer.time)).padded(1))
+                .element(
+                    elements::Paragraph::new(format!("{}", racer.track_rank.unwrap_or_default()))
+                        .padded(1),
+                )
+                .push()
+                .expect("Invalid table row");
+        }
+
+        doc.push(table);
+    }
+}
+
+fn print_categories(doc: &mut Document, race: &Race) {
+    for category in &race.categories {
+        let mut finished: Vec<&Racer> = race
+            .racers
+            .iter()
+            .filter(|r| r.categories.contains(category))
+            .filter(|r| r.finish.is_some())
+            .collect();
+
+        if finished.is_empty() {
+            continue;
+        }
+
+        finished.sort_by(|a, b| a.categories_rank[category].cmp(&b.categories_rank[category]));
+
+        doc.push(elements::PageBreak::new());
+
+        let mut table = elements::TableLayout::new(vec![1, 2, 2, 2, 1]);
+
+        print_heading(doc, format!("Category: {}", category.0).as_str());
+        print_table_header(&mut table);
+
+        for racer in finished {
+            table
+                .row()
+                .element(elements::Paragraph::new(format!("{}", racer.start_number)).padded(1))
+                .element(elements::Paragraph::new(&racer.first_name).padded(1))
+                .element(elements::Paragraph::new(&racer.last_name).padded(1))
+                .element(elements::Paragraph::new(format_time_delta(racer.time)).padded(1))
+                .element(
+                    elements::Paragraph::new(format!("{}", racer.categories_rank[category]))
+                        .padded(1),
+                )
+                .push()
+                .expect("Invalid table row");
+        }
+
+        doc.push(table);
+    }
+}