offline DB

POC_in_rust/.gitignore

@@ -0,0 +1 @@
+target

POC_in_rust/Cargo.toml

@@ -0,0 +1,21 @@
+[package]
+name = "POC_in_rust"
+version = "0.1.0"
+edition = "2024"
+
+[profile.release]
+opt-level="s"
+lto="fat"
+
+[dependencies]
+async-tungstenite = {version="0.29.1", features=["tokio-rustls-webpki-roots"]}
+chrono = "0.4.41"
+env_logger = "0.11.8"
+iced = {"git"= "https://github.com/iced-rs/iced.git", "features"=["tokio", "auto-detect-theme", "fira-sans", "tiny-skia", "sipper"]}
+lazy_static = "1.5.0"
+nusb = "0.1.13"
+reqwest = { version = "0.12.15", features = ["json"] }
+rustls = {version = "0.23.27", features = ["std", "prefer-post-quantum", "tls12", "logging"]}
+serde = {version = "1.0.219", features=["derive"]}
+serde_json = "1.0.140"
+tokio = {version = "1.45.0", features=["time", "fs", "io-util", "macros"]}

POC_in_rust/config.json

@@ -0,0 +1,5 @@
+{
+    "DURATION": 600,
+    "STATION_ID": 2,
+    "HOST": "https://beta.alkator.cz"
+}

POC_in_rust/people.json

@@ -0,0 +1,102 @@
+{
+    "1": 1114418469,
+    "2": 1111554085,
+    "3": 1112605381,
+    "4": 1362080126,
+    "5": 1632101230,
+    "6": 1114533941,
+    "7": 1364901054,
+    "8": 1364587710,
+    "9": 1364867822,
+    "10": 1364554558,
+    "11": 1364968750,
+    "12": 1111614357,
+    "13": 1362569198,
+    "14": 1364867662,
+    "15": 1112618821,
+    "16": 1364967150,
+    "17": 1364592718,
+    "18": 1364487310,
+    "19": 458336708,
+    "20": 1111590293,
+    "21": 1114448773,
+    "22": 1364550814,
+    "23": 1112421509,
+    "24": 1364529422,
+    "25": 1364916590,
+    "26": 455988804,
+    "27": 1631963022,
+    "28": 1114508533,
+    "29": 1364590606,
+    "30": 1364796894,
+    "31": 1112489029,
+    "32": 1114588261,
+    "33": 1111733589,
+    "34": 1112469509,
+    "35": 1632521678,
+    "36": 1631957710,
+    "37": 1111682853,
+    "38": 1111882197,
+    "39": 1631960974,
+    "40": 1362260606,
+    "41": 1364521806,
+    "42": 1364489406,
+    "43": 1361969902,
+    "44": 1364581838,
+    "45": 1364520526,
+    "46": 1361806574,
+    "47": 1364581310,
+    "48": 1364551150,
+    "49": 1364916158,
+    "50": 1364529662,
+    "51": 1632026766,
+    "52": 1364588798,
+    "53": 1631955550,
+    "54": 1631972606,
+    "55": 1364797086,
+    "56": 1364627198,
+    "57": 1364556446,
+    "58": 1632070414,
+    "59": 1631951758,
+    "60": 1364794654,
+    "61": 1632101166,
+    "62": 1361810574,
+    "63": 1114573589,
+    "64": 1361967886,
+    "65": 1632544222,
+    "66": 1111582085,
+    "67": 1362569438,
+    "68": 1364593198,
+    "69": 1364761406,
+    "70": 1631927918,
+    "71": 1364544414,
+    "72": 1362264958,
+    "73": 1364767006,
+    "74": 1364590110,
+    "75": 1362082334,
+    "76": 1364799166,
+    "77": 1632028398,
+    "78": 1361970078,
+    "79": 1364485118,
+    "80": 1364490846,
+    "81": 1632150846,
+    "82": 1362569342,
+    "83": 1362599998,
+    "84": 1632523854,
+    "85": 1364765134,
+    "86": 1631952062,
+    "87": 1364559822,
+    "88": 1364783854,
+    "89": 1362081950,
+    "90": 1111644021,
+    "91": 1631959326,
+    "92": 1364901422,
+    "93": 1632100830,
+    "94": 1111707429,
+    "95": 1632026702,
+    "96": 1362569022,
+    "97": 1114560181,
+    "98": 1364588510,
+    "99": 1364785486,
+    "100": 1361969950
+}

