Organisator: Link zur Übersicht des eigenen Matches

Der Organisator bekommt einen Link auf /stream/match/<id>, die
Stream-Übersicht nur für dieses Match. Der Zuschauercode bleibt
außen vor. Ist STREAM_KEY gesetzt, wird der Schlüssel angehängt.

.env.example

@@ -68,5 +68,3 @@ LOG_DEBUG=false
 SERIES_AUTO_ADVANCE_SECONDS=30
 # Schlüssel für die Stream-Übersicht aller Matches (/stream?key=...); leer = offen
 STREAM_KEY=
-# Discord-Webhook für Meldungen (Veto, Match-Start, Map- und Serienende, Fehler). Leer = aus
-DISCORD_WEBHOOK_URL=

README.md

@@ -75,14 +75,14 @@ Die Tests decken Veto-Engine und Ablaufvalidierung, RCON-Protokoll (gegen einen
 6. **Server konfigurieren:** Nach dem Veto wird der bereits laufende Server automatisch eingerichtet: Spielmodus, erste Map, Teamnamen und Startseiten, Match-Einstellungen, Server- und CSTV-Passwort. Die restliche Map-Reihenfolge ist gespeichert.
    - Spieler sehen danach den kopierbaren Konsolenbefehl `password …; connect host:port` und einen `steam://connect`-Link.
    - Zuschauer sehen den CSTV-Zugang (eigener Port, eigenes Passwort, Verzögerung).
-7. **Während der Serie:** Der Organisator kann die Aufwärmphase beenden (`mp_warmup_end`), das laufende Match pausieren und fortsetzen (`mp_pause_match`, `mp_unpause_match`), die nächste Map laden, den Server stoppen und das Match abschließen oder abbrechen.
+7. **Während der Serie:** Der Organisator kann die Aufwärmphase beenden (`mp_warmup_end`), die nächste Map laden, den Server stoppen und das Match abschließen oder abbrechen.
 8. **Fehlerfälle:** Startet der Server nicht, schlägt die Konfiguration fehl oder fällt der Server aus, zeigt die Seite den Grund. Der Organisator bekommt einen Knopf für den erneuten Versuch: „Server neu starten“ bzw. „Konfiguration wiederholen“.
 
 ### Rollen und Berechtigungen
 
 | Rolle | Zugang über | Darf |
 |---|---|---|
-| Organisator | Token beim Erstellen | Veto starten, Spieler entfernen, Captain setzen, Codes erneuern, Server neu starten/stoppen/konfigurieren, pausieren/fortsetzen, nächste Map, Match beenden; sieht Einladungen, Spieler- und CSTV-Verbindung, die Match-Übersicht |
+| Organisator | Token beim Erstellen | Veto starten, Spieler entfernen, Captain setzen, Codes erneuern, Server neu starten/stoppen/konfigurieren, nächste Map, Match beenden; sieht Einladungen, Spieler- und CSTV-Verbindung |
 | Captain | Teamcode (erster Spieler oder ernannt) | alles wie Spieler, dazu Veto-Aktionen seines Teams und Captain-Übergabe |
 | Spieler | Teamcode | bereit melden, Team verlassen; sieht die Spieler-Verbindungsdaten nach dem Veto |
 | Zuschauer | Zuschauercode | alles live verfolgen; sieht nur den CSTV-Zugang, nicht das Spielerpasswort |
@@ -201,22 +201,9 @@ Die Serververwaltung ist hinter [`server/src/servers/adapter.js`](server/src/ser
    - Wird alle `SERVER_STATUS_POLL_SECONDS` abgefragt, solange der Server startet, danach alle 30 s.
 3. **`configure(handle, plan)`**: in zwei Phasen.
    1. `game_type`, `game_mode`, `sv_password`, `tv_enable`, `tv_delay`, `tv_password`, dann `changelevel <map>`.
-   2. Warten, bis `status` die Map meldet (max. 2 Minuten), dann die Match-Einstellungen (`mp_teamname_1/2`, `mp_maxrounds`, `mp_overtime_enable`, `mp_match_can_clinch`, `mp_warmup_pausetimer 1`, `CS2_EXTRA_COMMANDS`) und die Turnierregeln (siehe unten).
+   2. Warten, bis `status` die Map meldet (max. 2 Minuten), dann die Match-Einstellungen (`mp_teamname_1/2`, `mp_maxrounds`, `mp_overtime_enable`, `mp_match_can_clinch`, `mp_warmup_pausetimer 1`, `CS2_EXTRA_COMMANDS`).
 
    Die zweite Phase kommt erst nach dem Mapwechsel, weil die `gamemode_*.cfg` des Spiels diese Werte beim Laden der Map sonst überschreibt.
-
-**Turnierregeln:** Jeder konfigurierte Server setzt außerdem diese Werte, die sich an FACEIT- und ESL-Richtwerten orientieren:
-
-| Befehl | Wert | Zweck |
-|---|---|---|
-| `sv_pausable` | `1` | erlaubt Pausen (`mp_pause_match`) |
-| `mp_halftime` | `1` | Seitenwechsel zur Halbzeit |
-| `mp_freezetime` | `20` | Freezetime in Sekunden |
-| `mp_buytime` | `20` | Kaufzeit in Sekunden |
-| `mp_startmoney` | `800` | Startgeld |
-| `mp_roundtime` | `1.92` | Rundenzeit in Minuten (1:55) |
-
-Die Werte stammen nicht aus einer Regel eines konkreten Turniers. Vor einem echten Turnier bitte mit dem Regelwerk des Veranstalters abgleichen und in `server/src/servers/cs2Config.js` anpassen. Ob `sv_pausable` und die Pause-Befehle am echten Server wirken, ist noch nicht getestet.
 4. **`stop(handle)`**: Server beenden bzw. freigeben.
 
 ### Option A: Docker (`SERVER_ADAPTER=docker`)
@@ -327,36 +314,17 @@ Unter `/stream` (in der Kopfzeile verlinkt) zeigt eine 1920×1080-Seite alle lau
 - **Raster:** passt sich der Anzahl an (1, 2, 4 oder 6 Karten). Bei mehr als 6 Matches blättert die Seite alle 12 Sekunden weiter.
 - **Unten:** offene Lobbys und die Ergebnisse der letzten drei Stunden.
 - **Datenschutz:** Codes und Verbindungsdaten erscheinen nicht.
-- **Einzelnes Match:** Ein Klick auf eine Karte oder einen Eintrag öffnet die Übersicht nur dieses Matches unter `/stream/match/<matchId>`. Der Link enthält keinen Zuschauercode, der Schlüssel `?key=` wird übernommen.
 - **Schlüssel:** Mit `STREAM_KEY` ist die Seite nur mit `/stream?key=<schlüssel>` erreichbar, sonst offen. `?bg=transparent` funktioniert ebenfalls.
 
 ### Stream-Übersicht eines Matches
 
 Unter `/stream/<Zuschauercode>` gibt es eine Vollbild-Übersicht für den Stream. Den Link findet der Organisator bei den Einladungen.
 
-Für die Übersicht eines einzelnen Matches ohne Zuschauercode gibt es `/stream/match/<matchId>`. Der Organisator findet den Link unter „Match-Übersicht“ im Bereich Einladungen. Ist `STREAM_KEY` gesetzt, hängt der Link den Schlüssel an, damit Organisatoren die Seite öffnen können.
-
 - **Format:** 1920×1080, skaliert auf jede Fenstergröße. In OBS als Browserquelle mit 1920×1080 einbinden. Mit `?bg=transparent` ist der Hintergrund durchsichtig.
 - **Ablauf:** Die Seite wechselt automatisch zwischen Lobby (Aufstellungen), Map-Veto (live) und Match (Spielstand, Rundenverlauf, Map-Leiste).
 - **Laufband:** zeigt das letzte für Zuschauer relevante Ereignis, keine technischen Servermeldungen.
 - **Datenschutz:** Verbindungsdaten und Passwörter erscheinen dort nie.
 
-### Discord-Meldungen für Streamer
-
-Mit `DISCORD_WEBHOOK_URL` schickt die Anwendung kurze Meldungen in einen Discord-Kanal:
-
-- Veto gestartet
-- Match gestartet (Aufwärmphase beendet)
-- Map beendet mit Ergebnis
-- Serie entschieden
-- Match abgeschlossen oder abgebrochen
-- Serverfehler
-
-Jede Meldung enthält einen Link auf die Match-Übersicht (`/stream/match/<id>`). Ist `STREAM_KEY` gesetzt, entfällt der Link, damit der Schlüssel nicht im Kanal landet. Ein Fehler beim Senden bremst den Matchablauf nicht. Er wird nur im Log vermerkt. Die Webhook-URL enthält ein Geheimnis und erscheint nie in Logs oder Oberflächen.
-
-Webhook anlegen: Discord-Kanal → Einstellungen → Integrationen → Webhooks → Neuer Webhook, dann die URL kopieren.
-
-Welche Ereignisse gemeldet werden, wählt der Admin im Admin-Bereich unter „Discord-Meldungen“. Die Auswahl wird in der Datenbank gespeichert. Die Webhook-URL bleibt in der Konfiguration, weil sie ein Geheimnis ist. Die Schaltfläche „Testmeldung senden“ prüft die Verbindung.
 ---
 
 ## Umgebungsvariablen
@@ -382,7 +350,6 @@ Alle Variablen mit Standardwerten stehen in [`.env.example`](.env.example). Die
 | `LOG_RECEIVER_URL` | `PUBLIC_URL` | Adresse, unter der der CS2-Server das Backend für Live-Logs erreicht |
 | `LOG_DEBUG` | `false` | empfangene Logzeilen im Terminal ausgeben |
 | `STREAM_KEY` | leer | Schlüssel für die Stream-Übersicht aller Matches (`/stream?key=…`); leer = offen |
-| `DISCORD_WEBHOOK_URL` | leer | Discord-Webhook für Meldungen zu Veto, Match-Start, Map- und Serienende sowie Serverfehlern; leer = aus |
 | `SERIES_AUTO_ADVANCE_SECONDS` | `30` | Wartezeit nach Map-Ende bis zur nächsten Map bzw. zum Abschluss; `-1` = manuell |
 
 Benötigte Zugangsdaten für den Echtbetrieb:
@@ -425,6 +392,6 @@ Alle Aktionen laufen per `POST` mit `Authorization: Bearer <token>`. Der Token i
 | `…/ready`, `…/leave` | Spieler |
 | `…/veto/action` `{stepIndex, map?, side?}` | Captain am Zug |
 | `…/captain` `{playerId}` | Organisator, Captain des Teams |
-| `…/veto/start`, `…/kick`, `…/codes/regenerate`, `…/server/retry`, `…/server/stop`, `…/server/warmup-end`, `…/server/pause`, `…/server/resume`, `…/series/next`, `…/finish`, `…/cancel` | Organisator |
+| `…/veto/start`, `…/kick`, `…/codes/regenerate`, `…/server/retry`, `…/server/stop`, `…/server/warmup-end`, `…/series/next`, `…/finish`, `…/cancel` | Organisator |
 
 Socket.IO: `match:subscribe {matchId, token}` liefert `match:state` bei jeder Änderung; `overview:subscribe` liefert `overview`.

client/src/pages/AdminPage.jsx

@@ -92,7 +92,6 @@ export default function AdminPage() {
         <button className="btn btn-sm" onClick={logout}>Abmelden</button>
       </header>
 
-      {token && <NotificationSettings token={token} setNotice={setNotice} />}
       {notice && <div className={`toast toast-${notice.tone}`} role="status">{notice.text}</div>}
       {error && <div className="alert alert-error">{error}</div>}
       {matches === null && !error && <p className="muted">Lade Matches …</p>}
@@ -107,73 +106,6 @@ export default function AdminPage() {
   );
 }
 
-/** Auswahl, welche Ereignisse Discord erhalten. Die Werte werden erst beim Speichern übernommen. */
-function NotificationSettings({ token, setNotice }) {
-  const [settings, setSettings] = useState(null);
-  const [events, setEvents] = useState({});
-  const [busy, setBusy] = useState(false);
-
-  useEffect(() => {
-    api('/admin/notifications', { token })
-      .then((res) => { setSettings(res); setEvents(res.events); })
-      .catch((err) => setNotice({ tone: 'error', text: err.message }));
-  }, [token, setNotice]);
-
-  const save = async () => {
-    setBusy(true);
-    try {
-      const res = await api('/admin/notifications', { method: 'PUT', body: { events }, token });
-      setSettings(res);
-      setEvents(res.events);
-      setNotice({ tone: 'ok', text: 'Meldungen gespeichert' });
-    } catch (err) {
-      setNotice({ tone: 'error', text: err.message });
-    } finally {
-      setBusy(false);
-    }
-  };
-
-  const test = async () => {
-    setBusy(true);
-    try {
-      await api('/admin/notifications/test', { method: 'POST', token });
-      setNotice({ tone: 'ok', text: 'Testmeldung gesendet' });
-    } catch (err) {
-      setNotice({ tone: 'error', text: err.message });
-    } finally {
-      setBusy(false);
-    }
-  };
-
-  if (!settings) return null;
-  const dirty = settings.catalog.some(({ key }) => !!events[key] !== settings.events[key]);
-
-  return (
-    <section className="admin-settings">
-      <h2>Discord-Meldungen</h2>
-      {!settings.enabled && (
-        <p className="alert alert-error">Kein Webhook eingerichtet. Setze DISCORD_WEBHOOK_URL und starte die Anwendung neu.</p>
-      )}
-      <div className="admin-settings-grid">
-        {settings.catalog.map(({ key, label }) => (
-          <label key={key} className="admin-check">
-            <input
-              type="checkbox"
-              checked={!!events[key]}
-              onChange={(e) => setEvents({ ...events, [key]: e.target.checked })}
-            />
-            {label}
-          </label>
-        ))}
-      </div>
-      <div className="admin-actions">
-        <button className="btn btn-sm btn-primary" onClick={save} disabled={busy || !dirty}>Speichern</button>
-        <button className="btn btn-sm" onClick={test} disabled={busy || !settings.enabled}>Testmeldung senden</button>
-      </div>
-    </section>
-  );
-}
-
 function AdminLogin({ onLogin }) {
   const [password, setPassword] = useState('');
   const [error, setError] = useState(null);
@@ -285,8 +217,6 @@ function MatchAdminCard({ m, run, busy, token, reload, setNotice }) {
         <Link className="btn btn-sm" to={`/m/${id}`}>Ansehen</Link>
         {m.status === 'lobby' && btn('Veto starten', { path: '/veto/start' }, 'btn-primary')}
         {(m.server?.status === 'configured') && btn('Aufwärmphase beenden', { path: '/server/warmup-end' })}
-        {(m.server?.status === 'configured') && btn('Pausieren', { path: '/server/pause', confirm: 'Match pausieren?' })}
-        {(m.server?.status === 'configured') && btn('Fortsetzen', { path: '/server/resume' })}
         {(m.server?.status === 'configured') && hasNext && btn('Nächste Map', { path: '/series/next' })}
         {m.server && ['start_failed', 'failed', 'stopped', 'config_failed', 'ready'].includes(m.server.status) && !closed &&
           btn('Server neu starten / wiederholen', { path: '/server/retry' })}

client/src/styles.css

@@ -512,8 +512,3 @@ input:focus, select:focus { border-color: var(--link); outline: none; }
 .rollback h3 { margin: 0 0 8px; display: flex; align-items: center; gap: 10px; }
 .rollback select { min-width: 200px; }
 .admin-badge { font: 600 .75rem var(--body); color: #fff; background: var(--brand-red); padding: 2px 8px; border-radius: 3px; }
-
-.admin-settings { border: 1px solid var(--line); background: var(--surface); border-radius: var(--radius); padding: 16px 20px; margin-bottom: 20px; }
-.admin-settings h2 { margin: 0 0 12px; font-size: 1.1rem; }
-.admin-settings-grid { display: grid; grid-template-columns: repeat(auto-fill, minmax(260px, 1fr)); gap: 8px 16px; margin-bottom: 12px; }
-.admin-check { display: flex; align-items: center; gap: 8px; cursor: pointer; }

server/src/adminRoutes.js

@@ -76,17 +76,6 @@ export function createAdminRouter({ service, manager, config }) {
 
   router.get('/session', requireAdmin, (req, res) => res.json({ ok: true }));
 
-  // Discord-Meldungen: welche Ereignisse gemeldet werden
-  router.get('/notifications', requireAdmin, wrap(() => service.notificationSettings()));
-  router.put('/notifications', requireAdmin, wrap((req) => service.setNotificationEvents(req.body?.events)));
-  router.post('/notifications/test', requireAdmin, wrap(async () => {
-    if (!service.notifier.enabled) throw new HttpError(409, 'Kein Discord-Webhook eingerichtet (DISCORD_WEBHOOK_URL)', 'not_configured');
-    if (!(await service.notifier.send('Testmeldung aus CS2 Mapveto'))) {
-      throw new HttpError(502, 'Discord hat die Meldung nicht angenommen (siehe Log)', 'send_failed');
-    }
-    return { ok: true };
-  }));
-
   // Alle Matches mit allen Details (Codes, Verbindungsdaten, Spieler, Veto, Serie, Ereignisse)
   router.get('/matches', requireAdmin, wrap(() => {
     const ids = service.db.prepare('SELECT id FROM matches ORDER BY created_at DESC LIMIT 100').all();
@@ -103,8 +92,6 @@ export function createAdminRouter({ service, manager, config }) {
   action('server/stop', (v) => manager.stopByOrganizer(v));
   action('server/retry', (v) => manager.retry(v));
   action('server/warmup-end', (v) => manager.endWarmup(v));
-  action('server/pause', (v) => manager.setPaused(v, true));
-  action('server/resume', (v) => manager.setPaused(v, false));
   action('series/next', (v) => manager.loadNextMap(v));
   action('veto/start', (v) => service.startVeto(v));
   action('veto/action', (v, b) => service.vetoAction(

server/src/app.js

@@ -5,7 +5,6 @@ import express from 'express';
 import { REPO_ROOT } from './config.js';
 import { openDatabase } from './db.js';
 import { createApiRouter } from './http.js';
-import { createDiscordNotifier } from './discord.js';
 import { loadMapPools } from './mapPools.js';
 import { MatchService } from './matchService.js';
 import { attachRealtime } from './realtime.js';
@@ -16,8 +15,7 @@ import { ServerManager } from './servers/serverManager.js';
 export function createApp(config, { adapter: adapterOverride, logger = console } = {}) {
   const db = openDatabase(config.databaseFile);
   const pools = loadMapPools(config.mapPoolFile);
-  const notifier = createDiscordNotifier(config.discordWebhookUrl, { logger });
-  const service = new MatchService({ db, pools, config, notifier });
+  const service = new MatchService({ db, pools, config });
 
   let manager;
   const adapter = adapterOverride ?? createServerAdapter(config, { getUsedPorts: () => manager.usedPorts() });

server/src/config.js

@@ -41,7 +41,6 @@ export function loadConfig(overrides = {}) {
     createMatchPassword: str('CREATE_MATCH_PASSWORD'),
     // Optionaler Schlüssel für die Stream-Übersicht aller Matches (/stream?key=…); leer = offen
     streamKey: str('STREAM_KEY'),
-    discordWebhookUrl: str('DISCORD_WEBHOOK_URL'),
     // Passwort für den Admin-Modus (/admin). Leer = Admin-Modus ist aus.
     adminPassword: str('ADMIN_PASSWORD'),
     requireFullTeams: bool('REQUIRE_FULL_TEAMS', false),

server/src/db.js

@@ -97,10 +97,6 @@ CREATE TABLE IF NOT EXISTS events (
   created_at INTEGER NOT NULL
 );
 CREATE INDEX IF NOT EXISTS events_match ON events(match_id, id);
-CREATE TABLE IF NOT EXISTS settings (
-  key TEXT PRIMARY KEY,
-  value TEXT NOT NULL
-);
 `;
 
 export function openDatabase(file) {

server/src/discord.js

@@ -1,46 +0,0 @@
-// Meldungen an einen Discord-Webhook, z. B. für Streamer. Fehler werden nur protokolliert
-// und bremsen den Matchablauf nie aus.
-
-const WEBHOOK_PATTERN = /^https:\/\/(discord\.com|discordapp\.com)\/api\/webhooks\/\d+\/[\w-]+$/;
-const TIMEOUT_MS = 5000;
-const MAX_LENGTH = 1900;
-
-/** Ereignisse, die gemeldet werden können. Alle sind standardmäßig aktiv. */
-export const NOTIFY_EVENTS = [
-  { key: 'veto_start', label: 'Veto gestartet' },
-  { key: 'match_start', label: 'Match gestartet (Aufwärmphase beendet)' },
-  { key: 'map_end', label: 'Map beendet (mit Ergebnis)' },
-  { key: 'series_end', label: 'Serie entschieden' },
-  { key: 'match_closed', label: 'Match abgeschlossen oder abgebrochen' },
-  { key: 'server_error', label: 'Serverfehler' },
-];
-
-/**
- * @param {string} url      Webhook-URL aus DISCORD_WEBHOOK_URL, leer = keine Meldungen
- * @param {object} options  fetchImpl und logger, vor allem für Tests
- */
-export function createDiscordNotifier(url, { fetchImpl = fetch, logger = console } = {}) {
-  if (!url) return { enabled: false, send: async () => false };
-  // Die URL enthält ein Geheimnis. Sie wird deshalb nie in Fehlermeldungen ausgegeben.
-  if (!WEBHOOK_PATTERN.test(url)) throw new Error('DISCORD_WEBHOOK_URL ist keine gültige Discord-Webhook-URL');
-
-  return {
-    enabled: true,
-    /** Liefert true, wenn Discord die Nachricht angenommen hat. */
-    async send(content) {
-      try {
-        const res = await fetchImpl(url, {
-          method: 'POST',
-          headers: { 'Content-Type': 'application/json' },
-          body: JSON.stringify({ content: content.slice(0, MAX_LENGTH) }),
-          signal: AbortSignal.timeout(TIMEOUT_MS),
-        });
-        if (res.ok) return true;
-        logger.warn(`Discord-Webhook antwortet mit HTTP ${res.status}`);
-      } catch (err) {
-        logger.warn(`Discord-Meldung fehlgeschlagen: ${err.name}`);
-      }
-      return false;
-    },
-  };
-}

server/src/matchService.js

@@ -4,7 +4,6 @@ import { formatCode, hashToken, normalizeCode, randomCode, randomId, randomToken
 import { applyLogLines, initialLiveState, seriesScore, splitLogBody } from './liveScore.js';
 import { trimLiveState } from './rounds.js';
 import { sanitizeConsoleText } from './servers/cs2Config.js';
-import { NOTIFY_EVENTS } from './discord.js';
 
 export class HttpError extends Error {
   constructor(status, message, code = 'error') {
@@ -42,12 +41,11 @@ function cleanSteamId(value) {
 }
 
 export class MatchService extends EventEmitter {
-  constructor({ db, pools, config, notifier = { enabled: false, send: async () => {} } }) {
+  constructor({ db, pools, config }) {
     super();
     this.db = db;
     this.pools = pools;
     this.config = config;
-    this.notifier = notifier;
     this.presence = () => new Set();
   }
 
@@ -341,7 +339,6 @@ export class MatchService extends EventEmitter {
         .run(firstTeam, this.now(), this.now(), match.id);
       const how = match.veto_start === 'coin' ? 'per Münzwurf ausgelost' : 'vom Organisator festgelegt';
       this.log(match.id, 'veto', `Veto gestartet – ${this.teamName(match, firstTeam)} beginnt (${how})`);
-      this.notify('veto_start', match.id, `Veto gestartet: ${this.matchTitle(match.id)}, ${this.teamName(match, firstTeam)} beginnt`);
     })();
     this.changed(viewer.matchId);
   }
@@ -519,8 +516,6 @@ export class MatchService extends EventEmitter {
         const winner = state.winner ? this.teamName(match, state.winner) : 'Unentschieden';
         this.log(matchId, 'score',
           `Map ${row.number} (${this.mapName(match, row.map)}) beendet: ${match.team_a_name} ${state.score.A}:${state.score.B} ${match.team_b_name} – Sieger: ${winner}`);
-        this.notify('map_end', matchId, `${this.matchTitle(matchId)}
-Map ${row.number} (${this.mapName(match, row.map)}) beendet: ${state.score.A}:${state.score.B}, Sieger ${winner}`);
       }
     })();
     if (ended) {
@@ -529,8 +524,6 @@ Map ${row.number} (${this.mapName(match, row.map)}) beendet: ${state.score.A}:${
       const needed = Math.floor(BEST_OF[ended.match.format] / 2) + 1;
       const decided = score.A >= needed ? 'A' : score.B >= needed ? 'B' : null;
       if (decided) this.log(matchId, 'score', `Serie entschieden: ${this.teamName(ended.match, decided)} gewinnt ${score[decided]}:${score[decided === 'A' ? 'B' : 'A']}`);
-      if (decided) this.notify('series_end', matchId, `${this.matchTitle(matchId)}
-Serie entschieden: ${this.teamName(ended.match, decided)} gewinnt ${score[decided]}:${score[decided === 'A' ? 'B' : 'A']}`);
       const hasNext = maps.some((m) => m.number === ended.row.number + 1);
       this.changed(matchId);
       this.emit('mapEnded', { matchId, number: ended.row.number, decided, hasNext });
@@ -562,8 +555,6 @@ Serie entschieden: ${this.teamName(ended.match, decided)} gewinnt ${score[decide
       this.db.prepare("UPDATE series_maps SET status = 'done' WHERE match_id = ? AND status IN ('live','next')").run(match.id);
     }
     this.log(match.id, 'status', message ?? (status === 'finished' ? 'Match abgeschlossen' : 'Match abgebrochen'));
-    this.notify('match_closed', match.id, `${this.matchTitle(match.id)}
-${message ?? (status === 'finished' ? 'Match abgeschlossen' : 'Match abgebrochen')}`);
     this.setStatus(match.id, status);
     this.emit('closed', match.id);
   }
@@ -578,45 +569,6 @@ ${message ?? (status === 'finished' ? 'Match abgeschlossen' : 'Match abgebrochen
     this.db.prepare('UPDATE matches SET last_activity_at = ? WHERE id = ?').run(this.now(), matchId);
   }
 
-  /** Titel für Meldungen, z. B. „Team A vs. Team B (BO3)“. */
-  matchTitle(matchId) {
-    const m = this.getMatch(matchId);
-    return `${m.team_a_name} vs. ${m.team_b_name} (${m.format.toUpperCase()})`;
-  }
-
-  /**
-   * Meldung an den Discord-Webhook, falls konfiguriert. Ohne Stream-Schlüssel gehört die Übersicht
-   * des Matches dazu, mit Schlüssel entfällt der Link, damit der Schlüssel nicht in den Kanal gelangt.
-   */
-  /** Discord-Meldungen: der Webhook muss eingerichtet und das Ereignis ausgewählt sein. */
-  notificationSettings() {
-    const row = this.db.prepare("SELECT value FROM settings WHERE key = 'discord_events'").get();
-    let stored = {};
-    try {
-      stored = row ? JSON.parse(row.value) : {};
-    } catch {
-      stored = {};
-    }
-    const events = Object.fromEntries(NOTIFY_EVENTS.map(({ key }) => [key, stored[key] !== false]));
-    return { enabled: this.notifier.enabled, events, catalog: NOTIFY_EVENTS };
-  }
-
-  setNotificationEvents(input) {
-    if (!input || typeof input !== 'object') throw new HttpError(400, 'Ungültige Auswahl der Meldungen', 'invalid');
-    const events = Object.fromEntries(NOTIFY_EVENTS.map(({ key }) => [key, input[key] === true]));
-    this.db
-      .prepare("INSERT INTO settings (key, value) VALUES ('discord_events', ?) ON CONFLICT(key) DO UPDATE SET value = excluded.value")
-      .run(JSON.stringify(events));
-    return this.notificationSettings();
-  }
-
-  notify(type, matchId, text) {
-    if (!this.notifier.enabled || !this.notificationSettings().events[type]) return;
-    const link = this.config.streamKey ? '' : `
-${this.config.publicUrl}/stream/match/${matchId}`;
-    this.notifier.send(`${text}${link}`);
-  }
-
   log(matchId, type, message) {
     this.db
       .prepare('INSERT INTO events (match_id, type, message, created_at) VALUES (?, ?, ?, ?)')

server/src/servers/cs2Config.js

@@ -63,13 +63,6 @@ export function buildMapCommands({ match, pool, seriesMap, secrets, settings, lo
     'mp_limitteams 0',
     // Aufwärmphase läuft, bis der Organisator das Match startet (mp_warmup_end)
     'mp_warmup_pausetimer 1',
-    // Turnierregeln (FACEIT/ESL-Richtwerte): Pausen erlauben, feste Rundenzeiten, Halbzeit
-    'sv_pausable 1',
-    'mp_halftime 1',
-    'mp_freezetime 20',
-    'mp_buytime 20',
-    'mp_startmoney 800',
-    'mp_roundtime 1.92',
     ...settings.extraCommands,
   ];
 

server/src/servers/serverManager.js

@@ -265,7 +265,6 @@ export class ServerManager {
     } else if (status.state === 'failed') {
       Object.assign(fields, { status: current.status === 'starting' ? 'start_failed' : 'failed', message: status.message });
       this.service.log(matchId, 'server', `Server-Fehler: ${status.message}`);
-      this.service.notify('server_error', matchId, `Server-Fehler bei ${this.service.matchTitle(matchId)}: ${status.message}`);
     } else if (status.state === 'stopped') {
       Object.assign(fields, { status: 'stopped', stopped_at: Date.now(), message: status.message ?? 'Server wurde extern beendet' });
       this.service.log(matchId, 'server', 'Server wurde außerhalb der Anwendung beendet');
@@ -388,26 +387,10 @@ export class ServerManager {
       throw new HttpError(502, `Befehl konnte nicht gesendet werden: ${err.message}`, 'server_error');
     }
     this.service.log(viewer.matchId, 'server', this.adapter.simulated ? 'Aufwärmphase beendet (simuliert)' : 'Aufwärmphase beendet – Match startet');
-    this.service.notify('match_start', viewer.matchId, `Match gestartet: ${this.service.matchTitle(viewer.matchId)}`);
     if (this.adapter.simulated) this.startDemoSimulation(viewer.matchId);
     this.service.changed(viewer.matchId);
   }
 
-  /** Admin: pausiert oder setzt das laufende Match auf dem Server fort (mp_pause_match / mp_unpause_match). */
-  async setPaused(viewer, paused) {
-    this.service.require(viewer, 'organizer');
-    const row = this.row(viewer.matchId);
-    if (row?.status !== 'configured') throw new HttpError(409, 'Der Server ist nicht bereit', 'wrong_state');
-    if (!this.adapter.sendCommands) throw new HttpError(501, 'Dieser Adapter unterstützt keine Befehle', 'unsupported');
-    try {
-      await this.adapter.sendCommands(JSON.parse(row.handle), [paused ? 'mp_pause_match' : 'mp_unpause_match']);
-    } catch (err) {
-      throw new HttpError(502, `Befehl konnte nicht gesendet werden: ${err.message}`, 'server_error');
-    }
-    this.service.log(viewer.matchId, 'server', paused ? 'Match pausiert (Admin)' : 'Match fortgesetzt (Admin)');
-    this.service.changed(viewer.matchId);
-  }
-
   /** Demo-Modus: simuliert einen Matchverlauf, indem echte CS2-Logzeilen erzeugt und ausgewertet werden. */
   startDemoSimulation(matchId) {
     const match = this.service.getMatch(matchId);

server/test/api.test.js

@@ -401,7 +401,6 @@ test('Admin-Modus: Anmeldung, Verwaltung aller Matches, Sperre ohne Anmeldung',
 
     // Ein Match abbrechen wie ein Admin
     assert.equal((await call('POST', `/admin/matches/${id}/cancel`, { ...admin, body: {} })).status, 200);
-    assert.equal((await call('POST', `/admin/matches/${id}/server/pause`, { ...admin, body: {} })).status, 409, 'ohne Server keine Pause');
     assert.equal(app.service.getMatch(id).status, 'cancelled');
 
     // Endgültig löschen

server/test/discord.test.js

@@ -1,46 +0,0 @@
-import { test } from 'node:test';
-import assert from 'node:assert/strict';
-import { createDiscordNotifier } from '../src/discord.js';
-
-const URL_OK = 'https://discord.com/api/webhooks/123456/geheim_TOKEN-1';
-
-test('Ohne URL ist der Notifier aus und tut nichts', async () => {
-  let called = false;
-  const n = createDiscordNotifier('', { fetchImpl: async () => { called = true; } });
-  assert.equal(n.enabled, false);
-  await n.send('Test');
-  assert.equal(called, false);
-});
-
-test('Ungültige URL wird beim Start abgelehnt, ohne die URL zu zeigen', () => {
-  assert.throws(() => createDiscordNotifier('https://example.com/geheim'), (err) => {
-    assert.match(err.message, /keine gültige Discord-Webhook-URL/);
-    assert.ok(!err.message.includes('geheim'));
-    return true;
-  });
-});
-
-test('Nachricht wird als JSON an den Webhook geschickt, überlange Texte gekürzt', async () => {
-  const sent = [];
-  const n = createDiscordNotifier(URL_OK, {
-    fetchImpl: async (url, init) => { sent.push({ url, init }); return { ok: true, status: 204 }; },
-  });
-  await n.send('Hallo');
-  await n.send('x'.repeat(5000));
-  assert.equal(sent[0].url, URL_OK);
-  assert.equal(sent[0].init.method, 'POST');
-  assert.equal(JSON.parse(sent[0].init.body).content, 'Hallo');
-  assert.equal(JSON.parse(sent[1].init.body).content.length, 1900);
-});
-
-test('Fehler des Webhooks brechen den Ablauf nicht ab und werden protokolliert ohne URL', async () => {
-  const warnings = [];
-  const logger = { warn: (m) => warnings.push(m) };
-  const failing = createDiscordNotifier(URL_OK, { logger, fetchImpl: async () => { throw new TypeError('fetch failed'); } });
-  await failing.send('Test');
-  const bad = createDiscordNotifier(URL_OK, { logger, fetchImpl: async () => ({ ok: false, status: 404 }) });
-  await bad.send('Test');
-  assert.equal(warnings.length, 2);
-  assert.match(warnings[1], /HTTP 404/);
-  assert.ok(warnings.every((w) => !w.includes('TOKEN')));
-});

server/test/rcon.test.js

@@ -64,8 +64,6 @@ test('Konsolentexte können keine Befehle einschleusen', () => {
   assert.ok(afterMapChange.includes('mp_teamname_1 "Bravo"'));
   assert.ok(afterMapChange.includes('mp_teamname_2 "Alphaquit"'));
   assert.ok(afterMapChange.includes('mp_maxrounds 16'));
-  assert.ok(afterMapChange.includes('sv_pausable 1'), 'Pausen-Knopf braucht sv_pausable');
-  assert.ok(afterMapChange.includes('mp_freezetime 20'));
 });
 
 test('Log-Weiterleitung wird vor dem Mapwechsel gesetzt, unsichere URLs nicht', () => {