Score Storage & Ranking — Altes vs. neues System¶

tfx_wertungen              ← Kopf-Datensatz: 1 Zeile pro Teilnehmer × Wettkampf
  int_wertungenid          (PK)
  int_wettkaempfeid        → tfx_wettkaempfe  (Wettkampf)
  int_teilnehmerid         → tfx_teilnehmer   (Teilnehmer)
  int_statusid, var_riege, int_startnummer, int_runde, …

tfx_wertungen_details      ← Ergebnis-Score: 1 Zeile pro Wertung × Disziplin × Versuch × KP
  int_wertungen_detailsid  (PK)
  int_wertungenid          → tfx_wertungen
  int_disziplinenid        → tfx_disziplinen
  rel_leistung             ← FINALSCORE (dieser Wert ALLEIN bestimmt Platzierung!)
  int_versuch              (Versuch-Nr., Standard 1)
  int_kp                   (0=Pflicht, 1=Kür)

tfx_jury_results           ← Einzelwertungen der Kampfrichter (NEU in Web-System)
  int_juryresultsid        (PK)
  int_wertungenid          → tfx_wertungen
  int_disziplinen_felderid → tfx_disziplinen_felder  (Felddef: D-Note, E-Note, …)
  rel_leistung             ← Wert dieses einen Feldes
  int_versuch, int_kp

tfx_disziplinen_felder     ← Felddefinitionen pro Disziplin
  bol_endwert              = true  → dieses Feld IST der Finalwert (muss in wertungen_details)
  bol_ausgangswert         = true  → Ausgangspunkt (z.B. D-Note beim Turnen)
  bol_enabled              = true/false
  int_sortierung           ← Anzeigereihenfolge

tfx_disziplinen            ← Disziplinkonfiguration
  var_formel               ← Built-in-Formel (wird zur ANZEIGE-/RANKINGZEIT angewendet, nicht beim Speichern)
  int_formelid             → tfx_formeln  (verknüpfte Formelvorlage für Berechnungen beim Speichern)

tfx_formeln                ← Formelvorlagen
  var_formel               ← Formel-Ausdruck, z.B. "A+B-C" oder "1*x"

Benutzer gibt einen einzigen Wert ein (z.B. Zeit in Sekunden): x = 12,5
→ Gespeichert in tfx_wertungen_details.rel_leistung = 12,5   (der ROHWERT)
→ Formel "20-x" wird beim Laden/Anzeigen angewendet: 20 - 12,5 = 7,5
→ Ranking basiert auf dem angezeigten Wert 7,5 (nicht dem gespeicherten 12,5)

Benutzer gibt mehrere Felder ein:
  D = 5,0   E1 = 8,2   E2 = 8,0   Abzug = 0,3
→ Jedes Feld wird in tfx_jury_results gespeichert
→ Nach jedem Feld wird die Formel ausgewertet (wenn alle Felder vorhanden):
  "D + (E1+E2)/2 - Abzug" = 5,0 + 8,1 - 0,3 = 12,8
→ Gespeichert in tfx_wertungen_details.rel_leistung = 12,8  (das ERGEBNIS)
→ var_formel ist bei solchen Disziplinen typischerweise "1*x" (keine weitere Transformation)
→ Ranking basiert auf dem gespeicherten Wert 12,8

// jury-portal: builtInFormulaHelper.ts
function isBuiltInFormula(formula, disciplineFieldCount) {
  if (disciplineFieldCount > 0) return false;  // Jury-Felder vorhanden → Typ 2
  return /[a-z]/.test(formula);                // Kleinbuchstabe → Typ 1
}

// Was wird in rel_leistung gespeichert?
function getScoreToSave(calculatedScore, fieldValues, formula, fieldCount) {
  if (isBuiltInFormula(formula, fieldCount)) {
    return fieldValues['x'];     // Typ 1: Rohwert speichern
  }
  return calculatedScore;         // Typ 2: Berechnetes Ergebnis speichern
}

Benutzer gibt ein:
  ┌─────────────────────────────────────────────────────────────┐
  │  Spalten 1..n  = Einzelwertungen (D-Note, E1, E2, Abzug)  │
  │  Letzte Spalte = Endwert (manuell berechnet / eingetragen)  │
  └─────────────────────────────────────────────────────────────┘

Speichern:
  Einzelwertungen  → tfx_jury_results       (via JuryScoreRepository)
  Endwert          → tfx_wertungen_details  (via ScoreDetailsRepository)
                     └─ rel_leistung = manuell eingegebener/berechneter Gesamtwert

-- Kernabfrage in result_calc.cpp:
SELECT
  tfx_wertungen.int_wertungenid,
  tfx_wettkaempfe_x_disziplinen.int_disziplinenid,
  max(tfx_wertungen_details.rel_leistung),   -- ← aggregierter Score pro Disziplin
  max(jr.rel_leistung),                       -- ← Ausgangswert (optional in Klammern angezeigt)
  tfx_wertungen_details.int_kp
FROM tfx_wertungen
  INNER JOIN ...
  LEFT JOIN tfx_wertungen_details ON int_wertungenid = ...
  LEFT JOIN tfx_jury_results jr ON ... bol_ausgangswert='true' ...