POC_in_rust/src/approx_time.rs

@@ -0,0 +1,25 @@
+
+use std::time::{Instant, SystemTime};
+use serde::{Serialize, Serializer, Deserialize, Deserializer, de::Error};
+
+pub fn serialize<S>(instant: &Instant, serializer: S) -> Result<S::Ok, S::Error>
+where
+    S: Serializer,
+{
+    let system_now = SystemTime::now();
+    let instant_now = Instant::now();
+    let approx = system_now - (instant_now - *instant);
+    approx.serialize(serializer)
+}
+
+pub fn deserialize<'de, D>(deserializer: D) -> Result<Instant, D::Error>
+where
+    D: Deserializer<'de>,
+{
+    let de = SystemTime::deserialize(deserializer)?;
+    let system_now = SystemTime::now();
+    let instant_now = Instant::now();
+    let duration = system_now.duration_since(de).map_err(Error::custom)?;
+    let approx = instant_now - duration;
+    Ok(approx)
+}

POC_in_rust/src/card_reader.rs

@@ -0,0 +1,66 @@
+use iced::task::{Never, Sipper, sipper};
+use tokio::time::sleep;
+use std::time::Duration;
+
+use nusb::{transfer::{ RequestBuffer, TransferError }, Interface};
+
+static USB_VENDOR: u16  = 0xffff;
+static USB_PRODUCT: u16 = 0x0035;
+
+
+fn get_interface() -> Option<Interface> {
+    let dev = nusb::list_devices().ok()?.find(|dev| dev.vendor_id() == USB_VENDOR && dev.product_id() == USB_PRODUCT)?;
+    let device = dev.open().ok()?;
+    device.detach_and_claim_interface(0).ok()
+}
+
+
+pub fn connect() -> impl Sipper<Never, Event> {
+    sipper(async |mut output|{
+        loop {
+            let interface = loop {
+                if let Some(interface) = get_interface(){
+                    break interface;
+                }
+                sleep(Duration::new(0, 100)).await;
+            };
+            output.send(Event::Connected).await;
+            let mut card_id = 0;
+            loop {
+                let buf = RequestBuffer::new(8);
+                let data = interface.interrupt_in(0x81, buf).await;
+                match data.status {
+                    Err(TransferError::Disconnected) => {
+                        output.send(Event::Disconnected).await;
+                        break;
+                    },
+                    Ok(()) => {
+                        let code = data.data[2];
+                        match code {
+                            40 => {
+                                output.send(Event::ReadedCardId(card_id)).await;
+                                card_id = 0;
+                            },
+                            0 => (),
+                            x @ 30..=38 => {
+                                card_id *= 10;
+                                card_id += x as usize - 29;
+                            },
+                            39 => {
+                                card_id *= 10;
+                            },
+                            _ => panic!(),
+                        }
+                    },
+                    _ => todo!(),
+                }
+            }
+        }
+    })
+}
+
+pub enum Event{
+    Disconnected,
+    Connected,
+    ReadedCardId(usize),
+}

POC_in_rust/src/config.rs

@@ -0,0 +1,30 @@
+use std::fs::File;
+use std::io::BufReader;
+use std::error::Error;
+use std::path::Path;
+use serde::{Deserialize};
+use lazy_static::lazy_static;
+
+#[allow(non_snake_case)]
+#[derive(Deserialize)]
+pub struct Config {
+    pub DURATION: u64,
+    pub STATION_ID: usize,
+    pub HOST: String,
+}
+
+fn read_config_from_file<P: AsRef<Path>>(path: P) -> Result<Config, Box<dyn Error>> {
+    // Open the file in read-only mode with buffer.
+    let file = File::open(path)?;
+    let reader = BufReader::new(file);
+
+    // Read the JSON contents of the file as an instance of `User`.
+    let config = serde_json::from_reader(reader)?;
+
+    // Return the `User`.
+    Ok(config)
+}
+
+lazy_static! {
+    pub static ref CONFIG: Config = read_config_from_file("config.json").unwrap();
+}

