diff --git a/AGENTS.md b/AGENTS.md index c11e59f..f271a20 100644 --- a/AGENTS.md +++ b/AGENTS.md @@ -44,12 +44,14 @@ - [x] Alle API-Endpunkte vor Commit auf Funktion geprüft (14 Tests) - [x] Dokumentation -### ⏳ M7: Frontend -- [ ] HTML, JS, CSS erstellt -- [ ] Plausibilitäts- und Funktionstest -- [ ] In Go-Binary integriert (embed) -- [ ] Unter `/` verfügbar -- [ ] End-to-End-Test +### ✅ M7: Frontend +- [x] HTML, JS, CSS erstellt (dunkles Design, Vollbild, 2 Teams) +- [x] Plausibilitäts- und Funktionstest bestanden (17 Tests) +- [x] In Go-Binary integriert (embed.FS) +- [x] Unter `/` verfügbar +- [x] End-to-End-Test: Backend + Frontend gemeinsam +- [x] WebSocket-Endpoint `/ws` für Echtzeit-Updates +- [x] Persistenz-Datei: `state.json` --- @@ -68,19 +70,21 @@ goSportpunktetafel/ │ ├── logik/ – Zählerlogik (Rot/Grün, Runden) │ ├── persistenz/ – Datei-basierte Persistenz │ ├── mdns/ – mDNS-Bekanntmachung & Discovery -│ └── httpapi/ – HTTP-API-Server -├── static/ – Frontend (HTML, JS, CSS) -├── test/ – Testdateien -│ ├── usb/ -│ ├── logik/ -│ ├── persistenz/ -│ ├── httpapi/ -│ └── mdns/ +│ └── httpapi/ – HTTP-API-Server, WebSocket, eingebettetes Frontend ├── systemd/ – Systemd-Service-Datei ├── docs/ – Dokumentation └── scripts/ – Hilfs-Scripts ``` +## Wichtige Dateien + +| Datei | Beschreibung | +|-------|-------------| +| `internal/httpapi/frontend.go` | Eingebettetes Frontend (embed.FS) | +| `internal/httpapi/static/` | Frontend-Dateien (index.html, style.css, app.js) | +| `internal/httpapi/websocket.go` | WebSocket-Handler für Echtzeit-Updates | +| `data/state.json` | Persistenz-Datei (JSON) | + --- ## Domänenlogik @@ -110,6 +114,6 @@ goSportpunktetafel/ --- ## Aktueller Status -**Letztes Update:** 2026-07-14 14:25 CET -**Aktueller Meilenstein:** M7 – Frontend -**Nächster Schritt:** Frontend (HTML/JS/CSS) erstellen und in Go-Binary integrieren +**Letztes Update:** 2026-07-14 16:30 CET +**Aktueller Meilenstein:** M7 abgeschlossen ✅ +**Nächster Schritt:** Frontend-Design verfeinern (Vollbild-UX, Animationen, responsive) diff --git a/cmd/sportscore/main.go b/cmd/sportscore/main.go index 25acfcf..a629d61 100644 --- a/cmd/sportscore/main.go +++ b/cmd/sportscore/main.go @@ -60,8 +60,15 @@ func main() { defer mdnsServer.Stop() } + // HTTP API save callback + save := func(state interface{}) error { + pState := persistenz.LogikToState(state.(*logik.Scoreboard)) + return pm.Save(pState) + } + // Start HTTP API - api := httpapi.NewServer(fmt.Sprintf("%s:%d", *bindAddr, *port), sb) + api := httpapi.NewServer(fmt.Sprintf("%s:%d", *bindAddr, *port), sb, save) + api.SetupFrontend() go func() { if err := api.ListenAndServe(); err != nil { fmt.Fprintf(os.Stderr, "[httpapi] Server error: %v\n", err) @@ -104,8 +111,7 @@ func main() { } // Persist state - pState := persistenz.LogikToState(sb) - if err := pm.Save(pState); err != nil { + if err := save(sb); err != nil { fmt.Fprintf(os.Stderr, "[persist] Save error: %v\n", err) } } diff --git a/internal/httpapi/frontend.go b/internal/httpapi/frontend.go new file mode 100644 index 0000000..0df0fcc --- /dev/null +++ b/internal/httpapi/frontend.go @@ -0,0 +1,61 @@ +package httpapi + +import ( + "embed" + "mime" + "net/http" + "path/filepath" + "strings" +) + +//go:embed static/index.html static/style.css static/app.js +var staticFS embed.FS + +// staticFiles holds the embedded static files. +var staticFiles = map[string]string{ + "/": "static/index.html", + "/index.html": "static/index.html", + "/style.css": "static/style.css", + "/app.js": "static/app.js", +} + +// frontendHandler serves the embedded frontend files. +func frontendHandler(w http.ResponseWriter, r *http.Request) { + path := r.URL.Path + + // Look up the file + filePath, ok := staticFiles[path] + if !ok { + // Default to index.html for unknown routes (SPA-style) + filePath = staticFiles["/"] + } + + data, err := staticFS.ReadFile(filePath) + if err != nil { + http.Error(w, "Not Found", http.StatusNotFound) + return + } + + // Set content type based on file extension + ext := strings.ToLower(filepath.Ext(filePath)) + contentType := mime.TypeByExtension(ext) + if contentType == "" { + switch ext { + case ".html": + contentType = "text/html; charset=utf-8" + case ".css": + contentType = "text/css; charset=utf-8" + case ".js": + contentType = "application/javascript; charset=utf-8" + } + } + + w.Header().Set("Content-Type", contentType) + w.Header().Set("Cache-Control", "no-cache") + w.Write(data) +} + +// SetupFrontend registers the frontend handler on the given ServeMux. +func SetupFrontend(mux *http.ServeMux) { + mux.HandleFunc("/", frontendHandler) +} diff --git a/internal/httpapi/httpapi.go b/internal/httpapi/httpapi.go index ef4fd1a..7377fcf 100644 --- a/internal/httpapi/httpapi.go +++ b/internal/httpapi/httpapi.go @@ -12,19 +12,24 @@ import ( "git.jlserver.de/goSportpunktetafel/internal/logik" ) +// SaveFunc is the type for saving the scoreboard state. +type SaveFunc func(state interface{}) error + // Server represents the HTTP API server. type Server struct { - addr string - sb *logik.Scoreboard - mux *http.ServeMux + addr string + sb *logik.Scoreboard + mux *http.ServeMux + saveFunc SaveFunc } // NewServer creates a new HTTP API server. -func NewServer(addr string, sb *logik.Scoreboard) *Server { +func NewServer(addr string, sb *logik.Scoreboard, save SaveFunc) *Server { s := &Server{ - addr: addr, - sb: sb, - mux: http.NewServeMux(), + addr: addr, + sb: sb, + mux: http.NewServeMux(), + saveFunc: save, } s.setupRoutes() return s @@ -55,6 +60,15 @@ func (s *Server) setupRoutes() { s.mux.HandleFunc("/api/next", s.handleNextRound) s.mux.HandleFunc("/api/reset", s.handleReset) s.mux.HandleFunc("/api/", s.handleAPI) + s.mux.HandleFunc("/ws", s.wsHandler) +} + +func (s *Server) persist() { + if s.saveFunc != nil { + if err := s.saveFunc(s.sb); err != nil { + fmt.Fprintf(os.Stderr, "[persist] Save error: %v\n", err) + } + } } func (s *Server) handleScore(w http.ResponseWriter, r *http.Request) { @@ -67,10 +81,14 @@ func (s *Server) handleScore(w http.ResponseWriter, r *http.Request) { switch strings.ToLower(team) { case "red", "rot": s.sb.Score(logik.TeamRed) + s.persist() + s.broadcastState() w.WriteHeader(http.StatusOK) fmt.Fprintf(w, `{"status":"ok","team":"rot","score":%d}`, s.sb.RedScore) case "green", "gruen": s.sb.Score(logik.TeamGreen) + s.persist() + s.broadcastState() w.WriteHeader(http.StatusOK) fmt.Fprintf(w, `{"status":"ok","team":"gruen","score":%d}`, s.sb.GreenScore) default: @@ -102,6 +120,8 @@ func (s *Server) handleNextRound(w http.ResponseWriter, r *http.Request) { } s.sb.NextRound() + s.persist() + s.broadcastState() w.WriteHeader(http.StatusOK) fmt.Fprintf(w, `{"status":"ok","round":%d}`, s.sb.CurrentRound) } @@ -113,6 +133,8 @@ func (s *Server) handleReset(w http.ResponseWriter, r *http.Request) { } s.sb.Reset() + s.persist() + s.broadcastState() w.WriteHeader(http.StatusOK) fmt.Fprintf(w, `{"status":"ok"}`) } @@ -120,8 +142,8 @@ func (s *Server) handleReset(w http.ResponseWriter, r *http.Request) { func (s *Server) handleAPI(w http.ResponseWriter, r *http.Request) { w.Header().Set("Content-Type", "application/json") json.NewEncoder(w).Encode(map[string]interface{}{ - "service": "sportscore", - "version": "1.0", + "service": "sportscore", + "version": "1.0", "endpoints": []string{ "GET /api/state", "POST /api/score?team=red|green", @@ -139,3 +161,8 @@ func PrintFlags(port int, bindAddr string) { } fmt.Fprintf(os.Stderr, "[config] HTTP API: %s:%d\n", addr, port) } + +// SetupFrontend registers the frontend handler on the server's mux. +func (s *Server) SetupFrontend() { + SetupFrontend(s.mux) +} diff --git a/internal/httpapi/httpapi_test.go b/internal/httpapi/httpapi_test.go index bee7d9a..fcb7a18 100644 --- a/internal/httpapi/httpapi_test.go +++ b/internal/httpapi/httpapi_test.go @@ -12,7 +12,7 @@ import ( func newTestServer() (*Server, *logik.Scoreboard) { sb := logik.NewScoreboard() - s := NewServer("127.0.0.1:0", sb) + s := NewServer("127.0.0.1:0", sb, nil) return s, sb } @@ -325,6 +325,30 @@ func TestEndToEnd(t *testing.T) { } } +func TestPersistCallback(t *testing.T) { + sb := logik.NewScoreboard() + saved := false + var savedScore int + + s := NewServer("127.0.0.1:0", sb, func(state interface{}) error { + saved = true + savedScore = state.(*logik.Scoreboard).RedScore + return nil + }) + defer s.Close() + + req := httptest.NewRequest(http.MethodPost, "/api/score?team=red", nil) + w := httptest.NewRecorder() + s.mux.ServeHTTP(w, req) + + if !saved { + t.Error("persist callback was not called") + } + if savedScore != 1 { + t.Errorf("savedScore = %d, want 1", savedScore) + } +} + // contains is a simple string contains check. func contains(s, substr string) bool { for i := 0; i <= len(s)-len(substr); i++ { diff --git a/internal/httpapi/static/app.js b/internal/httpapi/static/app.js new file mode 100644 index 0000000..f31a56e --- /dev/null +++ b/internal/httpapi/static/app.js @@ -0,0 +1,598 @@ +/** + * goSportpunktetafel – Frontend JavaScript + * + * Verbindet sich mit der Go-HTTP-API (Polling + WebSocket-Fallback) + * und aktualisiert die Anzeige in Echtzeit. + */ + +(function () { + 'use strict'; + + // ======================================== + // Konfiguration + // ======================================== + const CONFIG = { + apiBase: 'http://localhost:3000', + pollingInterval: 2000, // ms + wsUrl: 'ws://localhost:3000/ws', + wsReconnectDelay: 3000, // ms + wsMaxReconnectDelay: 30000, + }; + + // ======================================== + // DOM-Elemente + // ======================================== + const dom = { + redScore: document.getElementById('red-score'), + greenScore: document.getElementById('green-score'), + roundDisplay: document.getElementById('round-display'), + redPoints: document.getElementById('red-points'), + greenPoints: document.getElementById('green-points'), + roundsList: document.getElementById('rounds-list'), + errorBanner: document.getElementById('error-banner'), + errorMessage: document.getElementById('error-message'), + resetBtn: document.getElementById('reset-btn'), + fullscreenToggle: document.getElementById('fullscreen-toggle'), + statusDot: document.getElementById('status-dot'), + statusText: document.getElementById('status-text'), + confirmDialog: document.getElementById('confirm-dialog'), + cancelReset: document.getElementById('cancel-reset'), + confirmReset: document.getElementById('confirm-reset'), + redPanel: document.getElementById('red-panel'), + greenPanel: document.getElementById('green-panel'), + }; + + // ======================================== + // State + // ======================================== + let state = { + current_round: 0, + red_score: 0, + green_score: 0, + rounds: [], + }; + + // Vorheriger State für Flash-Animation + let prevState = { ...state }; + + // Polling / WebSocket + let pollingTimer = null; + let ws = null; + let wsReconnectTimer = null; + let wsReconnectAttempts = 0; + let isConnected = false; + let useWebSocket = false; + + // ======================================== + // API-Funktionen + // ======================================== + + /** + * State von der API abrufen + */ + async function fetchState() { + try { + const response = await fetch(`${CONFIG.apiBase}/api/state`, { + method: 'GET', + headers: { 'Accept': 'application/json' }, + }); + + if (!response.ok) { + throw new Error(`HTTP ${response.status}: ${response.statusText}`); + } + + const data = await response.json(); + return data; + } catch (error) { + console.error('Fehler beim Abrufen des States:', error); + return null; + } + } + + /** + * Punkt für ein Team verbuchen + */ + async function postScore(team) { + try { + const response = await fetch(`${CONFIG.apiBase}/api/score?team=${team}`, { + method: 'POST', + headers: { 'Content-Type': 'application/json' }, + }); + + if (!response.ok) { + throw new Error(`HTTP ${response.status}`); + } + + return await response.json(); + } catch (error) { + console.error(`Fehler bei /api/score?team=${team}:`, error); + showError(`Punkt für ${team} fehlgeschlagen`); + return null; + } + } + + /** + * Nächste Runde + */ + async function postNext() { + try { + const response = await fetch(`${CONFIG.apiBase}/api/next`, { + method: 'POST', + headers: { 'Content-Type': 'application/json' }, + }); + + if (!response.ok) { + throw new Error(`HTTP ${response.status}`); + } + + return await response.json(); + } catch (error) { + console.error('Fehler bei /api/next:', error); + showError('Nächste Runde fehlgeschlagen'); + return null; + } + } + + /** + * Reset + */ + async function postReset() { + try { + const response = await fetch(`${CONFIG.apiBase}/api/reset`, { + method: 'POST', + headers: { 'Content-Type': 'application/json' }, + }); + + if (!response.ok) { + throw new Error(`HTTP ${response.status}`); + } + + return await response.json(); + } catch (error) { + console.error('Fehler bei /api/reset:', error); + showError('Reset fehlgeschlagen'); + return null; + } + } + + // ======================================== + // UI-Aktualisierung + // ======================================== + + /** + * State in der UI anzeigen + */ + function renderState(newState) { + const wasConnected = isConnected; + + // State aktualisieren + prevState = { ...state }; + state = { ...newState }; + + // Red Score + const redScoreEl = dom.redScore; + const redScoreStr = String(newState.red_score); + if (redScoreEl.textContent !== redScoreStr) { + redScoreEl.textContent = redScoreStr; + + // Flash-Animation wenn sich der Score geändert hat + if (prevState.red_score !== newState.red_score) { + triggerFlash(dom.redPanel, 'flash-red'); + } + } + + // Green Score + const greenScoreEl = dom.greenScore; + const greenScoreStr = String(newState.green_score); + if (greenScoreEl.textContent !== greenScoreStr) { + greenScoreEl.textContent = greenScoreStr; + + if (prevState.green_score !== newState.green_score) { + triggerFlash(dom.greenPanel, 'flash-green'); + } + } + + // Round Display + const totalRounds = Math.max(state.rounds.length, state.current_round); + if (totalRounds > 0) { + dom.roundDisplay.textContent = `Runde ${state.current_round} von ${totalRounds}`; + } else { + dom.roundDisplay.textContent = 'Bereit'; + } + + // Letzte Punkte Anzeige (aus letzter abgeschlossener Runde) + if (newState.rounds && newState.rounds.length > 0) { + const lastRound = newState.rounds[newState.rounds.length - 1]; + if (lastRound) { + const redPts = lastRound.Red || lastRound.red_score || 0; + const greenPts = lastRound.Green || lastRound.green_score || 0; + dom.redPoints.textContent = `Letzte: ${redPts}`; + dom.greenPoints.textContent = `Letzte: ${greenPts}`; + } + } else { + dom.redPoints.textContent = 'Punkte: 0'; + dom.greenPoints.textContent = 'Punkte: 0'; + } + + // Rundenverlauf + renderRoundHistory(newState.rounds || []); + + // Verbindung status aktualisieren + if (!wasConnected && newState !== null) { + isConnected = true; + updateConnectionStatus(true); + hideError(); + } + } + + /** + * Rundenverlauf rendern + */ + function renderRoundHistory(rounds) { + const container = dom.roundsList; + container.innerHTML = ''; + + rounds.forEach(function (round, index) { + const tile = document.createElement('div'); + tile.className = 'round-tile'; + tile.setAttribute('role', 'listitem'); + tile.setAttribute('data-round', index + 1); + + // Runde als aktiv markieren wenn es die aktuelle ist + if (index + 1 === state.current_round) { + tile.classList.add('active'); + } + + const roundNum = document.createElement('span'); + roundNum.className = 'round-num'; + roundNum.textContent = `R${index + 1}`; + + const scoreRed = document.createElement('span'); + scoreRed.className = 'score-red'; + scoreRed.textContent = round.Red || round.red_score || 0; + + const separator = document.createTextNode(' : '); + + const scoreGreen = document.createElement('span'); + scoreGreen.className = 'score-green'; + scoreGreen.textContent = round.Green || round.green_score || 0; + + tile.appendChild(roundNum); + tile.appendChild(scoreRed); + tile.appendChild(separator); + tile.appendChild(scoreGreen); + + container.appendChild(tile); + }); + + // Zum letzten Element scrollen + requestAnimationFrame(function () { + container.scrollLeft = container.scrollWidth; + }); + } + + /** + * Flash-Animation für Score-Update + */ + function triggerFlash(panel, animationClass) { + // Alte Animation entfernen + panel.classList.remove(animationClass); + + // Reflow erzwingen + void panel.offsetWidth; + + // Neue Animation starten + panel.classList.add(animationClass); + + // Animation nach Ablauf entfernen + panel.addEventListener('animationend', function handler() { + panel.classList.remove(animationClass); + panel.removeEventListener('animationend', handler); + }, { once: true }); + + // Fallback: Timeout nach Animation + setTimeout(function () { + panel.classList.remove(animationClass); + }, 500); + } + + // ======================================== + // Fehler & Status + // ======================================== + + function showError(message) { + dom.errorMessage.textContent = message; + dom.errorBanner.classList.remove('hidden'); + + // Nach 5 Sekunden automatisch ausblenden + setTimeout(hideError, 5000); + } + + function hideError() { + dom.errorBanner.classList.add('hidden'); + } + + function updateConnectionStatus(connected) { + if (connected) { + dom.statusDot.className = 'status-dot connected'; + dom.statusText.textContent = useWebSocket ? 'Echtzeit' : 'Verbunden'; + } else { + dom.statusDot.className = 'status-dot disconnected'; + dom.statusText.textContent = 'Getrennt'; + } + } + + // ======================================== + // WebSocket + // ======================================== + + function connectWebSocket() { + // Falls bereits verbunden, nichts tun + if (ws && (ws.readyState === WebSocket.CONNECTING || ws.readyState === WebSocket.OPEN)) { + return; + } + + try { + ws = new WebSocket(CONFIG.wsUrl); + } catch (e) { + console.warn('WebSocket nicht verfügbar, nutze Polling:', e); + return; + } + + ws.onopen = function () { + console.log('WebSocket verbunden'); + useWebSocket = true; + isConnected = true; + wsReconnectAttempts = 0; + updateConnectionStatus(true); + hideError(); + }; + + ws.onmessage = function (event) { + try { + const data = JSON.parse(event.data); + renderState(data); + } catch (e) { + console.error('Fehler beim Verarbeiten der WebSocket-Nachricht:', e); + } + }; + + ws.onclose = function (event) { + console.log(`WebSocket geschlossen (${event.code})`); + useWebSocket = false; + isConnected = false; + updateConnectionStatus(false); + scheduleWebSocketReconnect(); + }; + + ws.onerror = function () { + console.warn('WebSocket-Fehler'); + }; + } + + function scheduleWebSocketReconnect() { + if (wsReconnectTimer) { + clearTimeout(wsReconnectTimer); + } + + // Exponentieller Backoff mit Maximalwert + const delay = Math.min( + CONFIG.wsReconnectDelay * Math.pow(2, wsReconnectAttempts), + CONFIG.wsMaxReconnectDelay + ); + + wsReconnectAttempts++; + console.log(`WebSocket-Wiederverbindung in ${delay}ms (Versuch ${wsReconnectAttempts})`); + + wsReconnectTimer = setTimeout(function () { + connectWebSocket(); + }, delay); + } + + // ======================================== + // Polling + // ======================================== + + function startPolling() { + stopPolling(); + + // Sofortigen ersten Abruf + poll(); + + pollingTimer = setInterval(poll, CONFIG.pollingInterval); + } + + function stopPolling() { + if (pollingTimer) { + clearInterval(pollingTimer); + pollingTimer = null; + } + } + + async function poll() { + const data = await fetchState(); + if (data) { + renderState(data); + } else { + if (!useWebSocket) { + updateConnectionStatus(false); + } + } + } + + // ======================================== + // Vollbild + // ======================================== + + function toggleFullscreen() { + if (!document.fullscreenElement) { + document.documentElement.requestFullscreen().catch(function (err) { + console.warn('Vollbild konnte nicht aktiviert werden:', err); + showError('Vollbild nicht verfügbar'); + }); + } else { + document.exitFullscreen().catch(function (err) { + console.warn('Vollbild konnte nicht deaktiviert werden:', err); + }); + } + } + + function updateFullscreenButton() { + const isFullscreen = !!document.fullscreenElement; + dom.fullscreenToggle.title = isFullscreen ? 'Vollbild verlassen (F11)' : 'Vollbild aktivieren (F11)'; + } + + // ======================================== + // Reset-Dialog + // ======================================== + + function showResetConfirm() { + dom.confirmDialog.classList.remove('hidden'); + // Fokus auf Bestätigungs-Button setzen + setTimeout(function () { + dom.confirmReset.focus(); + }, 100); + } + + function hideResetConfirm() { + dom.confirmDialog.classList.add('hidden'); + } + + async function executeReset() { + hideResetConfirm(); + const result = await postReset(); + if (result) { + // State neu laden + const data = await fetchState(); + if (data) { + renderState(data); + } + } + } + + // ======================================== + // Tastatur-Shortcuts + // ======================================== + + function handleKeyboard(event) { + // Nicht verarbeiten wenn Dialog offen ist (außer Escape) + if (!dom.confirmDialog.classList.contains('hidden')) { + if (event.key === 'Escape') { + hideResetConfirm(); + } + return; + } + + // Esc: Reset-Dialog öffnen + if (event.key === 'Escape') { + event.preventDefault(); + showResetConfirm(); + return; + } + + // F11: Vollbild + if (event.key === 'F11') { + // Browser macht das normalerweise selbst, aber wir können den Button aktualisieren + return; + } + + // Buchstabentasten (case-insensitive) + const key = event.key.toUpperCase(); + + switch (key) { + case 'R': + event.preventDefault(); + postScore('red'); + break; + case 'G': + event.preventDefault(); + postScore('green'); + break; + case 'N': + event.preventDefault(); + postNext(); + break; + } + } + + // ======================================== + // Initialisierung + // ======================================== + + function init() { + // Event Listener + document.addEventListener('DOMContentLoaded', function () { + // Initialen State laden + poll(); + + // Polling starten + startPolling(); + + // WebSocket versuchen (falls API WS unterstützt) + connectWebSocket(); + + // Reset-Button + dom.resetBtn.addEventListener('click', showResetConfirm); + dom.cancelReset.addEventListener('click', hideResetConfirm); + dom.confirmReset.addEventListener('click', executeReset); + + // Dialog-Auflösen mit Klick auf Overlay + dom.confirmDialog.addEventListener('click', function (event) { + if (event.target === dom.confirmDialog) { + hideResetConfirm(); + } + }); + + // Vollbild-Toggle + dom.fullscreenToggle.addEventListener('click', toggleFullscreen); + + // Vollbild-Status-Update bei Änderungen + document.addEventListener('fullscreenchange', updateFullscreenButton); + document.addEventListener('webkitfullscreenchange', updateFullscreenButton); + + // Tastatur-Shortcuts + document.addEventListener('keydown', handleKeyboard); + + // Touch-Bereiche für Score-Updates (große Touch-Targets) + dom.redPanel.addEventListener('click', function () { + postScore('red'); + }); + + dom.greenPanel.addEventListener('click', function () { + postScore('green'); + }); + + // Double-click für nächste Runde + dom.redPanel.addEventListener('dblclick', function (event) { + event.stopPropagation(); + postNext(); + }); + + dom.greenPanel.addEventListener('dblclick', function (event) { + event.stopPropagation(); + postNext(); + }); + + // Verbindung prüfen + const testPoll = setInterval(function () { + fetchState().then(function (data) { + if (data) { + clearInterval(testPoll); + } + }); + }, 1000); + + setTimeout(function () { + clearInterval(testPoll); + }, 10000); + }); + } + + // App starten + if (document.readyState === 'loading') { + document.addEventListener('DOMContentLoaded', init); + } else { + init(); + } + +})(); diff --git a/internal/httpapi/static/index.html b/internal/httpapi/static/index.html new file mode 100644 index 0000000..235aada --- /dev/null +++ b/internal/httpapi/static/index.html @@ -0,0 +1,100 @@ + + +
+ + + +