WHERE int_wettkaempfeid = ? AND int_runde = ?
GROUP BY ... ORDER BY ...

for (int i = 0; i < disrows.size(); i++) {
    double dres = wertungen[wertungId][disziplinId][kp];  // ← tfx_wertungen_details.rel_leistung
    // Built-in-Formel anwenden: var_formel mit Variable "x"
    fparser.Parse(var_formel, "x");
    double calc = fparser.Eval({dres});  // z.B. 20 - 12.5 = 7.5
    QString resString = QString::number(calc, 'f', precision);
    if (printAW) {
        // Optional: Ausgangswert in Klammern anhängen (z.B. "7.5 (12.5)")
        // Ausgangswert = das Jury-Feld mit bol_ausgangswert='true'
        resString += " (" + QString::number(ausgang, 'f', precision) + ")";
    }
    tnlist << resString;   // ← JE EINE SPALTE PRO DISZIPLIN
}
tnlist << QString::number(sum, 'f', 3);   // ← Gesamtergebnis (letzte Spalte)

POST /api/scores/save-value
  { participantId, disciplineId, score }

→ ScoreSynchronizer.updateWertungsDetailsScore()
    → INSERT/UPDATE tfx_wertungen_details  (rel_leistung = übergebener score)
    → kein Eintrag in tfx_jury_results

POST /api/jury-results/save-field-score  (z.B. D-Note, E-Note einzeln)
  { participantId, disciplineFieldId, performance, eventId, competitionId }

Schritt 1: ScoreSynchronizer.ensureWertungsDetailsEntry()
    → stellt sicher dass Eintrag in tfx_wertungen_details existiert (NULL-Placeholder)

Schritt 2: INSERT/UPDATE tfx_jury_results
    → rel_leistung = Wert für dieses eine Feld

Schritt 3: Formelberechnung (FIX #89)
    a) Falls Feld ist bol_endwert=true:
       → updateWertungsDetailsScore(wertungenId, disciplineId, performance)
    b) Falls Feld ist ein Eingabefeld:
       → Formel aus tfx_formeln (via int_formelid) laden
       → Alle bereits gespeicherten jury_results für diese Kombination laden
       → Formel auswerten (z.B. "D + (E1+E2+E3-Δ)/3")
       → Falls Ergebnis vollständig (alle Felder vorhanden):
          updateWertungsDetailsScore(wertungenId, disciplineId, calculatedScore)
       → Falls Felder noch unvollständig: tfx_wertungen_details bleibt vorerst NULL

Schritt 4: Socket.IO emit 'score-updated' (nur beim finalen Wert)

POST /api/jury-results  (direkt, ohne save-field-score)
  → gleiche Logik wie Pfad B, Schritt 2–4

PUT  /api/jury-results/:id
  → Update eines bestehenden jury_results-Eintrags
  → Falls Feld bol_endwert=true:
     ScoreSynchronizer.updateWertungsDetailsScore()  (FIX #89: statt plain UPDATE)

PUT /api/group-scores/:id
  → DELETE + INSERT in tfx_wertungen_details (kein Jury-Feld-System)
  → direkt rel_leistung setzen

tfx_wertungen_details.rel_leistung  (je Disziplin)
         ↓  (summiert über alle Disziplinen des Wettkampfs)
    Rohsumme
         ↓  (optional: Built-in-Formel var_formel angewendet)
    Anzeigewert / Sortierwert
         ↓  (absteigend sortiert, bei gleichen Werten: ties)
    Platzierung (wird NICHT gespeichert, immer on-the-fly berechnet)

-- aus analyzer.ts (Referenzimplementierung)
SELECT w.int_wertungenid, SUM(wd.rel_leistung) as total
FROM tfx_wertungen w
LEFT JOIN tfx_wertungen_details wd ON w.int_wertungenid = wd.int_wertungenid
WHERE w.int_wettkaempfeid = ?
GROUP BY w.int_wertungenid
ORDER BY SUM(wd.rel_leistung) DESC

Disziplin: Boden
Formelvorlage (tfx_formeln.var_formel): "D + (E1+E2)/2 - Abzug"
Built-in (tfx_disziplinen.var_formel):  "1*x"  (keine Transformation)

Benutzer gibt ein:
  D-Note = 5.0  → POST /save-field-score  → tfx_jury_results (D)
                   Formel noch unvollständig → rel_leistung bleibt NULL
  E1     = 8.2  → POST /save-field-score  → tfx_jury_results (E1)
                   Formel noch unvollständig → rel_leistung bleibt NULL
  E2     = 8.0  → POST /save-field-score  → tfx_jury_results (E2)
                   Formel noch unvollständig → rel_leistung bleibt NULL
  Abzug  = 0.3  → POST /save-field-score  → tfx_jury_results (Abzug)
                   Alle Felder vorhanden!
                   Berechnung: 5.0 + (8.2+8.0)/2 - 0.3 = 12.8
                   → updateWertungsDetailsScore(wertungenId, disciplineId, 12.8)
                   → tfx_wertungen_details.rel_leistung = 12.8  ✅

Platzierungsabfrage:
  SELECT SUM(wd.rel_leistung) ...  → 12.8
  Built-in 1*x → 12.8
  Rang: sortiert nach Gesamtsumme aller Disziplinen