POC_in_rust/src/main.rs

@@ -0,0 +1,205 @@
+use iced::time::{self, Duration, Instant, milliseconds};
+use std::collections::HashMap;
+use std::fmt::{Formatter, Error as fmtError};
+use serde::{Deserialize, Serialize};
+use iced::widget::{center, column, row, text};
+use iced::{Element, Subscription, Theme, Center, Task};
+use tokio::fs::File;
+use tokio::io::AsyncWriteExt;
+use std::fs::read_to_string;
+use reqwest::Client;
+use chrono::{DateTime, Local};
+use iced::futures::join;
+use lazy_static::lazy_static;
+use std::io::BufReader;
+use std::error::Error;
+use std::fs::File as stdFile;
+use std::path::Path;
+
+mod card_reader;
+mod approx_time;
+mod config;
+use config::CONFIG;
+
+
+#[derive(Serialize, Deserialize)]
+struct RacerTime{
+    #[serde(with = "approx_time")]
+    time: Instant,
+    racer: usize,
+}
+
+fn invert_hashmap<K, V>(map: HashMap<K, V>) -> HashMap<V, K>
+where
+    K: Eq + std::hash::Hash,
+    V: Eq + std::hash::Hash,
+{
+    map.into_iter().map(|(k, v)| (v, k)).collect()
+}
+
+fn read_db_from_file<P: AsRef<Path>>(path: P) -> Result<HashMap<usize, usize>, Box<dyn Error>> {
+    // Open the file in read-only mode with buffer.
+    let file = stdFile::open(path)?;
+    let reader = BufReader::new(file);
+
+    // Read the JSON contents of the file as an instance of `User`.
+    let db = serde_json::from_reader(reader)?;
+
+    // Return the `User`.
+    Ok(db)
+}
+
+lazy_static!{
+    // invert it so it is db[card_id] = starting number
+    pub static ref DB: HashMap<usize, usize> = invert_hashmap(read_db_from_file("people.json").unwrap());
+}
+
+#[derive(Serialize, Deserialize)]
+struct State{
+    racers: Vec<RacerTime>,
+    #[serde(with = "approx_time")]
+    time: Instant,
+}
+
+impl Default for State {
+    fn default() -> Self {
+        Self {
+            racers: vec![],
+            time: Instant::now(),
+        }
+    }
+}
+
+async fn dump_state(json: String) -> Result<(), tokio::io::Error> {
+    let mut file = File::create("state.json").await?;
+    file.write_all(json.as_bytes()).await?;
+    Ok(())
+}
+
+#[derive(Serialize)]
+struct RegisterRacer{
+    starting_number: usize,
+    time: String,
+    station_id: usize,
+}
+
+enum Message{
+    CardReader(card_reader::Event),
+    Tick(Instant),
+    Nothing,
+}
+
+impl std::fmt::Debug for Message {
+    // Required method
+    fn fmt(&self, _f: &mut Formatter<'_>) -> Result<(), fmtError>{
+        todo!()
+    }
+}
+
+async fn station_register(starting_number: usize, time: DateTime::<Local>) -> Result<(), reqwest::Error>{
+    let register_racer = RegisterRacer{
+        starting_number: starting_number,
+        station_id: CONFIG.STATION_ID,
+        time: format!("{}", time.format("%d.%m.%Y %H:%M:%S.%6f")),
+    };
+    Client::new()
+        .post(CONFIG.HOST.clone() + "/api/station/register")
+        .json(&register_racer)
+        .send()
+        .await?;
+    // Result can be error (400 and so on), whatever for now
+    Ok(())
+}
+
+async fn register_and_dump(card_id: usize, datetime: DateTime<Local>, json: String) -> (Result<(), tokio::io::Error>, Result<(), reqwest::Error>){
+    return join!(dump_state(json), station_register(card_id, datetime))
+}
+
+impl State{
+    fn update(&mut self, message: Message) -> Task<Message>{
+        match message {
+            Message::Tick(time) => {
+                self.time = time;
+                Task::none()
+            },
+            Message::Nothing => Task::none(),
+            Message::CardReader(card_reader::Event::ReadedCardId(card_id)) => {
+                let time = Instant::now();
+                let datetime = Local::now();
+                if let Some(&racer_starting_number) = DB.get(&card_id){
+                    let racer_time = RacerTime{time, racer: racer_starting_number};
+                    self.racers.push(racer_time);
+                } else {
+                    println!("Racer {} not found in db!", card_id)
+                }
+                let json = serde_json::to_string(self).unwrap();
+                Task::perform(register_and_dump(card_id, datetime, json), |_| Message::Nothing)
+            },
+            Message::CardReader(card_reader::Event::Connected) => {
+                println!("Card Reader Connected!");
+                Task::none()
+            },
+            Message::CardReader(card_reader::Event::Disconnected) => {
+                println!("Card Reader Disconnected!");
+                Task::none()
+            },
+        }
+    }
+    fn view(&self) -> Element<Message> {
+        let mut content = column![
+            row![
+                text("Číslo závodníka").width(120).align_x(Center).align_y(Center), text("čas").size(20).width(120).align_x(Center).align_y(Center)
+            ],
+        ];
+        for racer_time in &self.racers {
+            const MINUTE: u64 = 60;
+
+
+            let time = self.time - racer_time.time;
+            let duration = Duration::new(CONFIG.DURATION, 0);
+            let (duration, negative) = if duration < time {
+                (time - duration, true)
+            } else {
+                (duration - time, false)
+            };
+            let seconds = duration.as_secs();
+
+            if negative && seconds >= 10 {
+                continue
+            }
+
+            let duration = text!(
+                "{}{:0>2}:{:0>2}.{:0>2}",
+                if negative {"-"} else {""},
+                seconds / MINUTE,
+                seconds % MINUTE,
+                duration.subsec_millis() / 10,
+            ).size(20).width(120).align_x(Center).align_y(Center);
+            content = content.push(
+                row![
+                    text(racer_time.racer.to_string()).size(20).width(120).align_x(Center).align_y(Center), duration
+                ]
+            );
+        }
+        center(content).into()
+    }
+    fn subscription(&self) -> Subscription<Message> {
+        Subscription::batch(vec![
+            time::every(milliseconds(10)).map(Message::Tick),
+            Subscription::run(card_reader::connect).map(Message::CardReader),
+        ])
+    }
+    fn theme(&self) -> Theme {
+        Theme::Dark
+    }
+}
+
+pub fn main() -> iced::Result {
+    let init_state = || -> State {read_to_string("state.json").ok().map(|s| serde_json::from_str(&s).ok()).flatten().unwrap_or_else(||Default::default())}  ;
+    env_logger::init();
+    rustls::crypto::aws_lc_rs::default_provider().install_default().unwrap();
+    iced::application(init_state, State::update, State::view)
+        .subscription(State::subscription)
+        .theme(State::theme)
+        .run()
+}

config.json

@@ -0,0 +1,7 @@
+{
+    "station_id": 2,
+    "host": "https://beta.alkator.cz",
+    "login": "station_register@alkator.cz",
+    "password": "password_heslo",
+    "countdown_seconds": 60
+}

log.json

@@ -0,0 +1 @@
+[{"url": "https://beta.alkator.cz/api/card/register", "json": {"racer_id": 60, "starting_number": 2, "card_id": 1364550814, "time": "10.05.2025 17:40:13.486403"}}, {"url": "https://beta.alkator.cz/api/station/register", "json": {"card_id": 1364550814, "time": "10.05.2025 17:42:45.425016", "station_id": 1}}]

main.py

@@ -0,0 +1,205 @@
+import gi
+import threading
+import time
+import datetime
+import requests
+import json
+
+gi.require_version('Gtk', '4.0')
+from queue import Queue
+from gi.repository import Gtk, Gio, Gdk, GLib
+from requests.adapters import HTTPAdapter, Retry
+from usbcardreader import UsbCardReader
+
+
+with open('config.json', 'r') as f:
+    config = json.load(f)
+
+
+activeCards = []
+
+TIME = config['countdown_seconds']
+
+db = {}
+
+queue_to_send = []
+
+
+session = requests.Session()
+
+
+retries = Retry(total=10,
+                backoff_factor=1,
+                status_forcelist=[ 500, 502, 503, 504 ])
+
+session.mount('https://', HTTPAdapter(max_retries=retries))
+
+
+session.post(config['host'] + '/api/login', {'email':config['login'], 'password': config['password']})
+
+def refreshDb():
+    global db
+    resp = session.get(config['host'] + '/api/racers')
+    if resp.status_code == 200:
+        json = resp.json()
+        db = {}
+        for racer in json:
+            if racer["card_id"]:
+                db[racer["card_id"]] = racer
+
+
+def refreshDbEvery3mins():
+    while True:
+        refreshDb()
+        time.sleep(3 * 60)
+
+
+threading.Thread(target=refreshDbEvery3mins).start()
+
+log = []
+
+
+with open('log.json', 'r') as f:
+    log = json.loads(f.read())
+
+
+queue = Queue()
+
+
+def worker():
+    while True:
+        item = queue.get()
+        log.append(item)
+        with open('log.json', 'w') as f:
+            f.write(json.dumps(log))
+        response = session.post(item['url'], json=item['json'])
+        print(item, response)
+
+
+threading.Thread(target=worker).start()
+
+
+def callbackOnCard(card_id):
+    global win, activeCards, db
+    if card_id not in db:
+        refreshDb()
+    if card_id in db:
+        if card_id not in activeCards:
+            activeCards.append(card_id)
+            GLib.idle_add(win.arb, db[card_id])
+            print('Card is active now')
+        else:
+            print('Card is already active')
+    else:
+        print(f'Card {card_id} not found in db')
+
+
+class GridRow():
+    def __init__(self, parent, racer, index):
+        global queue_to_send
+        self.id = racer['starting_number']
+        self.parent = parent
+
+        self.grid = Gtk.Grid()
+
+        if index % 2 == 0:
+            self.grid.set_name("lightgrid")
+        else:
+            self.grid.set_name("darkgrid")
+
+        self.runid = Gtk.Label(label=str(racer["starting_number"]), name="gridlabel")
+        self.runid.set_justify(2)
+        self.runid.set_width_chars(10)
+
+        self.runb = Gtk.Label(label='00:00', name="gridlabel")
+        self.runb.set_hexpand(1)
+
+        self.grid.attach(self.runid, 0, 0, 1, 1)
+        self.grid.attach(self.runb, 1, 0, 1, 1)
+
+        parent.grid.attach(self.grid, 0, index, 2, 1)
+
+        countdown=threading.Thread(target=self.updateTime)
+        countdown.start()
+
+        queue.put({'url': config['host'] + '/api/station/register', 'json': {
+            'card_id': racer['card_id'],
+            'station_id': config['station_id'],
+            'time': datetime.datetime.now().strftime('%d.%m.%Y %H:%M:%S.%f')
+        }})
+
+    def printIndex(self, button):
+        print(self.index)
+
+    def updateTime(self):
+        t = TIME
+        while t >= -10:
+            if t < 0:
+                mins, secs = divmod((t * -1), 60)
+                timer = '-{:02d}:{:02d}'.format(mins, secs)
+            else:
+                mins, secs = divmod(t, 60)
+                timer = '{:02d}:{:02d}'.format(mins, secs)
+            GLib.idle_add(self.runb.set_label, timer)
+            time.sleep(1)
+            t -= 1
+            if t == 10:
+                if self.grid.get_name() == "lightgrid":
+                    GLib.idle_add(self.grid.set_name, "lredgrid")
+                else:
+                    GLib.idle_add(self.grid.set_name, "dredgrid")
+
+        GLib.idle_add(GridWindow.remRow, self.parent)
+
+class GridWindow(Gtk.ApplicationWindow):
+    def __init__(self, **kargs):
+        super().__init__(**kargs, title='Alkator Clock')
+
+        css_provider = Gtk.CssProvider()
+        css_provider.load_from_file(Gio.File.new_for_path("style.css"))
+        Gtk.StyleContext.add_provider_for_display(Gdk.Display.get_default(), css_provider, Gtk.STYLE_PROVIDER_PRIORITY_APPLICATION)
+
+        runlabel = Gtk.Label(label="ID", name="gridlabel")
+        runlabel.set_justify(2)
+        cntlabel = Gtk.Label(label="Countdown", name="gridlabel")
+        cntlabel.set_justify(2)
+
+        self.runners = []
+
+        self.grid = Gtk.Grid()
+        self.grid.attach(runlabel, 0, 0, 1, 1)
+        self.grid.attach(cntlabel, 1, 0, 2, 1)
+
+        self.set_child(self.grid)
+
+    def arb(self, racer):
+        self.runners.append(GridRow(self, racer, len(activeCards)))
+
+    def rrb(self, button):
+        self.remRow()
+
+    def addRow(self, runner, index):
+        runid = Gtk.Label(label=str(runner))
+        runb = Gtk.Button(label='time_placeholder')
+
+        self.grid.attach(runid, 0, index, 1, 1)
+        self.grid.attach(runb, 1, index, 1, 1)
+
+    def remRow(self):
+        global activeCards
+        if len(activeCards) > 0:
+            self.grid.remove_row(1)
+            del activeCards[0]
+
+
+def on_activate(app):
+    # Create window
+    global win
+    win = GridWindow(application=app)
+    win.present()
+
+UsbCardReader(callbackOnCard)
+app = Gtk.Application(application_id='com.example.App')
+app.connect('activate', on_activate)
+
+app.run(None)

registrace.py

@@ -0,0 +1,184 @@
+import sys
+import datetime
+import requests
+import threading
+import json
+from PyQt6 import QtWidgets, uic, QtGui, QtCore
+from PyQt6.QtCore import pyqtSignal as Signal, pyqtSlot as Slot
+from queue import Queue
+
+from requests.adapters import HTTPAdapter, Retry
+from usbcardreader import UsbCardReader
+
+app = QtWidgets.QApplication(sys.argv)
+
+with open('config.json', 'r') as f:
+    config = json.load(f)
+
+session = requests.Session()
+session.post(config['host'] + '/api/login', {'email':config['login'], 'password': config['password']})
+
+
+retries = Retry(total=10,
+                backoff_factor=1,
+                status_forcelist=[ 500, 502, 503, 504 ],)
+
+session.mount('https://', HTTPAdapter(max_retries=retries))
+
+
+last_card = 0
+last_time = datetime.datetime.now()
+
+racers = []
+
+log = []
+
+
+with open('log.json', 'r') as f:
+    log = json.loads(f.read())
+
+
+queue = Queue()
+
+
+class Worker(QtCore.QThread):
+    returned_state = Signal(str)
+    def __init__(self):
+        super().__init__()
+        self.returned_state.connect(self.handle_returned_state)
+        self.worker_thread = threading.Thread(target=self.worker)
+        self.worker_thread.start()
+
+    def worker(self):
+        while True:
+            item = queue.get()
+            log.append({
+                'url': item['url'],
+                'json': item['json'],
+            })
+            with open('log.json', 'w') as f:
+                f.write(json.dumps(log))
+            response = session.post(item['url'], json=item['json'])
+            if response.status_code == 200:
+                if item.get('on_success'):
+                    item['on_success']()
+                if item.get('message'):
+                    self.returned_state.emit(f'{item['message']}')
+            else:
+                if item.get('failed'):
+                    self.returned_state.emit(f'{item['failed']}')
+
+            print(item, response)
+    def handle_returned_state(self, state):
+        mb = QtWidgets.QMessageBox(text=f"{state}")
+        mb.exec()
+
+
+worker = Worker()
+
+
+def register_racer():
+    card_id = last_card
+    index = window.racers.currentIndex()
+    if not index.data():
+        mb = QtWidgets.QMessageBox(text='Prosím vyberte závodníka!')
+        mb.exec()
+        return
+    racer_id = int(index.data().split(' ')[-1])
+    try:
+        starting_number = max(filter(lambda r: r['starting_number'], racers), key=lambda racer: racer['starting_number'])['starting_number'] + 1
+    except ValueError:
+        starting_number = 1
+    racer = list(filter(lambda x: x['racer_id'] == racer_id, racers))[0]
+
+    def register_update_racer():
+        racer['card_id'] = card_id
+        racer['starting_number'] = starting_number
+        racer['started'] = False
+        updateRacers()
+
+    queue.put({
+        'url': config['host'] + '/api/card/register',
+        'json': {'racer_id': racer_id, 'starting_number': starting_number, 'card_id': card_id, 'time': datetime.datetime.now().strftime('%d.%m.%Y %H:%M:%S.%f')},
+        'message': f"Úspěšné zaregistrování závodníka {racer['first_name']} {racer['last_name']} se startovním číslem {starting_number}!",
+        'failed': f"Neúspěšná registrace závodníka {racer['first_name']} {racer['last_name']}",
+        'on_success': register_update_racer,
+    })
+
+
+model = QtGui.QStandardItemModel()
+
+def updateRacers():
+    model.clear()
+    for racer in racers:
+        if racer['starting_number'] or racer['card_id']:
+            continue
+        item = QtGui.QStandardItem(f"{racer['last_name']} {racer['first_name']} {racer['date_of_birth']} {racer['racer_id']}")
+        model.appendRow(item)
+
+
+updateRacers()
+
+
+def reload_racers():
+    global racers
+    response = session.get(config['host'] + '/api/racers')
+
+    racers = response.json()
+    updateRacers()
+
+
+reload_racers()
+
+
+def findByCard(card_id):
+    for racer in racers:
+        if racer['card_id'] == card_id:
+            return racer
+
+
+def updateLastCard(card_id):
+    global last_card, last_time
+    if card_id == last_card and datetime.datetime.now() - last_time < datetime.timedelta(seconds=15):
+        return
+    time = last_time = datetime.datetime.now()
+    last_card = card_id
+    window.lastCard.setText(str(card_id))
+
+    racer = findByCard(card_id)
+    if racer:
+        if racer['started']:
+            def finish_update_racer():
+                racer['card_id'] = None
+            queue.put({
+                'url': config['host'] + '/api/card/unregister',
+                'json': {'racer_id': racer['racer_id'], 'starting_number': racer['starting_number'], 'card_id': card_id, 'time': time.strftime('%d.%m.%Y %H:%M:%S.%f')},
+                'message': f"Úspěšné odhlášení závodníka {racer['starting_number']}!",
+                'failed': f"Neúspěšné odhlášení karty závodníka {racer['starting_number']}",
+                'on_success': finish_update_racer,
+            })
+        else:
+            def start_update_racer():
+                racer['started'] = True
+            queue.put({
+                'url': config['host'] + '/api/station/register',
+                'json': {'card_id': card_id, 'time': time.strftime('%d.%m.%Y %H:%M:%S.%f'), 'station_id': 1},
+                'message': f"Úspěšné odstartování závodníka {racer['starting_number']}!",
+                'failed': f"Núspěšné odstartování závodníka {racer['starting_number']}, prosím registraci opakujte!",
+                'on_success': start_update_racer,
+            })
+
+
+UsbCardReader(updateLastCard)
+
+
+
+
+window = uic.loadUi("registrace.ui")
+window.racers.setModel(model)
+window.register_racer.clicked.connect(register_racer)
+window.reload_racers.clicked.connect(reload_racers)
+window.show()
+
+
+app.exec()

registrace.ui

@@ -0,0 +1,61 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<ui version="4.0">
+ <class>Frame</class>
+ <widget class="QFrame" name="Frame">
+  <property name="geometry">
+   <rect>
+    <x>0</x>
+    <y>0</y>
+    <width>315</width>
+    <height>289</height>
+   </rect>
+  </property>
+  <property name="windowTitle">
+   <string>Registrace závodníků</string>
+  </property>
+  <layout class="QGridLayout" name="gridLayout">
+   <item row="4" column="0">
+    <spacer name="verticalSpacer">
+     <property name="orientation">
+      <enum>Qt::Orientation::Vertical</enum>
+     </property>
+     <property name="sizeHint" stdset="0">
+      <size>
+       <width>20</width>
+       <height>40</height>
+      </size>
+     </property>
+    </spacer>
+   </item>
+   <item row="0" column="0">
+    <widget class="QPushButton" name="register_racer">
+     <property name="text">
+      <string>Registrovat</string>
+     </property>
+    </widget>
+   </item>
+   <item row="2" column="0">
+    <widget class="QLineEdit" name="lastCard"/>
+   </item>
+   <item row="1" column="0">
+    <widget class="QLabel" name="label_2">
+     <property name="text">
+      <string>číslo karty</string>
+     </property>
+    </widget>
+   </item>
+   <item row="0" column="1" rowspan="5">
+    <widget class="QListView" name="racers"/>
+   </item>
+   <item row="3" column="0">
+    <widget class="QPushButton" name="reload_racers">
+     <property name="text">
+      <string>Obnovit Závodníky</string>
+     </property>
+    </widget>
+   </item>
+  </layout>
+ </widget>
+ <resources/>
+ <connections/>
+</ui>

run.sh

@@ -0,0 +1,2 @@
+#!/bin/bash
+GTK_THEME=Adwaita:light python ./main.py

usbcardreader.py

@@ -0,0 +1,52 @@
+import usb.core
+import usb.util
+import threading
+import time
+
+
+USB_IF      = 0 # Interface
+USB_TIMEOUT = 5 # Timeout in ms
+USB_VENDOR  = 0xffff # Vendor-ID:
+USB_PRODUCT = 0x0035 # Product-ID
+
+
+class UsbCardReader:
+    def __init__(self, callback):
+        #fn called on found card
+        self.callback = callback
+        # Find the HID device by vendor/product ID
+        self.dev = usb.core.find(idVendor=USB_VENDOR, idProduct=USB_PRODUCT)
+        # Get and store the endpoint
+        self.endpoint = self.dev[0][(0,0)][0]
+        if self.dev.is_kernel_driver_active(USB_IF) is True:
+            self.dev.detach_kernel_driver(USB_IF)
+        # Claim the device
+        usb.util.claim_interface(self.dev, USB_IF)
+        self.receivedNumber = 0
+
+        cardread=threading.Thread(target=self.read)
+        cardread.start()
+
+    def read(self):
+        receivedNumber = 0
+
+        while True:
+            control = None
+            try:
+                control = self.dev.read(self.endpoint.bEndpointAddress, self.endpoint.wMaxPacketSize, USB_TIMEOUT)
+                if (control[2] != 40) and (control[2] != 0):
+                    receivedDigit = control[2] - 29
+                    if receivedDigit == 10:
+                        receivedDigit = 0
+                    receivedNumber = 10 * receivedNumber + receivedDigit
+
+                if ( control[0] == 0 ) and ( control[2] == 40 ) and ( not receivedNumber == 0 ):
+                    self.callback(receivedNumber)
+                    receivedNumber = 0
+            except KeyboardInterrupt:
+                exit()
+            except:
+                receivedNumber = 0
+                pass
+
+            time.sleep(0.001)