Entfernt die myTischtennis-Integration aus dem Backend und Frontend. Löscht Controller, Routen und Service für myTischtennis. Aktualisiert die Datenmodelle, um die neue ExternalServiceAccount-Integration zu unterstützen. Ändert die API-Routen und Frontend-Komponenten, um die neuen Endpunkte zu verwenden.

backend/clients/hettvClient.js

@@ -0,0 +1,603 @@
+import axios from 'axios';
+import fs from 'fs';
+import path from 'path';
+
+const BASE_URL = 'https://ttde-id.liga.nu';
+const CLICK_TT_BASE = 'https://httv.click-tt.de';
+
+class HettvClient {
+  constructor() {
+    this.baseURL = BASE_URL;
+    this.client = axios.create({
+      baseURL: this.baseURL,
+      timeout: 15000,
+      headers: {
+        'Content-Type': 'application/x-www-form-urlencoded',
+        'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
+        'Accept-Language': 'de-DE,de;q=0.9,en-US;q=0.8,en;q=0.7'
+      },
+      maxRedirects: 5, // Folge den OAuth2-Redirects
+      validateStatus: (status) => status >= 200 && status < 400
+    });
+
+    // Einfache Cookie-Jar nach Host -> { name: value }
+    this.cookieJar = new Map();
+    this.defaultHeaders = {
+      'User-Agent': 'Mozilla/5.0 (X11; Linux x86_64; rv:141.0) Gecko/20100101 Firefox/141.0',
+      'Accept-Language': 'de-DE,de;q=0.9,en-US;q=0.8,en;q=0.7'
+    };
+  }
+
+  /**
+   * Login to HeTTV via OAuth2
+   * @param {string} username - HeTTV username (email)
+   * @param {string} password - HeTTV password
+   * @returns {Promise<Object>} Login response with session data
+   */
+  async login(username, password) {
+    try {
+      console.log('[HettvClient] - Starting login for:', username);
+      
+      // Schritt 1: OAuth2-Authorization-Endpoint aufrufen - das sollte zur Login-Seite weiterleiten
+      const oauthParams = new URLSearchParams({
+        'scope': 'nuLiga',
+        'response_type': 'code',
+        'redirect_uri': 'https://httv.click-tt.de/cgi-bin/WebObjects/nuLigaTTDE.woa/wa/oAuthLogin',
+        'state': 'nonce=' + Math.random().toString(36).substring(2, 15),
+        'client_id': 'XtVpGjXKAhz3BZuu'
+      });
+      
+      // OAuth2 Start
+      
+      // Der OAuth2-Endpoint sollte direkt zur Login-Seite weiterleiten
+      const loginPageResponse = await this.client.get(`/oauth2/authz/ttde?${oauthParams.toString()}`, {
+        maxRedirects: 5, // Folge den Redirects zur Login-Seite
+        validateStatus: (status) => status >= 200 && status < 400,
+        headers: {
+          ...this.defaultHeaders
+        }
+      });
+      
+      // Login-Seite erreicht
+      
+      // Session-Cookie aus der Login-Seite extrahieren
+      const setCookies = loginPageResponse.headers['set-cookie'];
+      if (!setCookies || !Array.isArray(setCookies)) {
+        console.error('[HettvClient] - No cookies from login page');
+        return {
+          success: false,
+          error: 'Keine Session-Cookie von Login-Seite erhalten'
+        };
+      }
+      
+      const sessionCookie = setCookies.find(cookie => cookie.startsWith('nusportingress='));
+      if (!sessionCookie) {
+        console.error('[HettvClient] - No nusportingress cookie from login page');
+        return {
+          success: false,
+          error: 'Keine nusportingress Session von Login-Seite erhalten'
+        };
+      }
+      
+      // Extrahiere t:formdata aus dem HTML der Login-Seite
+      const htmlContent = loginPageResponse.data;
+      // HTML erhalten
+      
+      // Suche nach t:formdata im HTML - verschiedene mögliche Formate
+      let formDataMatch = htmlContent.match(/name="t:formdata"\s+value="([^"]+)"/);
+      
+      if (!formDataMatch) {
+        // Versuche andere Formate
+        formDataMatch = htmlContent.match(/name='t:formdata'\s+value='([^']+)'/);
+      }
+      
+      if (!formDataMatch) {
+        // Suche nach hidden input mit t:formdata (value vor name)
+        formDataMatch = htmlContent.match(/<input[^>]*value="([^"]+)"[^>]*name="t:formdata"/);
+      }
+      
+      if (!formDataMatch) {
+        // Suche nach hidden input mit t:formdata (name vor value)
+        formDataMatch = htmlContent.match(/<input[^>]*name="t:formdata"[^>]*value="([^"]+)"/);
+      }
+      
+      if (!formDataMatch) {
+        // Suche nach t:formdata ohne Anführungszeichen
+        formDataMatch = htmlContent.match(/name=t:formdata\s+value=([^\s>]+)/);
+      }
+      
+      if (!formDataMatch) {
+        console.error('[HettvClient] - No t:formdata found in login page');
+        console.log('[HettvClient] - HTML snippet:', htmlContent.substring(0, 2000));
+        
+        // Debug: Suche nach allen hidden inputs
+        const hiddenInputs = htmlContent.match(/<input[^>]*type="hidden"[^>]*>/g);
+        console.log('[HettvClient] - Hidden inputs found:', hiddenInputs);
+        
+        return {
+          success: false,
+          error: 'Keine t:formdata von Login-Seite erhalten'
+        };
+      }
+      
+      const tFormData = formDataMatch[1];
+      // CSRF-Token gefunden
+      
+      // Schritt 2: Login mit den korrekten Daten durchführen
+      // Verwende die Session-Cookie für den Login-Request
+      const formData = new URLSearchParams();
+      formData.append('t:submit', '["submit_0","submit_0"]');
+      formData.append('t:ac', 'ttde');
+      formData.append('t:formdata', tFormData);
+      formData.append('username', username);
+      formData.append('password', password);
+      
+      const loginResponse = await this.client.post('/oauth2/login.loginform', formData.toString(), {
+        headers: {
+          'Cookie': sessionCookie.split(';')[0],
+          'Content-Type': 'application/x-www-form-urlencoded',
+          'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
+          ...this.defaultHeaders,
+          'Referer': `${BASE_URL}/oauth2/login.loginform`
+        },
+        maxRedirects: 5,
+        validateStatus: (status) => status >= 200 && status < 400
+      });
+
+      // Login-Antwort erhalten
+      
+      // Prüfe ob wir erfolgreich eingeloggt sind
+      // Login-Response geprüft
+      
+      // Prüfe den Response-Inhalt um zu sehen ob wir noch auf der Login-Seite sind
+      const responseContent = loginResponse.data;
+      const isLoginPage = responseContent.includes('click-TT ID') && 
+                         responseContent.includes('Username') && 
+                         responseContent.includes('Password');
+      
+      // Login-Page-Erkennung durchgeführt
+      
+      if (isLoginPage) {
+        console.log('[HettvClient] - Still on login page, login failed');
+        console.log('[HettvClient] - Response snippet:', responseContent.substring(0, 500));
+        return {
+          success: false,
+          error: 'Login fehlgeschlagen - ungültige Zugangsdaten'
+        };
+      }
+      
+      // Prüfe auf OAuth2-Redirect oder Erfolg
+      const hasOAuthRedirect = responseContent.includes('oauth2') || 
+                              responseContent.includes('redirect') ||
+                              loginResponse.status >= 300;
+      
+      // OAuth Redirect erkannt
+      
+      // Extrahiere die finale Session-Cookie
+      const finalCookies = loginResponse.headers['set-cookie'];
+      const finalSessionCookie = finalCookies?.find(cookie => cookie.startsWith('nusportingress='));
+      
+      const sessionId = (finalSessionCookie || sessionCookie).match(/nusportingress=([^;]+)/)?.[1];
+      
+      console.log('[HettvClient] - Login erfolgreich (HeTTV).');
+
+      // Versuche die finale OAuth-Weiterleitung zu httv.click-tt.de aufzurufen, um PHPSESSID zu erhalten
+      let finalUrl = loginResponse.request?.res?.responseUrl;
+      console.log('[HettvClient] - Login finalUrl:', finalUrl);
+      let phpSessIdCookie = null;
+      let finalHtml = null;
+      try {
+        if (finalUrl && finalUrl.includes('oAuthLogin')) {
+          const clickTTClient = axios.create({
+            timeout: 15000,
+            maxRedirects: 0,
+            validateStatus: (status) => status >= 200 && status < 400
+          });
+
+          // Folge der Redirect-Kette manuell, übernehme Cookies
+          let currentUrl = finalUrl;
+          let lastResp = null;
+          let hop = 0;
+          const maxHops = 10;
+          while (hop++ < maxHops && currentUrl) {
+            lastResp = await clickTTClient.get(currentUrl, {
+              headers: {
+                'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
+                ...this.defaultHeaders,
+                'Referer': hop === 1 ? `${BASE_URL}/oauth2/login.loginform` : (lastResp?.request?.res?.responseUrl || currentUrl),
+                'Cookie': this._cookieHeaderForUrl(currentUrl)
+              }
+            });
+
+            this._ingestSetCookiesFromResponse(currentUrl, lastResp.headers['set-cookie']);
+
+            const loc = lastResp.headers['location'];
+            if (loc) {
+              // Absolut vs relativ
+              if (/^https?:\/\//i.test(loc)) {
+                currentUrl = loc;
+              } else {
+                const u = new URL(currentUrl);
+                currentUrl = `${u.origin}${loc}`;
+              }
+              continue;
+            }
+            break; // keine weitere Location => final
+          }
+
+          const clickTTResp = lastResp;
+          finalHtml = typeof clickTTResp.data === 'string' ? clickTTResp.data : '';
+          const ctSetCookies = clickTTResp.headers['set-cookie'];
+          if (Array.isArray(ctSetCookies)) {
+            phpSessIdCookie = ctSetCookies.find(c => c.startsWith('PHPSESSID='))?.split(';')[0] || null;
+          }
+          // Finale click-TT URL ermittelt
+        }
+      } catch (e) {
+        // Finale click-TT Seite konnte nicht geladen werden
+      }
+
+      // Baue kombinierte Cookie-Kette (falls PHPSESSID vorhanden)
+      const baseCookie = (finalSessionCookie || sessionCookie).split(';')[0];
+      const combinedCookie = phpSessIdCookie ? `${baseCookie}; ${phpSessIdCookie}` : baseCookie;
+
+      return {
+        success: true,
+        sessionId: sessionId,
+        cookie: combinedCookie,
+        accessToken: null,
+        refreshToken: null,
+        expiresAt: null,
+        user: {
+          finalUrl: finalUrl || null,
+          htmlSnippet: finalHtml ? finalHtml.substring(0, 2000) : null
+        }
+      };
+    } catch (error) {
+      console.error('HeTTV login error:', error.message);
+      console.error('Error details:', error.response?.status, error.response?.statusText);
+      return {
+        success: false,
+        error: error.response?.data?.message || 'Login fehlgeschlagen',
+        status: error.response?.status || 500
+      };
+    }
+  }
+
+  /**
+   * Verify login credentials
+   * @param {string} username - HeTTV username
+   * @param {string} password - HeTTV password
+   * @returns {Promise<boolean>} True if credentials are valid
+   */
+  async verifyCredentials(username, password) {
+    const result = await this.login(username, password);
+    return result.success;
+  }
+
+  /**
+   * Make an authenticated request to click-TT
+   * @param {string} endpoint - API endpoint
+   * @param {string} cookie - JSESSIONID cookie
+   * @param {Object} options - Additional axios options
+   * @returns {Promise<Object>} API response
+   */
+  async authenticatedRequest(endpoint, cookie, options = {}, finalUrl = null) {
+    try {
+      // Bestimme Basis-URL dynamisch aus finalUrl, falls vorhanden
+      let baseURL = CLICK_TT_BASE;
+      if (finalUrl) {
+        try {
+          const url = new URL(finalUrl);
+          baseURL = url.origin;
+        } catch (_) {}
+      }
+
+      const isAbsolute = /^https?:\/\//i.test(endpoint);
+      const client = axios.create({
+        baseURL: isAbsolute ? undefined : baseURL,
+        timeout: 15000,
+        maxRedirects: 0,
+        validateStatus: (status) => status >= 200 && status < 400
+      });
+
+      // Manuelles Redirect-Following inkl. Cookies/Referer
+      let currentUrl = isAbsolute ? endpoint : `${baseURL}${endpoint.startsWith('/') ? '' : '/'}${endpoint}`;
+      let lastResp = null;
+      const trace = [];
+      let hop = 0;
+      const maxHops = 10;
+      
+      console.log(`[HettvClient] - Starting redirect chain from: ${currentUrl}`);
+      
+      while (hop++ < maxHops && currentUrl) {
+        console.log(`[HettvClient] - Redirect ${hop}: GET ${currentUrl}`);
+        
+        lastResp = await client.request({
+          method: options.method || 'GET',
+          url: currentUrl,
+          data: options.data,
+          headers: {
+            ...this.defaultHeaders,
+            ...(options.headers || {}),
+            'Cookie': this._mergeCookieHeader(cookie, this._cookieHeaderForUrl(currentUrl)),
+            'Referer': hop === 1 ? (finalUrl || baseURL) : (lastResp?.request?.res?.responseUrl || currentUrl)
+          }
+        });
+
+        this._ingestSetCookiesFromResponse(currentUrl, lastResp.headers['set-cookie']);
+        const loc = lastResp.headers['location'];
+        
+        console.log(`[HettvClient] - Response: ${lastResp.status} ${lastResp.statusText}`);
+        console.log(`[HettvClient] - Location header: ${loc || 'none'}`);
+        console.log(`[HettvClient] - Set-Cookie header: ${lastResp.headers['set-cookie'] ? 'present' : 'none'}`);
+        console.log(`[HettvClient] - Content-Type: ${lastResp.headers['content-type'] || 'none'}`);
+        
+        // Speichere jede Seite zur Analyse
+        try {
+          const dir = path.resolve(process.cwd(), 'backend', 'uploads');
+          if (!fs.existsSync(dir)) {
+            fs.mkdirSync(dir, { recursive: true });
+          }
+          const filename = `hettv_redirect_${hop}_${Date.now()}.html`;
+          const filePath = path.join(dir, filename);
+          const content = typeof lastResp.data === 'string' ? lastResp.data : JSON.stringify(lastResp.data, null, 2);
+          fs.writeFileSync(filePath, content, 'utf8');
+          console.log(`[HettvClient] - Saved page to: ${filename}`);
+        } catch (e) {
+          console.log(`[HettvClient] - Could not save page ${hop}:`, e.message);
+        }
+        
+        trace.push({
+          url: currentUrl,
+          status: lastResp.status,
+          location: loc || null
+        });
+        
+        if (loc) {
+          const newUrl = /^https?:\/\//i.test(loc) ? loc : `${new URL(currentUrl).origin}${loc}`;
+          console.log(`[HettvClient] - Following redirect to: ${newUrl}`);
+          currentUrl = newUrl;
+          continue;
+        }
+        
+        console.log(`[HettvClient] - Final response: ${lastResp.status} (no more redirects)`);
+        break;
+      }
+      
+      return {
+        success: true,
+        data: lastResp?.data,
+        trace
+      };
+    } catch (error) {
+      console.error('HeTTV API error:', error.message);
+      return {
+        success: false,
+        error: error.response?.data?.message || 'API-Anfrage fehlgeschlagen',
+        status: error.response?.status || 500
+      };
+    }
+  }
+
+  /**
+   * Navigate to main HeTTV page and find Downloads menu
+   * @param {string} cookie - Session cookie
+   * @returns {Promise<Object>} Response with main page content and download links
+   */
+  async getMainPageWithDownloads(cookie, finalUrl = null) {
+    try {
+      console.log('[HettvClient] - Loading main HeTTV page...');
+
+      // Kandidaten für Einstiegs-URL bestimmen
+      let origin = CLICK_TT_BASE;
+      if (finalUrl) {
+        try { origin = new URL(finalUrl).origin; } catch (_) {}
+      }
+
+      const candidates = [];
+      // Direkt zu HeTTV navigieren
+      candidates.push('http://httv.click-tt.de/');
+      candidates.push('http://httv.click-tt.de/wa/');
+      candidates.push('http://httv.click-tt.de/cgi-bin/WebObjects/nuLigaTTDE.woa/wa/');
+      
+      // Wenn wir eine finalUrl haben, verwende diese auch
+      if (finalUrl) {
+        candidates.push(finalUrl);
+      }
+      
+      console.log('[HettvClient] - URL candidates:', candidates);
+
+      let mainPageResponse = null;
+      let mainTrace = [];
+      let lastError = null;
+      for (const candidate of candidates) {
+        const resp = await this.authenticatedRequest(candidate, cookie, {}, finalUrl);
+        if (resp.success && typeof resp.data === 'string' && resp.data.length > 0) {
+          mainPageResponse = resp;
+          mainTrace = resp.trace || [];
+          break;
+        }
+        lastError = resp;
+      }
+
+      if (!mainPageResponse) {
+        return lastError || { success: false, error: 'HeTTV Einstiegsseite nicht erreichbar', status: 404 };
+      }
+
+      const htmlContent = mainPageResponse.data;
+      console.log('[HettvClient] - Main page loaded, HTML length:', htmlContent.length);
+
+      // Erkenne Fehlerseite (Session ungültig)
+      if (/click-TT\s*-\s*Fehlerseite/i.test(htmlContent) || /ungültige oder nicht mehr gültige URL/i.test(htmlContent)) {
+        return {
+          success: false,
+          error: 'Session ungültig oder abgelaufen',
+          status: 401,
+          data: { htmlSnippet: htmlContent.substring(0, 1000) }
+        };
+      }
+
+      // Speichere HTML zur Analyse
+      let savedFile = null;
+      try {
+        const dir = path.resolve(process.cwd(), 'backend', 'uploads');
+        if (!fs.existsSync(dir)) {
+          fs.mkdirSync(dir, { recursive: true });
+        }
+        const filename = `hettv_main_${Date.now()}.html`;
+        const filePath = path.join(dir, filename);
+        fs.writeFileSync(filePath, htmlContent, 'utf8');
+        savedFile = filePath;
+      } catch (e) {
+        // Ignoriere Speicherfehler still, nur für Debug
+      }
+
+      // Suche nach Downloads-Links im HTML
+      const downloadLinks = [];
+
+      // 1) URL-Heuristiken
+      const urlPatterns = [
+        /href="([^"]*download[^"]*)"/gi,
+        /href="([^"]*downloads[^"]*)"/gi,
+        /href="([^"]*Download[^"]*)"/gi,
+        /href="([^"]*Downloads[^"]*)"/gi
+      ];
+
+      urlPatterns.forEach(pattern => {
+        let match;
+        while ((match = pattern.exec(htmlContent)) !== null) {
+          const link = match[1];
+          if (link && !downloadLinks.includes(link)) {
+            downloadLinks.push(link);
+          }
+        }
+      });
+
+      // 2) Linktext-Heuristik: <a ...>Downloads</a>
+      const anchorPattern = /<a[^>]*href="([^"]+)"[^>]*>([\s\S]*?)<\/a>/gi;
+      let aMatch;
+      while ((aMatch = anchorPattern.exec(htmlContent)) !== null) {
+        const href = aMatch[1];
+        const text = aMatch[2].replace(/<[^>]*>/g, ' ').replace(/\s+/g, ' ').trim();
+        if (/\bdownloads?\b/i.test(text)) {
+          if (href && !downloadLinks.includes(href)) {
+            downloadLinks.push(href);
+          }
+        }
+      }
+
+      // 3) Fallback: Menüpunkte in Navigationen (role="navigation" etc.)
+      if (downloadLinks.length === 0) {
+        const navSectionRegex = /<nav[\s\S]*?<\/nav>/gi;
+        let nav;
+        while ((nav = navSectionRegex.exec(htmlContent)) !== null) {
+          const section = nav[0];
+          let m;
+          anchorPattern.lastIndex = 0;
+          while ((m = anchorPattern.exec(section)) !== null) {
+            const href = m[1];
+            const text = m[2].replace(/<[^>]*>/g, ' ').replace(/\s+/g, ' ').trim();
+            if (/\bdownloads?\b/i.test(text)) {
+              if (href && !downloadLinks.includes(href)) {
+                downloadLinks.push(href);
+              }
+            }
+          }
+        }
+      }
+
+      console.log('[HettvClient] - Found download links:', downloadLinks);
+
+      return {
+        success: true,
+        data: {
+          htmlContent: htmlContent,
+          downloadLinks: downloadLinks,
+          htmlSnippet: htmlContent.substring(0, 2000), // Erste 2000 Zeichen für Analyse
+          savedFile,
+          trace: mainTrace,
+          lastUrl: mainTrace.length ? mainTrace[mainTrace.length - 1].url : null,
+          lastStatus: mainTrace.length ? mainTrace[mainTrace.length - 1].status : null
+        }
+      };
+    } catch (error) {
+      console.error('HeTTV main page error:', error.message);
+      return {
+        success: false,
+        error: error.message || 'Fehler beim Laden der Hauptseite',
+        status: 500
+      };
+    }
+  }
+
+  /**
+   * Load a specific download page
+   * @param {string} downloadUrl - URL to the download page
+   * @param {string} cookie - Session cookie
+   * @returns {Promise<Object>} Response with download page content
+   */
+  async loadDownloadPage(downloadUrl, cookie, finalUrl = null) {
+    try {
+      console.log('[HettvClient] - Loading download page:', downloadUrl);
+      
+      const response = await this.authenticatedRequest(downloadUrl, cookie, {}, finalUrl);
+      if (!response.success) {
+        return response;
+      }
+
+      const htmlContent = response.data;
+      console.log('[HettvClient] - Download page loaded, HTML length:', htmlContent.length);
+
+      return {
+        success: true,
+        data: {
+          url: downloadUrl,
+          htmlContent: htmlContent,
+          htmlSnippet: htmlContent.substring(0, 3000) // Erste 3000 Zeichen für Analyse
+        }
+      };
+    } catch (error) {
+      console.error('HeTTV download page error:', error.message);
+      return {
+        success: false,
+        error: error.message || 'Fehler beim Laden der Download-Seite',
+        status: 500
+      };
+    }
+  }
+
+  // --- Cookie-Helfer ---
+  _ingestSetCookiesFromResponse(currentUrl, setCookies) {
+    if (!Array.isArray(setCookies) || setCookies.length === 0) return;
+    const { host } = new URL(currentUrl);
+    if (!this.cookieJar.has(host)) this.cookieJar.set(host, new Map());
+    const jar = this.cookieJar.get(host);
+    setCookies.forEach((cookieStr) => {
+      const pair = cookieStr.split(';')[0];
+      const eq = pair.indexOf('=');
+      if (eq > 0) {
+        const name = pair.substring(0, eq).trim();
+        const value = pair.substring(eq + 1).trim();
+        jar.set(name, value);
+      }
+    });
+  }
+
+  _cookieHeaderForUrl(currentUrl) {
+    const { host } = new URL(currentUrl);
+    const jar = this.cookieJar.get(host);
+    if (!jar || jar.size === 0) return '';
+    return Array.from(jar.entries()).map(([k, v]) => `${k}=${v}`).join('; ');
+  }
+
+  _mergeCookieHeader(primary, secondary) {
+    const items = [];
+    if (primary) items.push(primary);
+    if (secondary) items.push(secondary);
+    return items.filter(Boolean).join('; ');
+  }
+}
+
+export default new HettvClient();
+

backend/clients/myTischtennisClient.js

@@ -0,0 +1,284 @@
+import axios from 'axios';
+
+const BASE_URL = 'https://www.mytischtennis.de';
+
+class MyTischtennisClient {
+  constructor() {
+    this.baseURL = BASE_URL;
+    this.client = axios.create({
+      baseURL: this.baseURL,
+      timeout: 10000,
+      headers: {
+        'Content-Type': 'application/x-www-form-urlencoded',
+        'Accept': '*/*'
+      },
+      maxRedirects: 0, // Don't follow redirects automatically
+      validateStatus: (status) => status >= 200 && status < 400 // Accept 3xx as success
+    });
+  }
+
+  /**
+   * Login to myTischtennis API
+   * @param {string} email - myTischtennis email (not username!)
+   * @param {string} password - myTischtennis password
+   * @returns {Promise<Object>} Login response with token and session data
+   */
+  async login(email, password) {
+    try {
+      // Create form data
+      const formData = new URLSearchParams();
+      formData.append('email', email);
+      formData.append('password', password);
+      formData.append('intent', 'login');
+
+      const response = await this.client.post(
+        '/login?next=%2F&_data=routes%2F_auth%2B%2Flogin',
+        formData.toString()
+      );
+
+      // Extract the cookie from response headers
+      const setCookie = response.headers['set-cookie'];
+      if (!setCookie || !Array.isArray(setCookie)) {
+        return {
+          success: false,
+          error: 'Keine Session-Cookie erhalten'
+        };
+      }
+
+      // Find the sb-10-auth-token cookie
+      const authCookie = setCookie.find(cookie => cookie.startsWith('sb-10-auth-token='));
+      if (!authCookie) {
+        return {
+          success: false,
+          error: 'Kein Auth-Token in Response gefunden'
+        };
+      }
+
+      // Extract and decode the token
+      const tokenMatch = authCookie.match(/sb-10-auth-token=base64-([^;]+)/);
+      if (!tokenMatch) {
+        return {
+          success: false,
+          error: 'Token-Format ungültig'
+        };
+      }
+
+      const base64Token = tokenMatch[1];
+      let tokenData;
+      try {
+        const decodedToken = Buffer.from(base64Token, 'base64').toString('utf-8');
+        tokenData = JSON.parse(decodedToken);
+      } catch (decodeError) {
+        console.error('Error decoding token:', decodeError);
+        return {
+          success: false,
+          error: 'Token konnte nicht dekodiert werden'
+        };
+      }
+
+      return {
+        success: true,
+        accessToken: tokenData.access_token,
+        refreshToken: tokenData.refresh_token,
+        expiresAt: tokenData.expires_at,
+        expiresIn: tokenData.expires_in,
+        user: tokenData.user,
+        cookie: authCookie.split(';')[0] // Just the cookie value without attributes
+      };
+    } catch (error) {
+      console.error('MyTischtennis login error:', error.message);
+      return {
+        success: false,
+        error: error.response?.data?.message || 'Login fehlgeschlagen',
+        status: error.response?.status || 500
+      };
+    }
+  }
+
+  /**
+   * Verify login credentials
+   * @param {string} email - myTischtennis email
+   * @param {string} password - myTischtennis password
+   * @returns {Promise<boolean>} True if credentials are valid
+   */
+  async verifyCredentials(email, password) {
+    const result = await this.login(email, password);
+    return result.success;
+  }
+
+  /**
+   * Make an authenticated request
+   * @param {string} endpoint - API endpoint
+   * @param {string} cookie - Authentication cookie (sb-10-auth-token)
+   * @param {Object} options - Additional axios options
+   * @returns {Promise<Object>} API response
+   */
+  async authenticatedRequest(endpoint, cookie, options = {}) {
+    try {
+      const response = await this.client.request({
+        url: endpoint,
+        ...options,
+        headers: {
+          ...options.headers,
+          'Cookie': cookie,
+          'Accept': '*/*',
+          'Accept-Language': 'de-DE,de;q=0.9,en-US;q=0.8,en;q=0.7',
+          'Referer': 'https://www.mytischtennis.de/',
+          'sec-fetch-dest': 'empty',
+          'sec-fetch-mode': 'cors',
+          'sec-fetch-site': 'same-origin'
+        }
+      });
+      return {
+        success: true,
+        data: response.data
+      };
+    } catch (error) {
+      console.error('MyTischtennis API error:', error.message);
+      return {
+        success: false,
+        error: error.response?.data?.message || 'API-Anfrage fehlgeschlagen',
+        status: error.response?.status || 500
+      };
+    }
+  }
+
+  /**
+   * Get user profile and club information
+   * @param {string} cookie - Authentication cookie (sb-10-auth-token)
+   * @returns {Promise<Object>} User profile with club info
+   */
+  async getUserProfile(cookie) {
+    console.log('[getUserProfile] - Calling /?_data=root with cookie:', cookie?.substring(0, 50) + '...');
+    
+    const result = await this.authenticatedRequest('/?_data=root', cookie, {
+      method: 'GET'
+    });
+    
+    console.log('[getUserProfile] - Result success:', result.success);
+    
+    if (result.success) {
+      console.log('[getUserProfile] - Response structure:', {
+        hasUserProfile: !!result.data?.userProfile,
+        hasClub: !!result.data?.userProfile?.club,
+        hasOrganization: !!result.data?.userProfile?.organization,
+        clubnr: result.data?.userProfile?.club?.clubnr,
+        clubName: result.data?.userProfile?.club?.name,
+        orgShort: result.data?.userProfile?.organization?.short,
+        ttr: result.data?.userProfile?.ttr,
+        qttr: result.data?.userProfile?.qttr
+      });
+      
+      console.log('[getUserProfile] - Full userProfile.club:', result.data?.userProfile?.club);
+      console.log('[getUserProfile] - Full userProfile.organization:', result.data?.userProfile?.organization);
+      
+      return {
+        success: true,
+        clubId: result.data?.userProfile?.club?.clubnr || null,
+        clubName: result.data?.userProfile?.club?.name || null,
+        fedNickname: result.data?.userProfile?.organization?.short || null,
+        ttr: result.data?.userProfile?.ttr || null,
+        qttr: result.data?.userProfile?.qttr || null,
+        userProfile: result.data?.userProfile || null
+      };
+    }
+    
+    console.error('[getUserProfile] - Failed:', result.error);
+    return result;
+  }
+
+  /**
+   * Get club rankings (andro-Rangliste)
+   * @param {string} cookie - Authentication cookie
+   * @param {string} clubId - Club number (e.g., "43030")
+   * @param {string} fedNickname - Federation nickname (e.g., "HeTTV")
+   * @returns {Promise<Object>} Rankings with player entries (all pages)
+   */
+  async getClubRankings(cookie, clubId, fedNickname) {
+    const allEntries = [];
+    let currentPage = 0;
+    let hasMorePages = true;
+    
+    console.log('[getClubRankings] - Starting to fetch rankings for club', clubId);
+    
+    while (hasMorePages) {
+      const endpoint = `/rankings/andro-rangliste?all-players=on&clubnr=${clubId}&fednickname=${fedNickname}&results-per-page=100&page=${currentPage}&_data=routes%2F%24`;
+      
+      console.log(`[getClubRankings] - Fetching page ${currentPage}...`);
+      
+      const result = await this.authenticatedRequest(endpoint, cookie, {
+        method: 'GET'
+      });
+      
+      if (!result.success) {
+        console.error(`[getClubRankings] - Failed to fetch page ${currentPage}:`, result.error);
+        return result;
+      }
+      
+      // Find the dynamic key that contains entries
+      const blockLoaderData = result.data?.pageContent?.blockLoaderData;
+      if (!blockLoaderData) {
+        console.error('[getClubRankings] - No blockLoaderData found');
+        return {
+          success: false,
+          error: 'Keine blockLoaderData gefunden'
+        };
+      }
+      
+      // Finde den Schlüssel, der entries enthält
+      let entries = null;
+      let rankingData = null;
+      
+      for (const key in blockLoaderData) {
+        if (blockLoaderData[key]?.entries) {
+          entries = blockLoaderData[key].entries;
+          rankingData = blockLoaderData[key];
+          break;
+        }
+      }
+      
+      if (!entries) {
+        console.error('[getClubRankings] - No entries found in blockLoaderData');
+        return {
+          success: false,
+          error: 'Keine entries in blockLoaderData gefunden'
+        };
+      }
+      
+      console.log(`[getClubRankings] - Page ${currentPage}: Found ${entries.length} entries`);
+      
+      // Füge Entries hinzu
+      allEntries.push(...entries);
+      
+      // Prüfe ob es weitere Seiten gibt
+      // Wenn die aktuelle Seite weniger Einträge hat als das Limit, sind wir am Ende
+      // Oder wenn wir alle erwarteten Einträge haben
+      if (entries.length === 0) {
+        hasMorePages = false;
+        console.log('[getClubRankings] - No more entries, stopping');
+      } else if (rankingData.numberOfPages && currentPage >= rankingData.numberOfPages - 1) {
+        hasMorePages = false;
+        console.log(`[getClubRankings] - Reached last page (${rankingData.numberOfPages})`);
+      } else if (allEntries.length >= rankingData.resultLength) {
+        hasMorePages = false;
+        console.log(`[getClubRankings] - Got all entries (${allEntries.length}/${rankingData.resultLength})`);
+      } else {
+        currentPage++;
+      }
+    }
+    
+    console.log(`[getClubRankings] - Total entries fetched: ${allEntries.length}`);
+    
+    return {
+      success: true,
+      entries: allEntries,
+      metadata: {
+        totalEntries: allEntries.length,
+        pagesFetched: currentPage + 1
+      }
+    };
+  }
+}
+
+export default new MyTischtennisClient();
+

backend/controllers/clubsController.js

@@ -1,77 +1,76 @@
 import ClubService from '../services/clubService.js';
 import { getUserByToken } from '../utils/userUtils.js';
+import { devLog } from '../utils/logger.js';
 
 export const getClubs = async (req, res) => {
   try {
-    console.log('[getClubs] - get clubs');
+    devLog('[getClubs] - get clubs');
     const clubs = await ClubService.getAllClubs();
-    console.log('[getClubs] - prepare response');
+    devLog('[getClubs] - prepare response');
     res.status(200).json(clubs);
-    console.log('[getClubs] - done');
+    devLog('[getClubs] - done');
   } catch (error) {
-    console.log('[getClubs] - error');
-    console.log(error);
+    console.error('[getClubs] - error:', error);
     res.status(500).json({ error: "internalerror" });
   }
 };
 
 export const addClub = async (req, res) => {
-  console.log('[addClub] - Read out parameters');
+  devLog('[addClub] - Read out parameters');
   const { authcode: token } = req.headers;
   const { name: clubName } = req.body;
 
   try {
-    console.log('[addClub] - find club by name');
+    devLog('[addClub] - find club by name');
     const club = await ClubService.findClubByName(clubName);
-    console.log('[addClub] - get user');
+    devLog('[addClub] - get user');
     const user = await getUserByToken(token);
-    console.log('[addClub] - check if club already exists');
+    devLog('[addClub] - check if club already exists');
     if (club) {
       res.status(409).json({ error: "alreadyexists" });
       return;
     }
 
-    console.log('[addClub] - create club');
+    devLog('[addClub] - create club');
     const newClub = await ClubService.createClub(clubName);
-    console.log('[addClub] - add user to new club');
+    devLog('[addClub] - add user to new club');
     await ClubService.addUserToClub(user.id, newClub.id);
-    console.log('[addClub] - prepare response');
+    devLog('[addClub] - prepare response');
     res.status(200).json(newClub);
-    console.log('[addClub] - done');
+    devLog('[addClub] - done');
   } catch (error) {
-    console.log('[addClub] - error');
-    console.log(error);
+    console.error('[addClub] - error:', error);
     res.status(500).json({ error: "internalerror" });
   }
 };
 
 export const getClub = async (req, res) => {
-  console.log('[getClub] - start');
+  devLog('[getClub] - start');
   try {
     const { authcode: token } = req.headers;
     const { clubid: clubId } = req.params;
-    console.log('[getClub] - get user');
+    devLog('[getClub] - get user');
     const user = await getUserByToken(token);
-    console.log('[getClub] - get users club');
+    devLog('[getClub] - get users club');
     const access = await ClubService.getUserClubAccess(user.id, clubId);
-    console.log('[getClub] - check access');
+    devLog('[getClub] - check access');
     if (access.length === 0 || !access[0].approved) {
       res.status(403).json({ error: "noaccess", status: access.length === 0 ? "notrequested" : "requested" });
       return;
     }
 
-    console.log('[getClub] - get club');
+    devLog('[getClub] - get club');
     const club = await ClubService.findClubById(clubId);
-    console.log('[getClub] - check club exists');
+    devLog('[getClub] - check club exists');
     if (!club) {
       return res.status(404).json({ message: 'Club not found' });
     }
 
-    console.log('[getClub] - set response');
+    devLog('[getClub] - set response');
     res.status(200).json(club);
-    console.log('[getClub] - done');
+    devLog('[getClub] - done');
   } catch (error) {
-    console.log(error);
+    console.error('[getClub] - error:', error);
     res.status(500).json({ message: 'Server error' });
   }
 };
@@ -82,7 +81,7 @@ export const requestClubAccess = async (req, res) => {
 
   try {
     const user = await getUserByToken(token);
-    console.log(user);
+    devLog('[requestClubAccess] - user:', user);
 
     await ClubService.requestAccessToClub(user.id, clubId);
     res.status(200).json({});
@@ -92,6 +91,7 @@ export const requestClubAccess = async (req, res) => {
     } else if (error.message === 'clubnotfound') {
       res.status(404).json({ err: "clubnotfound" });
     } else {
+      console.error('[requestClubAccess] - error:', error);
       res.status(500).json({ err: "internalerror" });
     }
   }

backend/controllers/diaryController.js

@@ -1,6 +1,7 @@
 import diaryService from '../services/diaryService.js';
 import HttpError from '../exceptions/HttpError.js';
 
+import { devLog } from '../utils/logger.js';
 const getDatesForClub = async (req, res) => {
     try {
         const { clubId } = req.params; 
@@ -38,7 +39,7 @@ const updateTrainingTimes = async (req, res) => {
         const { authcode: userToken } = req.headers;
         const { dateId, trainingStart, trainingEnd } = req.body;
         if (!dateId || !trainingStart) {
-            console.log(dateId, trainingStart, trainingEnd);
+            devLog(dateId, trainingStart, trainingEnd);
             throw new HttpError('notallfieldsfilled', 400);
         }
         const updatedDate = await diaryService.updateTrainingTimes(userToken, clubId, dateId, trainingStart, trainingEnd);

backend/controllers/diaryDateActivityController.js

@@ -1,5 +1,6 @@
 import diaryDateActivityService from '../services/diaryDateActivityService.js';
 
+import { devLog } from '../utils/logger.js';
 export const createDiaryDateActivity = async (req, res) => {
     try {
         const { authcode: userToken } = req.headers;
@@ -15,7 +16,7 @@ export const createDiaryDateActivity = async (req, res) => {
         });
         res.status(201).json(activityItem);
     } catch (error) {
-        console.log(error);
+        devLog(error);
         res.status(500).json({ error: 'Error creating activity' });
     }
 };
@@ -58,7 +59,7 @@ export const updateDiaryDateActivityOrder = async (req, res) => {
         const updatedActivity = await diaryDateActivityService.updateActivityOrder(userToken, clubId, id, orderId);
         res.status(200).json(updatedActivity);
     } catch (error) {
-        console.log(error);
+        devLog(error);
         res.status(500).json({ error: 'Error updating activity order' });
     }
 };
@@ -70,7 +71,7 @@ export const getDiaryDateActivities = async (req, res) => {
         const activities = await diaryDateActivityService.getActivities(userToken, clubId, diaryDateId);
         res.status(200).json(activities);
     } catch (error) {
-        console.log(error);
+        devLog(error);
         res.status(500).json({ error: 'Error getting activities' });
     }
 }
@@ -82,7 +83,7 @@ export const addGroupActivity = async(req, res) => {
         const activityItem = await diaryDateActivityService.addGroupActivity(userToken, clubId, diaryDateId, groupId, activity);
         res.status(201).json(activityItem);        
     } catch (error) {
-        console.log(error);
+        devLog(error);
         res.status(500).json({ error: 'Error adding group activity' });
     }
 }

backend/controllers/diaryDateTagController.js

@@ -1,7 +1,8 @@
 import diaryDateTagService from "../services/diaryDateTagService.js"
 
+import { devLog } from '../utils/logger.js';
 export const getDiaryDateMemberTags = async (req, res) => {
-    console.log("getDiaryDateMemberTags");
+    devLog("getDiaryDateMemberTags");
     try {
         const { authcode: userToken } = req.headers;
         const { clubId, memberId } = req.params;
@@ -14,7 +15,7 @@ export const getDiaryDateMemberTags = async (req, res) => {
 }
 
 export const addDiaryDateTag = async (req, res) => {
-    console.log("addDiaryDateTag");
+    devLog("addDiaryDateTag");
     try {
         const { authcode: userToken } = req.headers;
         const { clubId } = req.params;

backend/controllers/diaryMemberController.js

@@ -1,11 +1,12 @@
 import DiaryMemberService from '../services/diaryMemberService.js';
 
+import { devLog } from '../utils/logger.js';
 const getMemberTags = async (req, res) => {
     try {
         const { diaryDateId, memberId } = req.query;
         const { clubId } = req.params;
         const { authcode: userToken } = req.headers;
-        console.log(diaryDateId, memberId, clubId);
+        devLog(diaryDateId, memberId, clubId);
         const tags = await DiaryMemberService.getTagsForMemberAndDate(userToken, clubId, diaryDateId, memberId);
         res.status(200).json(tags);
     } catch (error) {
@@ -19,7 +20,7 @@ const getMemberNotes = async (req, res) => {
         const { diaryDateId, memberId } = req.query;
         const { clubId } = req.params;
         const { authcode: userToken } = req.headers;
-        console.log('---------->', userToken, clubId);
+        devLog('---------->', userToken, clubId);
         const notes = await DiaryMemberService.getNotesForMember(userToken, clubId, diaryDateId, memberId);
         res.status(200).json(notes);
     } catch (error) {

backend/controllers/diaryTagController.js

@@ -1,5 +1,6 @@
 import { DiaryTag, DiaryDateTag } from '../models/index.js';
 
+import { devLog } from '../utils/logger.js';
 export const getTags = async (req, res) => {
     try {
         const tags = await DiaryTag.findAll();
@@ -12,11 +13,11 @@ export const getTags = async (req, res) => {
 export const createTag = async (req, res) => {
     try {
         const { name } = req.body;
-        console.log(name);
+        devLog(name);
         const newTag = await DiaryTag.findOrCreate({ where: { name }, defaults: { name } });
         res.status(201).json(newTag);
     } catch (error) {
-        console.log('[createTag] - Error:', error);
+        devLog('[createTag] - Error:', error);
         res.status(500).json({ error: 'Error creating tag' });
     }
 };

backend/controllers/externalServiceController.js

@@ -0,0 +1,172 @@
+import externalServiceService from '../services/externalServiceService.js';
+import HttpError from '../exceptions/HttpError.js';
+
+class ExternalServiceController {
+  /**
+   * GET /api/mytischtennis/account?service=mytischtennis
+   * Get current user's external service account
+   */
+  async getAccount(req, res, next) {
+    try {
+      const userId = req.user.id;
+      const service = req.query.service || 'mytischtennis';
+      const account = await externalServiceService.getAccount(userId, service);
+      
+      if (!account) {
+        return res.status(200).json({ account: null });
+      }
+      
+      res.status(200).json({ account });
+    } catch (error) {
+      next(error);
+    }
+  }
+
+  /**
+   * GET /api/mytischtennis/status?service=mytischtennis
+   * Check account configuration status
+   */
+  async getStatus(req, res, next) {
+    try {
+      const userId = req.user.id;
+      const service = req.query.service || 'mytischtennis';
+      const status = await externalServiceService.checkAccountStatus(userId, service);
+      res.status(200).json(status);
+    } catch (error) {
+      next(error);
+    }
+  }
+
+  /**
+   * POST /api/mytischtennis/account
+   * Create or update external service account
+   */
+  async upsertAccount(req, res, next) {
+    try {
+      const userId = req.user.id;
+      const { email, password, savePassword, userPassword, service = 'mytischtennis' } = req.body;
+
+      if (!email) {
+        throw new HttpError(400, 'E-Mail-Adresse erforderlich');
+      }
+
+      // Wenn ein Passwort gesetzt wird, muss das App-Passwort angegeben werden
+      if (password && !userPassword) {
+        throw new HttpError(400, 'App-Passwort erforderlich zum Setzen des myTischtennis-Passworts');
+      }
+
+      const account = await externalServiceService.upsertAccount(
+        userId,
+        email,
+        password,
+        savePassword || false,
+        userPassword,
+        service
+      );
+
+      res.status(200).json({ 
+        message: `${service}-Account erfolgreich gespeichert`,
+        account 
+      });
+    } catch (error) {
+      next(error);
+    }
+  }
+
+  /**
+   * DELETE /api/mytischtennis/account?service=mytischtennis
+   * Delete external service account
+   */
+  async deleteAccount(req, res, next) {
+    try {
+      const userId = req.user.id;
+      const service = req.query.service || 'mytischtennis';
+      const deleted = await externalServiceService.deleteAccount(userId, service);
+      
+      if (!deleted) {
+        throw new HttpError(404, `Kein ${service}-Account gefunden`);
+      }
+
+      res.status(200).json({ message: `${service}-Account gelöscht` });
+    } catch (error) {
+      next(error);
+    }
+  }
+
+  /**
+   * POST /api/mytischtennis/verify
+   * Verify login credentials
+   */
+  async verifyLogin(req, res, next) {
+    try {
+      const userId = req.user.id;
+      const { password, service = 'mytischtennis' } = req.body;
+
+      const result = await externalServiceService.verifyLogin(userId, password, service);
+
+      res.status(200).json({
+        message: 'Login erfolgreich',
+        success: true,
+        accessToken: result.accessToken,
+        expiresAt: result.expiresAt,
+        clubId: result.clubId,
+        clubName: result.clubName
+      });
+    } catch (error) {
+      next(error);
+    }
+  }
+
+  /**
+   * GET /api/mytischtennis/session?service=mytischtennis
+   * Get stored session data for authenticated requests
+   */
+  async getSession(req, res, next) {
+    try {
+      const userId = req.user.id;
+      const service = req.query.service || 'mytischtennis';
+      const session = await externalServiceService.getSession(userId, service);
+
+      res.status(200).json({ session });
+    } catch (error) {
+      next(error);
+    }
+  }
+
+  /**
+   * GET /api/external-service/hettv/main-page
+   * Load HeTTV main page and find download links
+   */
+  async loadHettvMainPage(req, res, next) {
+    try {
+      const userId = req.user.id;
+      const result = await externalServiceService.loadHettvMainPage(userId);
+      res.status(200).json(result);
+    } catch (error) {
+      next(error);
+    }
+  }
+
+  /**
+   * POST /api/external-service/hettv/download-page
+   * Load specific HeTTV download page
+   */
+  async loadHettvDownloadPage(req, res, next) {
+    try {
+      const userId = req.user.id;
+      const { downloadUrl } = req.body;
+      
+      if (!downloadUrl) {
+        throw new HttpError(400, 'Download-URL ist erforderlich');
+      }
+      
+      const result = await externalServiceService.loadHettvDownloadPage(userId, downloadUrl);
+      res.status(200).json(result);
+    } catch (error) {
+      next(error);
+    }
+  }
+}
+
+export default new ExternalServiceController();
+

backend/controllers/groupController.js

@@ -1,6 +1,7 @@
 import HttpError from '../exceptions/HttpError.js';
 import groupService from '../services/groupService.js';
 
+import { devLog } from '../utils/logger.js';
 const addGroup = async(req, res) => {
     try {
         const { authcode: userToken } = req.headers;
@@ -9,7 +10,7 @@ const addGroup = async(req, res) => {
         res.status(201).json(result);
     } catch (error) {
         console.error('[addGroup] - Error:', error);
-        console.log(req.params, req.headers, req.body)
+        devLog(req.params, req.headers, req.body)
         res.status(error.statusCode || 500).json({ error: error.message });
     }
 }

backend/controllers/matchController.js

@@ -1,6 +1,7 @@
 import MatchService from '../services/matchService.js';
 import fs from 'fs';
 
+import { devLog } from '../utils/logger.js';
 export const uploadCSV = async (req, res) => {
     try {
         const { clubId } = req.body;
@@ -21,7 +22,7 @@ export const uploadCSV = async (req, res) => {
 
 export const getLeaguesForCurrentSeason = async (req, res) => {
     try {
-        console.log(req.headers, req.params);
+        devLog(req.headers, req.params);
         const { authcode: userToken } = req.headers;
         const { clubId } = req.params;
         const leagues = await MatchService.getLeaguesForCurrentSeason(userToken, clubId);

backend/controllers/memberController.js

@@ -1,5 +1,6 @@
 import MemberService from "../services/memberService.js";
 
+import { devLog } from '../utils/logger.js';
 const getClubMembers = async(req, res) => {
     try {
         const { authcode: userToken } = req.headers;
@@ -9,24 +10,24 @@ const getClubMembers = async(req, res) => {
         }
         res.status(200).json(await MemberService.getClubMembers(userToken, clubId, showAll));
     } catch(error) {
-        console.log('[getClubMembers] - Error: ', error);
+        devLog('[getClubMembers] - Error: ', error);
         res.status(500).json({ error: 'systemerror' });
     }
 }
 
 const getWaitingApprovals = async(req, res) => {
     try {
-        console.log('[getWaitingApprovals] - Start');
+        devLog('[getWaitingApprovals] - Start');
         const { id: clubId } = req.params;
-        console.log('[getWaitingApprovals] - get token');
+        devLog('[getWaitingApprovals] - get token');
         const { authcode: userToken } = req.headers;
-        console.log('[getWaitingApprovals] - load for waiting approvals');
+        devLog('[getWaitingApprovals] - load for waiting approvals');
         const waitingApprovals = await MemberService.getApprovalRequests(userToken, clubId);
-        console.log('[getWaitingApprovals] - set response');
+        devLog('[getWaitingApprovals] - set response');
         res.status(200).json(waitingApprovals);
-        console.log('[getWaitingApprovals] - done');
+        devLog('[getWaitingApprovals] - done');
     } catch(error) {
-        console.log('[getWaitingApprovals] - Error: ', error);
+        devLog('[getWaitingApprovals] - Error: ', error);
         res.status(403).json({ error: error });
     }
 } 
@@ -34,11 +35,11 @@ const getWaitingApprovals = async(req, res) => {
 const setClubMembers = async (req, res) => {
     try {
         const { id: memberId, firstname: firstName, lastname: lastName, street, city, birthdate, phone, email, active, 
-            testMembership, picsInInternetAllowed, gender } = req.body;
+            testMembership, picsInInternetAllowed, gender, ttr, qttr } = req.body;
         const { id: clubId } = req.params;
         const { authcode: userToken } = req.headers;
         const addResult = await MemberService.setClubMember(userToken, clubId, memberId, firstName, lastName, street, city, birthdate, 
-            phone, email, active, testMembership, picsInInternetAllowed, gender);
+            phone, email, active, testMembership, picsInInternetAllowed, gender, ttr, qttr);
         res.status(addResult.status || 500).json(addResult.response);
     } catch (error) {
         console.error('[setClubMembers] - Error:', error);
@@ -59,7 +60,7 @@ const uploadMemberImage = async (req, res) => {
 };
 
 const getMemberImage = async (req, res) => {
-    console.log('[getMemberImage]');
+    devLog('[getMemberImage]');
     try {
         const { clubId, memberId } = req.params;
         const { authcode: userToken } = req.headers;
@@ -75,4 +76,17 @@ const getMemberImage = async (req, res) => {
     }
 };
 
-export { getClubMembers, getWaitingApprovals, setClubMembers, uploadMemberImage, getMemberImage };
+const updateRatingsFromMyTischtennis = async (req, res) => {
+    devLog('[updateRatingsFromMyTischtennis]');
+    try {
+        const { id: clubId } = req.params;
+        const { authcode: userToken } = req.headers;
+        const result = await MemberService.updateRatingsFromMyTischtennis(userToken, clubId);
+        res.status(result.status).json(result.response);
+    } catch (error) {
+        console.error('[updateRatingsFromMyTischtennis] - Error:', error);
+        res.status(500).json({ error: 'Failed to update ratings' });
+    }
+};
+
+export { getClubMembers, getWaitingApprovals, setClubMembers, uploadMemberImage, getMemberImage, updateRatingsFromMyTischtennis };

backend/controllers/memberNoteController.js

@@ -1,15 +1,16 @@
 import MemberNoteService from "../services/memberNoteService.js";
 
+import { devLog } from '../utils/logger.js';
 const getMemberNotes = async (req, res) => {
     try {
         const { authcode: userToken } = req.headers;
         const { memberId } = req.params;
         const { clubId } = req.query;
-        console.log('[getMemberNotes]', userToken, memberId, clubId);
+        devLog('[getMemberNotes]', userToken, memberId, clubId);
         const notes = await MemberNoteService.getNotesForMember(userToken, clubId, memberId);
         res.status(200).json(notes);
     } catch (error) {
-        console.log('[getMemberNotes] - Error: ', error);
+        devLog('[getMemberNotes] - Error: ', error);
         res.status(500).json({ error: 'systemerror' });
     }
 };
@@ -18,12 +19,12 @@ const addMemberNote = async (req, res) => {
     try {
         const { authcode: userToken } = req.headers;
         const { memberId, content, clubId } = req.body;
-        console.log('[addMemberNote]', userToken, memberId, content, clubId);
+        devLog('[addMemberNote]', userToken, memberId, content, clubId);
         await MemberNoteService.addNoteToMember(userToken, clubId, memberId, content);
         const notes = await MemberNoteService.getNotesForMember(userToken, clubId, memberId);
         res.status(201).json(notes);
     } catch (error) {
-        console.log('[addMemberNote] - Error: ', error);
+        devLog('[addMemberNote] - Error: ', error);
         res.status(500).json({ error: 'systemerror' });
     }
 };
@@ -33,13 +34,13 @@ const deleteMemberNote = async (req, res) => {
         const { authcode: userToken } = req.headers;
         const { noteId } = req.params;
         const { clubId } = req.body;
-        console.log('[deleteMemberNote]', userToken, noteId, clubId);
+        devLog('[deleteMemberNote]', userToken, noteId, clubId);
         const memberId = await MemberNoteService.getMemberIdForNote(noteId); // Member ID ermitteln
         await MemberNoteService.deleteNoteForMember(userToken, clubId, noteId);
         const notes = await MemberNoteService.getNotesForMember(userToken, clubId, memberId);
         res.status(200).json(notes);
     } catch (error) {
-        console.log('[deleteMemberNote] - Error: ', error);
+        devLog('[deleteMemberNote] - Error: ', error);
         res.status(500).json({ error: 'systemerror' });
     }
 };

backend/controllers/participantController.js

@@ -1,12 +1,13 @@
 import Participant from '../models/Participant.js';
 
+import { devLog } from '../utils/logger.js';
 export const getParticipants = async (req, res) => {
     try {
         const { dateId } = req.params;
         const participants = await Participant.findAll({ where: { diaryDateId: dateId } });
         res.status(200).json(participants);
     } catch (error) {
-        console.log(error);
+        devLog(error);
         res.status(500).json({ error: 'Fehler beim Abrufen der Teilnehmer' });
     }
 };
@@ -17,7 +18,7 @@ export const addParticipant = async (req, res) => {
         const participant = await Participant.create({ diaryDateId, memberId });
         res.status(201).json(participant);
     } catch (error) {
-        console.log(error);
+        devLog(error);
         res.status(500).json({ error: 'Fehler beim Hinzufügen des Teilnehmers' });
     }
 };
@@ -28,7 +29,7 @@ export const removeParticipant = async (req, res) => {
         await Participant.destroy({ where: { diaryDateId, memberId } });
         res.status(200).json({ message: 'Teilnehmer entfernt' });
     } catch (error) {
-        console.log(error);
+        devLog(error);
         res.status(500).json({ error: 'Fehler beim Entfernen des Teilnehmers' });
     }
 };

backend/controllers/predefinedActivityController.js

@@ -5,8 +5,8 @@ import fs from 'fs';
 
 export const createPredefinedActivity = async (req, res) => {
     try {
-        const { name, code, description, durationText, duration, imageLink } = req.body;
-        const predefinedActivity = await predefinedActivityService.createPredefinedActivity({ name, code, description, durationText, duration, imageLink });
+        const { name, code, description, durationText, duration, imageLink, drawingData } = req.body;
+        const predefinedActivity = await predefinedActivityService.createPredefinedActivity({ name, code, description, durationText, duration, imageLink, drawingData });
         res.status(201).json(predefinedActivity);
     } catch (error) {
         console.error('[createPredefinedActivity] - Error:', error);
@@ -42,8 +42,8 @@ export const getPredefinedActivityById = async (req, res) => {
 export const updatePredefinedActivity = async (req, res) => {
     try {
         const { id } = req.params;
-        const { name, code, description, durationText, duration, imageLink } = req.body;
-        const updatedActivity = await predefinedActivityService.updatePredefinedActivity(id, { name, code, description, durationText, duration, imageLink });
+        const { name, code, description, durationText, duration, imageLink, drawingData } = req.body;
+        const updatedActivity = await predefinedActivityService.updatePredefinedActivity(id, { name, code, description, durationText, duration, imageLink, drawingData });
         res.status(200).json(updatedActivity);
     } catch (error) {
         console.error('[updatePredefinedActivity] - Error:', error);

backend/controllers/predefinedActivityImageController.js

@@ -5,6 +5,7 @@ import path from 'path';
 import fs from 'fs';
 import sharp from 'sharp';
 
+import { devLog } from '../utils/logger.js';
 export const uploadPredefinedActivityImage = async (req, res) => {
   try {
     const { id } = req.params; // predefinedActivityId
@@ -33,10 +34,15 @@ export const uploadPredefinedActivityImage = async (req, res) => {
       .jpeg({ quality: 85 })
       .toFile(filePath);
 
+    // Extrahiere Zeichnungsdaten aus dem Request
+    const drawingData = req.body.drawingData ? JSON.parse(req.body.drawingData) : null;
+    devLog('[uploadPredefinedActivityImage] - drawingData:', drawingData);
+
     const imageRecord = await PredefinedActivityImage.create({
       predefinedActivityId: id,
       imagePath: filePath,
       mimeType: 'image/jpeg',
+      drawingData: drawingData ? JSON.stringify(drawingData) : null,
     });
 
     // Optional: als imageLink am Activity-Datensatz setzen

backend/controllers/trainingStatsController.js

@@ -19,6 +19,25 @@ class TrainingStatsController {
         }
       });
       
+      // Anzahl der Trainings im jeweiligen Zeitraum berechnen
+      const trainingsCount12Months = await DiaryDate.count({
+        where: {
+          clubId: parseInt(clubId),
+          date: {
+            [Op.gte]: twelveMonthsAgo
+          }
+        }
+      });
+      
+      const trainingsCount3Months = await DiaryDate.count({
+        where: {
+          clubId: parseInt(clubId),
+          date: {
+            [Op.gte]: threeMonthsAgo
+          }
+        }
+      });
+      
       const stats = [];
       
       for (const member of members) {
@@ -116,7 +135,36 @@ class TrainingStatsController {
       // Nach Gesamtteilnahme absteigend sortieren
       stats.sort((a, b) => b.participationTotal - a.participationTotal);
       
-      res.json(stats);
+      // Trainingstage mit Teilnehmerzahlen abrufen (letzte 12 Monate, absteigend sortiert)
+      const trainingDays = await DiaryDate.findAll({
+        where: {
+          clubId: parseInt(clubId),
+          date: {
+            [Op.gte]: twelveMonthsAgo
+          }
+        },
+        include: [{
+          model: Participant,
+          as: 'participantList',
+          attributes: ['id']
+        }],
+        order: [['date', 'DESC']]
+      });
+      
+      // Formatiere Trainingstage mit Teilnehmerzahl
+      const formattedTrainingDays = trainingDays.map(day => ({
+        id: day.id,
+        date: day.date,
+        participantCount: day.participantList ? day.participantList.length : 0
+      }));
+      
+      // Zusätzliche Metadaten mit Trainingsanzahl zurückgeben
+      res.json({
+        members: stats,
+        trainingsCount12Months,
+        trainingsCount3Months,
+        trainingDays: formattedTrainingDays
+      });
       
     } catch (error) {
       console.error('Fehler beim Laden der Trainings-Statistik:', error);

backend/migrations/add_drawing_data_to_predefined_activity_images.sql

@@ -0,0 +1,11 @@
+-- Migration: Add drawing_data column to predefined_activity_images table
+-- Date: 2025-09-22
+-- Description: Adds drawing_data column to store Court Drawing Tool metadata
+
+ALTER TABLE `predefined_activity_images` 
+ADD COLUMN `drawing_data` TEXT NULL 
+COMMENT 'JSON string containing drawing metadata for Court Drawing Tool' 
+AFTER `mime_type`;
+
+-- Verify the column was added
+DESCRIBE `predefined_activity_images`;

backend/models/ExternalServiceAccount.js

@@ -0,0 +1,132 @@
+import { DataTypes } from 'sequelize';
+import sequelize from '../database.js';
+import { encryptData, decryptData } from '../utils/encrypt.js';
+
+const ExternalServiceAccount = sequelize.define('ExternalServiceAccount', {
+  id: {
+    type: DataTypes.INTEGER,
+    primaryKey: true,
+    autoIncrement: true,
+    allowNull: false
+  },
+  userId: {
+    type: DataTypes.INTEGER,
+    allowNull: false,
+    references: {
+      model: 'user',
+      key: 'id'
+    },
+    onDelete: 'CASCADE'
+  },
+  service: {
+    type: DataTypes.STRING(50),
+    allowNull: false,
+    defaultValue: 'mytischtennis'
+  },
+  email: {
+    type: DataTypes.STRING,
+    allowNull: false, 
+  },
+  encryptedPassword: {
+    type: DataTypes.TEXT,
+    allowNull: true,
+    field: 'encrypted_password'
+  },
+  savePassword: {
+    type: DataTypes.BOOLEAN,
+    defaultValue: false,
+    allowNull: false,
+    field: 'save_password'
+  },
+  accessToken: {
+    type: DataTypes.TEXT,
+    allowNull: true,
+    field: 'access_token'
+  },
+  refreshToken: {
+    type: DataTypes.TEXT,
+    allowNull: true,
+    field: 'refresh_token'
+  },
+  expiresAt: {
+    type: DataTypes.BIGINT,
+    allowNull: true,
+    field: 'expires_at'
+  },
+  cookie: {
+    type: DataTypes.TEXT,
+    allowNull: true
+  },
+  userData: {
+    type: DataTypes.JSON,
+    allowNull: true,
+    field: 'user_data'
+  },
+  clubId: {
+    type: DataTypes.STRING,
+    allowNull: true,
+    field: 'club_id'
+  },
+  clubName: {
+    type: DataTypes.STRING,
+    allowNull: true,
+    field: 'club_name'
+  },
+  fedNickname: {
+    type: DataTypes.STRING,
+    allowNull: true,
+    field: 'fed_nickname'
+  },
+  lastLoginAttempt: {
+    type: DataTypes.DATE,
+    allowNull: true,
+    field: 'last_login_attempt'
+  },
+  lastLoginSuccess: {
+    type: DataTypes.DATE,
+    allowNull: true,
+    field: 'last_login_success'
+  }
+}, {
+  underscored: true,
+  tableName: 'external_service_account',
+  timestamps: true,
+  indexes: [
+    {
+      unique: true,
+      fields: ['user_id', 'service']
+    }
+  ],
+  hooks: {
+    beforeSave: async (instance) => {
+      // Wenn savePassword false ist, password auf null setzen
+      if (!instance.savePassword) {
+        instance.encryptedPassword = null;
+      }
+    }
+  }
+});
+
+// Virtuelle Felder für password handling
+ExternalServiceAccount.prototype.setPassword = function(password) {
+  if (password && this.savePassword) {
+    this.encryptedPassword = encryptData(password);
+  } else {
+    this.encryptedPassword = null;
+  }
+};
+
+ExternalServiceAccount.prototype.getPassword = function() {
+  if (this.encryptedPassword) {
+    try {
+      return decryptData(this.encryptedPassword);
+    } catch (error) {
+      console.error('Error decrypting password:', error);
+      return null;
+    }
+  }
+  return null;
+};
+
+export default ExternalServiceAccount;
+

backend/models/Member.js

@@ -127,6 +127,16 @@ const Member = sequelize.define('Member', {
     type: DataTypes.ENUM('male','female','diverse','unknown'),
     allowNull: true,
     defaultValue: 'unknown'
+  },
+  ttr: {
+    type: DataTypes.INTEGER,
+    allowNull: true,
+    defaultValue: null
+  },
+  qttr: {
+    type: DataTypes.INTEGER,
+    allowNull: true,
+    defaultValue: null
   }
 }, {
   underscored: true,

backend/models/MyTischtennis.js

@@ -0,0 +1,132 @@
+import { DataTypes } from 'sequelize';
+import sequelize from '../database.js';
+import { encryptData, decryptData } from '../utils/encrypt.js';
+
+const ExternalServiceAccount = sequelize.define('ExternalServiceAccount', {
+  id: {
+    type: DataTypes.INTEGER,
+    primaryKey: true,
+    autoIncrement: true,
+    allowNull: false
+  },
+  userId: {
+    type: DataTypes.INTEGER,
+    allowNull: false,
+    references: {
+      model: 'user',
+      key: 'id'
+    },
+    onDelete: 'CASCADE'
+  },
+  service: {
+    type: DataTypes.STRING(50),
+    allowNull: false,
+    defaultValue: 'mytischtennis'
+  },
+  email: {
+    type: DataTypes.STRING,
+    allowNull: false,
+  },
+  encryptedPassword: {
+    type: DataTypes.TEXT,
+    allowNull: true,
+    field: 'encrypted_password'
+  },
+  savePassword: {
+    type: DataTypes.BOOLEAN,
+    defaultValue: false,
+    allowNull: false,
+    field: 'save_password'
+  },
+  accessToken: {
+    type: DataTypes.TEXT,
+    allowNull: true,
+    field: 'access_token'
+  },
+  refreshToken: {
+    type: DataTypes.TEXT,
+    allowNull: true,
+    field: 'refresh_token'
+  },
+  expiresAt: {
+    type: DataTypes.BIGINT,
+    allowNull: true,
+    field: 'expires_at'
+  },
+  cookie: {
+    type: DataTypes.TEXT,
+    allowNull: true
+  },
+  userData: {
+    type: DataTypes.JSON,
+    allowNull: true,
+    field: 'user_data'
+  },
+  clubId: {
+    type: DataTypes.STRING,
+    allowNull: true,
+    field: 'club_id'
+  },
+  clubName: {
+    type: DataTypes.STRING,
+    allowNull: true,
+    field: 'club_name'
+  },
+  fedNickname: {
+    type: DataTypes.STRING,
+    allowNull: true,
+    field: 'fed_nickname'
+  },
+  lastLoginAttempt: {
+    type: DataTypes.DATE,
+    allowNull: true,
+    field: 'last_login_attempt'
+  },
+  lastLoginSuccess: {
+    type: DataTypes.DATE,
+    allowNull: true,
+    field: 'last_login_success'
+  }
+}, {
+  underscored: true,
+  tableName: 'external_service_account',
+  timestamps: true,
+  indexes: [
+    {
+      unique: true,
+      fields: ['user_id', 'service']
+    }
+  ],
+  hooks: {
+    beforeSave: async (instance) => {
+      // Wenn savePassword false ist, password auf null setzen
+      if (!instance.savePassword) {
+        instance.encryptedPassword = null;
+      }
+    }
+  }
+});
+
+// Virtuelle Felder für password handling
+ExternalServiceAccount.prototype.setPassword = function(password) {
+  if (password && this.savePassword) {
+    this.encryptedPassword = encryptData(password);
+  } else {
+    this.encryptedPassword = null;
+  }
+};
+
+ExternalServiceAccount.prototype.getPassword = function() {
+  if (this.encryptedPassword) {
+    try {
+      return decryptData(this.encryptedPassword);
+    } catch (error) {
+      console.error('Error decrypting password:', error);
+      return null;
+    }
+  }
+  return null;
+};
+
+export default ExternalServiceAccount;
+

backend/models/PredefinedActivity.js

@@ -19,6 +19,11 @@ const PredefinedActivity = sequelize.define('PredefinedActivity', {
         type: DataTypes.TEXT,
         allowNull: true,
     },
+    drawingData: {
+        type: DataTypes.TEXT,
+        allowNull: true,
+        comment: 'JSON string with metadata for Court Drawing Tool'
+    },
     durationText: {
         type: DataTypes.STRING,
         allowNull: true,

backend/models/PredefinedActivityImage.js

@@ -19,6 +19,11 @@ const PredefinedActivityImage = sequelize.define('PredefinedActivityImage', {
     type: DataTypes.STRING,
     allowNull: true,
   },
+  drawingData: {
+    type: DataTypes.TEXT,
+    allowNull: true,
+    comment: 'JSON string containing drawing metadata for Court Drawing Tool'
+  },
 }, {
   tableName: 'predefined_activity_images',
   timestamps: true,

backend/models/index.js

@@ -33,6 +33,7 @@ import UserToken from './UserToken.js';
 import OfficialTournament from './OfficialTournament.js';
 import OfficialCompetition from './OfficialCompetition.js';
 import OfficialCompetitionMember from './OfficialCompetitionMember.js';
+import ExternalServiceAccount from './ExternalServiceAccount.js';
 // Official tournaments relations
 OfficialTournament.hasMany(OfficialCompetition, { foreignKey: 'tournamentId', as: 'competitions' });
 OfficialCompetition.belongsTo(OfficialTournament, { foreignKey: 'tournamentId', as: 'tournament' });
@@ -204,6 +205,9 @@ Member.hasMany(Accident, { foreignKey: 'memberId', as: 'accidents' });
 Accident.belongsTo(DiaryDate, { foreignKey: 'diaryDateId', as: 'diaryDates' });
 DiaryDate.hasMany(Accident, { foreignKey: 'diaryDateId', as: 'accidents' });
 
+User.hasMany(ExternalServiceAccount, { foreignKey: 'userId', as: 'externalServiceAccounts' });
+ExternalServiceAccount.belongsTo(User, { foreignKey: 'userId', as: 'user' });
+
 export {
     User,
     Log,
@@ -239,4 +243,5 @@ export {
     OfficialTournament,
     OfficialCompetition,
     OfficialCompetitionMember,
+    ExternalServiceAccount,
 };

backend/node_modules/.package-lock.json

@@ -4,6 +4,15 @@
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
+    "node_modules/@babel/runtime": {
+      "version": "7.28.4",
+      "resolved": "https://registry.npmjs.org/@babel/runtime/-/runtime-7.28.4.tgz",
+      "integrity": "sha512-Q/N6JNWvIvPnLDvjlE1OUBLPQHH6l3CltCEsHIujp45zQUSSh8K+gHnaEX45yAT1nyngnINhvWtzN+Nb9D8RAQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
     "node_modules/@emnapi/runtime": {
       "version": "1.2.0",
       "resolved": "https://registry.npmjs.org/@emnapi/runtime/-/runtime-1.2.0.tgz",
@@ -810,6 +819,12 @@
       "resolved": "https://registry.npmjs.org/array-flatten/-/array-flatten-1.1.1.tgz",
       "integrity": "sha512-PCVAQswWemu6UdxsDFFX/+gVeYqKAod3D3UVm91jHwynguOwAvYPhx8nNlM++NqRcK6CxxpUafjmhIdKiHibqg=="
     },
+    "node_modules/asynckit": {
+      "version": "0.4.0",
+      "resolved": "https://registry.npmjs.org/asynckit/-/asynckit-0.4.0.tgz",
+      "integrity": "sha512-Oei9OH4tRh0YqU3GxhX79dM/mwVgvbZJaSNaRk+bshkj0S5cfHcgYakreBjrHwatXKbz+IoIdYLxrKim2MjW0Q==",
+      "license": "MIT"
+    },
     "node_modules/aws-ssl-profiles": {
       "version": "1.1.1",
       "resolved": "https://registry.npmjs.org/aws-ssl-profiles/-/aws-ssl-profiles-1.1.1.tgz",
@@ -818,6 +833,17 @@
         "node": ">= 6.0.0"
       }
     },
+    "node_modules/axios": {
+      "version": "1.12.2",
+      "resolved": "https://registry.npmjs.org/axios/-/axios-1.12.2.tgz",
+      "integrity": "sha512-vMJzPewAlRyOgxV2dU0Cuz2O8zzzx9VYtbJOaBgXFeLc4IV/Eg50n4LowmehOOR61S8ZMpc2K5Sa7g6A4jfkUw==",
+      "license": "MIT",
+      "dependencies": {
+        "follow-redirects": "^1.15.6",
+        "form-data": "^4.0.4",
+        "proxy-from-env": "^1.1.0"
+      }
+    },
     "node_modules/balanced-match": {
       "version": "1.0.2",
       "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-1.0.2.tgz",
@@ -955,6 +981,19 @@
         "url": "https://github.com/sponsors/ljharb"
       }
     },
+    "node_modules/call-bind-apply-helpers": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/call-bind-apply-helpers/-/call-bind-apply-helpers-1.0.2.tgz",
+      "integrity": "sha512-Sp1ablJ0ivDkSzjcaJdxEunN5/XvksFJ2sMBFfq6x0ryhQV/2b/KwFe21cMpmHtPOSij8K99/wSfoEuTObmuMQ==",
+      "license": "MIT",
+      "dependencies": {
+        "es-errors": "^1.3.0",
+        "function-bind": "^1.1.2"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
     "node_modules/callsites": {
       "version": "3.1.0",
       "resolved": "https://registry.npmjs.org/callsites/-/callsites-3.1.0.tgz",
@@ -1084,6 +1123,18 @@
         "color-support": "bin.js"
       }
     },
+    "node_modules/combined-stream": {
+      "version": "1.0.8",
+      "resolved": "https://registry.npmjs.org/combined-stream/-/combined-stream-1.0.8.tgz",
+      "integrity": "sha512-FQN4MRfuJeHf7cBbBMJFXhKSDq+2kAArBlmRBvcvFE5BB1HZKXtSFASDhdlz9zOYwxh8lDdnvmMOe/+5cdoEdg==",
+      "license": "MIT",
+      "dependencies": {
+        "delayed-stream": "~1.0.0"
+      },
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
     "node_modules/concat-map": {
       "version": "0.0.1",
       "resolved": "https://registry.npmjs.org/concat-map/-/concat-map-0.0.1.tgz",
@@ -1227,6 +1278,22 @@
         "node": ">= 10"
       }
     },
+    "node_modules/date-fns": {
+      "version": "2.30.0",
+      "resolved": "https://registry.npmjs.org/date-fns/-/date-fns-2.30.0.tgz",
+      "integrity": "sha512-fnULvOpxnC5/Vg3NCiWelDsLiUc9bRwAPs/+LfTLNvetFCtCTN+yQz15C/fs4AwX1R9K5GLtLfn8QW+dWisaAw==",
+      "license": "MIT",
+      "dependencies": {
+        "@babel/runtime": "^7.21.0"
+      },
+      "engines": {
+        "node": ">=0.11"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/date-fns"
+      }
+    },
     "node_modules/debug": {
       "version": "2.6.9",
       "resolved": "https://registry.npmjs.org/debug/-/debug-2.6.9.tgz",
@@ -1259,6 +1326,15 @@
         "url": "https://github.com/sponsors/ljharb"
       }
     },
+    "node_modules/delayed-stream": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/delayed-stream/-/delayed-stream-1.0.0.tgz",
+      "integrity": "sha512-ZySD7Nf91aLB0RxL4KGrKHBXl7Eds1DAmEdcoVawXnLD7SDhpNgtuII2aAkg7a7QS41jxPSZ17p4VdGnMHk3MQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.4.0"
+      }
+    },
     "node_modules/delegates": {
       "version": "1.0.0",
       "resolved": "https://registry.npmjs.org/delegates/-/delegates-1.0.0.tgz",
@@ -1315,6 +1391,20 @@
       "resolved": "https://registry.npmjs.org/dottie/-/dottie-2.0.6.tgz",
       "integrity": "sha512-iGCHkfUc5kFekGiqhe8B/mdaurD+lakO9txNnTvKtA6PISrw86LgqHvRzWYPyoE2Ph5aMIrCw9/uko6XHTKCwA=="
     },
+    "node_modules/dunder-proto": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/dunder-proto/-/dunder-proto-1.0.1.tgz",
+      "integrity": "sha512-KIN/nDJBQRcXw0MLVhZE9iQHmG68qAVIBg9CqmUYjmQIhgij9U5MFvrqkUL5FbtyyzZuOeOt0zdeRe4UY7ct+A==",
+      "license": "MIT",
+      "dependencies": {
+        "call-bind-apply-helpers": "^1.0.1",
+        "es-errors": "^1.3.0",
+        "gopd": "^1.2.0"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
     "node_modules/ecdsa-sig-formatter": {
       "version": "1.0.11",
       "resolved": "https://registry.npmjs.org/ecdsa-sig-formatter/-/ecdsa-sig-formatter-1.0.11.tgz",
@@ -1342,13 +1432,10 @@
       }
     },
     "node_modules/es-define-property": {
-      "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/es-define-property/-/es-define-property-1.0.0.tgz",
-      "integrity": "sha512-jxayLKShrEqqzJ0eumQbVhTYQM27CfT1T35+gCgDFoL82JLsXqTJ76zv6A0YLOgEnLUMvLzsDsGIrl8NFpT2gQ==",
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/es-define-property/-/es-define-property-1.0.1.tgz",
+      "integrity": "sha512-e3nRfgfUZ4rNGL232gUgX06QNyyez04KdjFrF+LTRoOXmrOgFKDg4BCdsjW8EnT69eqdYGmRpJwiPVYNrCaW3g==",
       "license": "MIT",
-      "dependencies": {
-        "get-intrinsic": "^1.2.4"
-      },
       "engines": {
         "node": ">= 0.4"
       }
@@ -1362,6 +1449,33 @@
         "node": ">= 0.4"
       }
     },
+    "node_modules/es-object-atoms": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/es-object-atoms/-/es-object-atoms-1.1.1.tgz",
+      "integrity": "sha512-FGgH2h8zKNim9ljj7dankFPcICIK9Cp5bm+c2gQSYePhpaG5+esrLODihIorn+Pe6FGJzWhXQotPv73jTaldXA==",
+      "license": "MIT",
+      "dependencies": {
+        "es-errors": "^1.3.0"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/es-set-tostringtag": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/es-set-tostringtag/-/es-set-tostringtag-2.1.0.tgz",
+      "integrity": "sha512-j6vWzfrGVfyXxge+O0x5sh6cvxAog0a/4Rdd2K36zCMV5eJ+/+tOAngRO8cODMNWbVRdVlmGZQL2YS3yR8bIUA==",
+      "license": "MIT",
+      "dependencies": {
+        "es-errors": "^1.3.0",
+        "get-intrinsic": "^1.2.6",
+        "has-tostringtag": "^1.0.2",
+        "hasown": "^2.0.2"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
     "node_modules/escape-html": {
       "version": "1.0.3",
       "resolved": "https://registry.npmjs.org/escape-html/-/escape-html-1.0.3.tgz",
@@ -1752,6 +1866,42 @@
       "dev": true,
       "peer": true
     },
+    "node_modules/follow-redirects": {
+      "version": "1.15.11",
+      "resolved": "https://registry.npmjs.org/follow-redirects/-/follow-redirects-1.15.11.tgz",
+      "integrity": "sha512-deG2P0JfjrTxl50XGCDyfI97ZGVCxIpfKYmfyrQ54n5FO/0gfIES8C/Psl6kWVDolizcaaxZJnTS0QSMxvnsBQ==",
+      "funding": [
+        {
+          "type": "individual",
+          "url": "https://github.com/sponsors/RubenVerborgh"
+        }
+      ],
+      "license": "MIT",
+      "engines": {
+        "node": ">=4.0"
+      },
+      "peerDependenciesMeta": {
+        "debug": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/form-data": {
+      "version": "4.0.4",
+      "resolved": "https://registry.npmjs.org/form-data/-/form-data-4.0.4.tgz",
+      "integrity": "sha512-KrGhL9Q4zjj0kiUt5OO4Mr/A/jlI2jDYs5eHBpYHPcBEVSiipAvn2Ko2HnPe20rmcuuvMHNdZFp+4IlGTMF0Ow==",
+      "license": "MIT",
+      "dependencies": {
+        "asynckit": "^0.4.0",
+        "combined-stream": "^1.0.8",
+        "es-set-tostringtag": "^2.1.0",
+        "hasown": "^2.0.2",
+        "mime-types": "^2.1.12"
+      },
+      "engines": {
+        "node": ">= 6"
+      }
+    },
     "node_modules/forwarded": {
       "version": "0.2.0",
       "resolved": "https://registry.npmjs.org/forwarded/-/forwarded-0.2.0.tgz",
@@ -1849,16 +1999,21 @@
       }
     },
     "node_modules/get-intrinsic": {
-      "version": "1.2.4",
-      "resolved": "https://registry.npmjs.org/get-intrinsic/-/get-intrinsic-1.2.4.tgz",
-      "integrity": "sha512-5uYhsJH8VJBTv7oslg4BznJYhDoRI6waYCxMmCdnTrcCrHA/fCFKoTFz2JKKE0HdDFUF7/oQuhzumXJK7paBRQ==",
+      "version": "1.3.0",
+      "resolved": "https://registry.npmjs.org/get-intrinsic/-/get-intrinsic-1.3.0.tgz",
+      "integrity": "sha512-9fSjSaos/fRIVIp+xSJlE6lfwhES7LNtKaCBIamHsjr2na1BiABJPo0mOjjz8GJDURarmCPGqaiVg5mfjb98CQ==",
       "license": "MIT",
       "dependencies": {
+        "call-bind-apply-helpers": "^1.0.2",
+        "es-define-property": "^1.0.1",
         "es-errors": "^1.3.0",
+        "es-object-atoms": "^1.1.1",
         "function-bind": "^1.1.2",
-        "has-proto": "^1.0.1",
-        "has-symbols": "^1.0.3",
-        "hasown": "^2.0.0"
+        "get-proto": "^1.0.1",
+        "gopd": "^1.2.0",
+        "has-symbols": "^1.1.0",
+        "hasown": "^2.0.2",
+        "math-intrinsics": "^1.1.0"
       },
       "engines": {
         "node": ">= 0.4"
@@ -1867,6 +2022,19 @@
         "url": "https://github.com/sponsors/ljharb"
       }
     },
+    "node_modules/get-proto": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/get-proto/-/get-proto-1.0.1.tgz",
+      "integrity": "sha512-sTSfBjoXBp89JvIKIefqw7U2CCebsc74kiY6awiGogKtoSGbgjYE/G/+l9sF3MWFPNc9IcoOC4ODfKHfxFmp0g==",
+      "license": "MIT",
+      "dependencies": {
+        "dunder-proto": "^1.0.1",
+        "es-object-atoms": "^1.0.0"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
     "node_modules/glob": {
       "version": "7.2.3",
       "resolved": "https://registry.npmjs.org/glob/-/glob-7.2.3.tgz",
@@ -1913,12 +2081,12 @@
       }
     },
     "node_modules/gopd": {
-      "version": "1.0.1",
-      "resolved": "https://registry.npmjs.org/gopd/-/gopd-1.0.1.tgz",
-      "integrity": "sha512-d65bNlIadxvpb/A2abVdlqKqV563juRnZ1Wtk6s1sIR8uNsXR70xqIzVqxVf1eTqDunwT2MkczEeaezCKTZhwA==",
+      "version": "1.2.0",
+      "resolved": "https://registry.npmjs.org/gopd/-/gopd-1.2.0.tgz",
+      "integrity": "sha512-ZUKRh6/kUFoAiTAtTYPZJ3hw9wNxx+BIBOijnlG9PnrJsCcSjs1wyyD6vJpaYtgnzDrKYRSqf3OO6Rfa93xsRg==",
       "license": "MIT",
-      "dependencies": {
-        "get-intrinsic": "^1.1.3"
+      "engines": {
+        "node": ">= 0.4"
       },
       "funding": {
         "url": "https://github.com/sponsors/ljharb"
@@ -1945,10 +2113,10 @@
         "url": "https://github.com/sponsors/ljharb"
       }
     },
-    "node_modules/has-proto": {
-      "version": "1.0.3",
-      "resolved": "https://registry.npmjs.org/has-proto/-/has-proto-1.0.3.tgz",
-      "integrity": "sha512-SJ1amZAJUiZS+PhsVLf5tGydlaVB8EdFpaSO4gmiUKUOxk8qzn5AIy4ZeJUmh22znIdk/uMAUT2pl3FxzVUH+Q==",
+    "node_modules/has-symbols": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/has-symbols/-/has-symbols-1.1.0.tgz",
+      "integrity": "sha512-1cDNdwJ2Jaohmb3sg4OmKaMBwuC48sYni5HUw2DvsC8LjGTLK9h+eb1X6RyuOHe4hT0ULCW68iomhjUoKUqlPQ==",
       "license": "MIT",
       "engines": {
         "node": ">= 0.4"
@@ -1957,11 +2125,14 @@
         "url": "https://github.com/sponsors/ljharb"
       }
     },
-    "node_modules/has-symbols": {
-      "version": "1.0.3",
-      "resolved": "https://registry.npmjs.org/has-symbols/-/has-symbols-1.0.3.tgz",
-      "integrity": "sha512-l3LCuF6MgDNwTDKkdYGEihYjt5pRPbEg46rtlmnSPlUbgmB8LOIrKJbYYFBSbnPaJexMKtiPO8hmeRjRz2Td+A==",
+    "node_modules/has-tostringtag": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/has-tostringtag/-/has-tostringtag-1.0.2.tgz",
+      "integrity": "sha512-NqADB8VjPFLM2V0VvHUewwwsw0ZWBaIdgo+ieHtK3hasLz4qeCRjYcqfB6AQrBggRKppKF8L52/VqdVsO47Dlw==",
       "license": "MIT",
+      "dependencies": {
+        "has-symbols": "^1.0.3"
+      },
       "engines": {
         "node": ">= 0.4"
       },
@@ -2405,6 +2576,15 @@
         "semver": "bin/semver.js"
       }
     },
+    "node_modules/math-intrinsics": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/math-intrinsics/-/math-intrinsics-1.1.0.tgz",
+      "integrity": "sha512-/IXtbwEk5HTPyEwyKX6hGkYXxM9nbj64B+ilVJnC/R6B0pH5G4V3b0pVbL7DBj4tkhBAppbQUlf6F6Xl9LHu1g==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
     "node_modules/media-typer": {
       "version": "0.3.0",
       "resolved": "https://registry.npmjs.org/media-typer/-/media-typer-0.3.0.tgz",
@@ -2972,6 +3152,12 @@
         "node": ">= 0.10"
       }
     },
+    "node_modules/proxy-from-env": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/proxy-from-env/-/proxy-from-env-1.1.0.tgz",
+      "integrity": "sha512-D+zkORCbA9f1tdWRK0RaCR3GPv50cMxcrz4X8k5LTSUD1Dkw47mKJEZQNunItRTkWwgtaUSo1RVFRIG9ZXiFYg==",
+      "license": "MIT"
+    },
     "node_modules/pstree.remy": {
       "version": "1.1.8",
       "resolved": "https://registry.npmjs.org/pstree.remy/-/pstree.remy-1.1.8.tgz",

backend/node_modules/es-define-property/CHANGELOG.md

@@ -5,6 +5,20 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/)
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [v1.0.1](https://github.com/ljharb/es-define-property/compare/v1.0.0...v1.0.1) - 2024-12-06
+
+### Commits
+
+- [types] use shared tsconfig [`954a663`](https://github.com/ljharb/es-define-property/commit/954a66360326e508a0e5daa4b07493d58f5e110e)
+- [actions] split out node 10-20, and 20+ [`3a8e84b`](https://github.com/ljharb/es-define-property/commit/3a8e84b23883f26ff37b3e82ff283834228e18c6)
+- [Dev Deps] update `@ljharb/eslint-config`, `@ljharb/tsconfig`, `@types/get-intrinsic`, `@types/tape`, `auto-changelog`, `gopd`, `tape` [`86ae27b`](https://github.com/ljharb/es-define-property/commit/86ae27bb8cc857b23885136fad9cbe965ae36612)
+- [Refactor] avoid using `get-intrinsic` [`02480c0`](https://github.com/ljharb/es-define-property/commit/02480c0353ef6118965282977c3864aff53d98b1)
+- [Tests] replace `aud` with `npm audit` [`f6093ff`](https://github.com/ljharb/es-define-property/commit/f6093ff74ab51c98015c2592cd393bd42478e773)
+- [Tests] configure testling [`7139e66`](https://github.com/ljharb/es-define-property/commit/7139e66959247a56086d9977359caef27c6849e7)
+- [Dev Deps] update `tape` [`b901b51`](https://github.com/ljharb/es-define-property/commit/b901b511a75e001a40ce1a59fef7d9ffcfc87482)
+- [Tests] fix types in tests [`469d269`](https://github.com/ljharb/es-define-property/commit/469d269fd141b1e773ec053a9fa35843493583e0)
+- [Dev Deps] add missing peer dep [`733acfb`](https://github.com/ljharb/es-define-property/commit/733acfb0c4c96edf337e470b89a25a5b3724c352)
+
 ## v1.0.0 - 2024-02-12
 
 ### Commits

backend/node_modules/es-define-property/index.js

@@ -1,9 +1,7 @@
 'use strict';
 
-var GetIntrinsic = require('get-intrinsic');
-
 /** @type {import('.')} */
-var $defineProperty = GetIntrinsic('%Object.defineProperty%', true) || false;
+var $defineProperty = Object.defineProperty || false;
 if ($defineProperty) {
 	try {
 		$defineProperty({}, 'a', { value: 1 });

backend/node_modules/es-define-property/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "es-define-property",
-	"version": "1.0.0",
+	"version": "1.0.1",
 	"description": "`Object.defineProperty`, but not IE 8's broken one.",
 	"main": "index.js",
 	"types": "./index.d.ts",
@@ -19,7 +19,7 @@
 		"pretest": "npm run lint",
 		"tests-only": "nyc tape 'test/**/*.js'",
 		"test": "npm run tests-only",
-		"posttest": "aud --production",
+		"posttest": "npx npm@'>= 10.2' audit --production",
 		"version": "auto-changelog && git add CHANGELOG.md",
 		"postversion": "auto-changelog && git add CHANGELOG.md && git commit --no-edit --amend && git tag -f \"v$(node -e \"console.log(require('./package.json').version)\")\""
 	},
@@ -42,29 +42,29 @@
 		"url": "https://github.com/ljharb/es-define-property/issues"
 	},
 	"homepage": "https://github.com/ljharb/es-define-property#readme",
-	"dependencies": {
-		"get-intrinsic": "^1.2.4"
-	},
 	"devDependencies": {
-		"@ljharb/eslint-config": "^21.1.0",
-		"@types/get-intrinsic": "^1.2.2",
+		"@ljharb/eslint-config": "^21.1.1",
+		"@ljharb/tsconfig": "^0.2.2",
 		"@types/gopd": "^1.0.3",
-		"@types/tape": "^5.6.4",
-		"aud": "^2.0.4",
-		"auto-changelog": "^2.4.0",
+		"@types/tape": "^5.6.5",
+		"auto-changelog": "^2.5.0",
+		"encoding": "^0.1.13",
 		"eslint": "^8.8.0",
 		"evalmd": "^0.0.19",
-		"gopd": "^1.0.1",
+		"gopd": "^1.2.0",
 		"in-publish": "^2.0.1",
 		"npmignore": "^0.3.1",
 		"nyc": "^10.3.2",
 		"safe-publish-latest": "^2.0.0",
-		"tape": "^5.7.4",
+		"tape": "^5.9.0",
 		"typescript": "next"
 	},
 	"engines": {
 		"node": ">= 0.4"
 	},
+	"testling": {
+		"files": "test/index.js"
+	},
 	"auto-changelog": {
 		"output": "CHANGELOG.md",
 		"template": "keepachangelog",

backend/node_modules/es-define-property/test/index.js

@@ -10,6 +10,7 @@ test('defineProperty: supported', { skip: !$defineProperty }, function (t) {
 
 	t.equal(typeof $defineProperty, 'function', 'defineProperty is supported');
 	if ($defineProperty && gOPD) { // this `if` check is just to shut TS up
+		/** @type {{ a: number, b?: number, c?: number }} */
 		var o = { a: 1 };
 
 		$defineProperty(o, 'b', { enumerable: true, value: 2 });

backend/node_modules/es-define-property/tsconfig.json

@@ -1,47 +1,7 @@
 {
+	"extends": "@ljharb/tsconfig",
 	"compilerOptions": {
-		/* Visit https://aka.ms/tsconfig.json to read more about this file */
-
-		/* Projects */
-
-		/* Language and Environment */
-		"target": "es2022",																	/* Set the JavaScript language version for emitted JavaScript and include compatible library declarations. */
-		// "lib": [],																				/* Specify a set of bundled library declaration files that describe the target runtime environment. */
-		// "noLib": true,																		/* Disable including any library files, including the default lib.d.ts. */
-		"useDefineForClassFields": true,										 /* Emit ECMAScript-standard-compliant class fields. */
-		// "moduleDetection": "auto",												/* Control what method is used to detect module-format JS files. */
-
-		/* Modules */
-		"module": "commonjs",																/* Specify what module code is generated. */
-		// "rootDir": "./",																	/* Specify the root folder within your source files. */
-		// "moduleResolution": "node",											 /* Specify how TypeScript looks up a file from a given module specifier. */
-		// "baseUrl": "./",																	/* Specify the base directory to resolve non-relative module names. */
-		// "paths": {},																			/* Specify a set of entries that re-map imports to additional lookup locations. */
-		// "rootDirs": [],																	 /* Allow multiple folders to be treated as one when resolving modules. */
-		// "typeRoots": ["types"],													 /* Specify multiple folders that act like `./node_modules/@types`. */
-		"resolveJsonModule": true,													 /* Enable importing .json files. */
-		// "allowArbitraryExtensions": true,								 /* Enable importing files with any extension, provided a declaration file is present. */
-
-		/* JavaScript Support */
-		"allowJs": true,																		 /* Allow JavaScript files to be a part of your program. Use the `checkJS` option to get errors from these files. */
-		"checkJs": true,																		 /* Enable error reporting in type-checked JavaScript files. */
-		"maxNodeModuleJsDepth": 1,													 /* Specify the maximum folder depth used for checking JavaScript files from `node_modules`. Only applicable with `allowJs`. */
-
-		/* Emit */
-		"declaration": true,																 /* Generate .d.ts files from TypeScript and JavaScript files in your project. */
-		"declarationMap": true,															/* Create sourcemaps for d.ts files. */
-		"noEmit": true,																			/* Disable emitting files from a compilation. */
-
-		/* Interop Constraints */
-		"allowSyntheticDefaultImports": true,								/* Allow `import x from y` when a module doesn't have a default export. */
-		"esModuleInterop": true,														 /* Emit additional JavaScript to ease support for importing CommonJS modules. This enables `allowSyntheticDefaultImports` for type compatibility. */
-		"forceConsistentCasingInFileNames": true,						/* Ensure that casing is correct in imports. */
-
-		/* Type Checking */
-		"strict": true,																			/* Enable all strict type-checking options. */
-
-		/* Completeness */
-		// "skipLibCheck": true															/* Skip type checking all .d.ts files. */
+		"target": "es2022",
 	},
 	"exclude": [
 		"coverage",

backend/node_modules/get-intrinsic/.eslintrc

@@ -11,6 +11,10 @@
 		"es2022": true,
 	},
 
+	"globals": {
+		"Float16Array": false,
+	},
+
 	"rules": {
 		"array-bracket-newline": 0,
 		"complexity": 0,

backend/node_modules/get-intrinsic/CHANGELOG.md

@@ -5,6 +5,49 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/)
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [v1.3.0](https://github.com/ljharb/get-intrinsic/compare/v1.2.7...v1.3.0) - 2025-02-22
+
+### Commits
+
+- [Dev Deps] update `es-abstract`, `es-value-fixtures`, `for-each`, `object-inspect` [`9b61553`](https://github.com/ljharb/get-intrinsic/commit/9b61553c587f1c1edbd435597e88c7d387da97dd)
+- [Deps] update `call-bind-apply-helpers`, `es-object-atoms`, `get-proto` [`a341fee`](https://github.com/ljharb/get-intrinsic/commit/a341fee0f39a403b0f0069e82c97642d5eb11043)
+- [New] add `Float16Array` [`de22116`](https://github.com/ljharb/get-intrinsic/commit/de22116b492fb989a0341bceb6e573abfaed73dc)
+
+## [v1.2.7](https://github.com/ljharb/get-intrinsic/compare/v1.2.6...v1.2.7) - 2025-01-02
+
+### Commits
+
+- [Refactor] use `get-proto` directly [`00ab955`](https://github.com/ljharb/get-intrinsic/commit/00ab95546a0980c8ad42a84253daaa8d2adcedf9)
+- [Deps] update `math-intrinsics` [`c716cdd`](https://github.com/ljharb/get-intrinsic/commit/c716cdd6bbe36b438057025561b8bb5a879ac8a0)
+- [Dev Deps] update `call-bound`, `es-abstract` [`dc648a6`](https://github.com/ljharb/get-intrinsic/commit/dc648a67eb359037dff8d8619bfa71d86debccb1)
+
+## [v1.2.6](https://github.com/ljharb/get-intrinsic/compare/v1.2.5...v1.2.6) - 2024-12-11
+
+### Commits
+
+- [Refactor] use `math-intrinsics` [`841be86`](https://github.com/ljharb/get-intrinsic/commit/841be8641a9254c4c75483b30c8871b5d5065926)
+- [Refactor] use `es-object-atoms` [`42057df`](https://github.com/ljharb/get-intrinsic/commit/42057dfa16f66f64787e66482af381cc6f31d2c1)
+- [Deps] update `call-bind-apply-helpers` [`45afa24`](https://github.com/ljharb/get-intrinsic/commit/45afa24a9ee4d6d3c172db1f555b16cb27843ef4)
+- [Dev Deps] update `call-bound` [`9cba9c6`](https://github.com/ljharb/get-intrinsic/commit/9cba9c6e70212bc163b7a5529cb25df46071646f)
+
+## [v1.2.5](https://github.com/ljharb/get-intrinsic/compare/v1.2.4...v1.2.5) - 2024-12-06
+
+### Commits
+
+- [actions] split out node 10-20, and 20+ [`6e2b9dd`](https://github.com/ljharb/get-intrinsic/commit/6e2b9dd23902665681ebe453256ccfe21d7966f0)
+- [Refactor] use `dunder-proto` and `call-bind-apply-helpers` instead of `has-proto` [`c095d17`](https://github.com/ljharb/get-intrinsic/commit/c095d179ad0f4fbfff20c8a3e0cb4fe668018998)
+- [Refactor] use `gopd` [`9841d5b`](https://github.com/ljharb/get-intrinsic/commit/9841d5b35f7ab4fd2d193f0c741a50a077920e90)
+- [Dev Deps] update `@ljharb/eslint-config`, `auto-changelog`, `es-abstract`, `es-value-fixtures`, `gopd`, `mock-property`, `object-inspect`, `tape` [`2d07e01`](https://github.com/ljharb/get-intrinsic/commit/2d07e01310cee2cbaedfead6903df128b1f5d425)
+- [Deps] update `gopd`, `has-proto`, `has-symbols`, `hasown` [`974d8bf`](https://github.com/ljharb/get-intrinsic/commit/974d8bf5baad7939eef35c25cc1dd88c10a30fa6)
+- [Dev Deps] update `call-bind`, `es-abstract`, `tape` [`df9dde1`](https://github.com/ljharb/get-intrinsic/commit/df9dde178186631ab8a3165ede056549918ce4bc)
+- [Refactor] cache `es-define-property` as well [`43ef543`](https://github.com/ljharb/get-intrinsic/commit/43ef543cb02194401420e3a914a4ca9168691926)
+- [Deps] update `has-proto`, `has-symbols`, `hasown` [`ad4949d`](https://github.com/ljharb/get-intrinsic/commit/ad4949d5467316505aad89bf75f9417ed782f7af)
+- [Tests] use `call-bound` directly [`ad5c406`](https://github.com/ljharb/get-intrinsic/commit/ad5c4069774bfe90e520a35eead5fe5ca9d69e80)
+- [Deps] update `has-proto`, `hasown` [`45414ca`](https://github.com/ljharb/get-intrinsic/commit/45414caa312333a2798953682c68f85c550627dd)
+- [Tests] replace `aud` with `npm audit` [`18d3509`](https://github.com/ljharb/get-intrinsic/commit/18d3509f79460e7924da70409ee81e5053087523)
+- [Deps] update `es-define-property` [`aadaa3b`](https://github.com/ljharb/get-intrinsic/commit/aadaa3b2188d77ad9bff394ce5d4249c49eb21f5)
+- [Dev Deps] add missing peer dep [`c296a16`](https://github.com/ljharb/get-intrinsic/commit/c296a16246d0c9a5981944f4cc5cf61fbda0cf6a)
+
 ## [v1.2.4](https://github.com/ljharb/get-intrinsic/compare/v1.2.3...v1.2.4) - 2024-02-05
 
 ### Commits

backend/node_modules/get-intrinsic/index.js

@@ -2,6 +2,8 @@
 
 var undefined;
 
+var $Object = require('es-object-atoms');
+
 var $Error = require('es-errors');
 var $EvalError = require('es-errors/eval');
 var $RangeError = require('es-errors/range');
@@ -10,6 +12,14 @@ var $SyntaxError = require('es-errors/syntax');
 var $TypeError = require('es-errors/type');
 var $URIError = require('es-errors/uri');
 
+var abs = require('math-intrinsics/abs');
+var floor = require('math-intrinsics/floor');
+var max = require('math-intrinsics/max');
+var min = require('math-intrinsics/min');
+var pow = require('math-intrinsics/pow');
+var round = require('math-intrinsics/round');
+var sign = require('math-intrinsics/sign');
+
 var $Function = Function;
 
 // eslint-disable-next-line consistent-return
@@ -19,14 +29,8 @@ var getEvalledConstructor = function (expressionSyntax) {
 	} catch (e) {}
 };
 
-var $gOPD = Object.getOwnPropertyDescriptor;
-if ($gOPD) {
-	try {
-		$gOPD({}, '');
-	} catch (e) {
-		$gOPD = null; // this is IE 8, which has a broken gOPD
-	}
-}
+var $gOPD = require('gopd');
+var $defineProperty = require('es-define-property');
 
 var throwTypeError = function () {
 	throw new $TypeError();
@@ -49,13 +53,13 @@ var ThrowTypeError = $gOPD
 	: throwTypeError;
 
 var hasSymbols = require('has-symbols')();
-var hasProto = require('has-proto')();
 
-var getProto = Object.getPrototypeOf || (
-	hasProto
-		? function (x) { return x.__proto__; } // eslint-disable-line no-proto
-		: null
-);
+var getProto = require('get-proto');
+var $ObjectGPO = require('get-proto/Object.getPrototypeOf');
+var $ReflectGPO = require('get-proto/Reflect.getPrototypeOf');
+
+var $apply = require('call-bind-apply-helpers/functionApply');
+var $call = require('call-bind-apply-helpers/functionCall');
 
 var needsEval = {};
 
@@ -86,6 +90,7 @@ var INTRINSICS = {
 	'%Error%': $Error,
 	'%eval%': eval, // eslint-disable-line no-eval
 	'%EvalError%': $EvalError,
+	'%Float16Array%': typeof Float16Array === 'undefined' ? undefined : Float16Array,
 	'%Float32Array%': typeof Float32Array === 'undefined' ? undefined : Float32Array,
 	'%Float64Array%': typeof Float64Array === 'undefined' ? undefined : Float64Array,
 	'%FinalizationRegistry%': typeof FinalizationRegistry === 'undefined' ? undefined : FinalizationRegistry,
@@ -102,7 +107,8 @@ var INTRINSICS = {
 	'%MapIteratorPrototype%': typeof Map === 'undefined' || !hasSymbols || !getProto ? undefined : getProto(new Map()[Symbol.iterator]()),
 	'%Math%': Math,
 	'%Number%': Number,
-	'%Object%': Object,
+	'%Object%': $Object,
+	'%Object.getOwnPropertyDescriptor%': $gOPD,
 	'%parseFloat%': parseFloat,
 	'%parseInt%': parseInt,
 	'%Promise%': typeof Promise === 'undefined' ? undefined : Promise,
@@ -128,7 +134,20 @@ var INTRINSICS = {
 	'%URIError%': $URIError,
 	'%WeakMap%': typeof WeakMap === 'undefined' ? undefined : WeakMap,
 	'%WeakRef%': typeof WeakRef === 'undefined' ? undefined : WeakRef,
-	'%WeakSet%': typeof WeakSet === 'undefined' ? undefined : WeakSet
+	'%WeakSet%': typeof WeakSet === 'undefined' ? undefined : WeakSet,
+
+	'%Function.prototype.call%': $call,
+	'%Function.prototype.apply%': $apply,
+	'%Object.defineProperty%': $defineProperty,
+	'%Object.getPrototypeOf%': $ObjectGPO,
+	'%Math.abs%': abs,
+	'%Math.floor%': floor,
+	'%Math.max%': max,
+	'%Math.min%': min,
+	'%Math.pow%': pow,
+	'%Math.round%': round,
+	'%Math.sign%': sign,
+	'%Reflect.getPrototypeOf%': $ReflectGPO
 };
 
 if (getProto) {
@@ -223,11 +242,11 @@ var LEGACY_ALIASES = {
 
 var bind = require('function-bind');
 var hasOwn = require('hasown');
-var $concat = bind.call(Function.call, Array.prototype.concat);
-var $spliceApply = bind.call(Function.apply, Array.prototype.splice);
-var $replace = bind.call(Function.call, String.prototype.replace);
-var $strSlice = bind.call(Function.call, String.prototype.slice);
-var $exec = bind.call(Function.call, RegExp.prototype.exec);
+var $concat = bind.call($call, Array.prototype.concat);
+var $spliceApply = bind.call($apply, Array.prototype.splice);
+var $replace = bind.call($call, String.prototype.replace);
+var $strSlice = bind.call($call, String.prototype.slice);
+var $exec = bind.call($call, RegExp.prototype.exec);
 
 /* adapted from https://github.com/lodash/lodash/blob/4.17.15/dist/lodash.js#L6735-L6744 */
 var rePropName = /[^%.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|%$))/g;

backend/node_modules/get-intrinsic/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "get-intrinsic",
-	"version": "1.2.4",
+	"version": "1.3.0",
 	"description": "Get and robustly cache all JS language-level intrinsics at first require time",
 	"main": "index.js",
 	"exports": {
@@ -17,7 +17,7 @@
 		"pretest": "npm run lint",
 		"tests-only": "nyc tape 'test/**/*.js'",
 		"test": "npm run tests-only",
-		"posttest": "aud --production",
+		"posttest": "npx npm@'>= 10.2' audit --production",
 		"version": "auto-changelog && git add CHANGELOG.md",
 		"postversion": "auto-changelog && git add CHANGELOG.md && git commit --no-edit --amend && git tag -f \"v$(node -e \"console.log(require('./package.json').version)\")\""
 	},
@@ -43,26 +43,37 @@
 		"url": "https://github.com/ljharb/get-intrinsic/issues"
 	},
 	"homepage": "https://github.com/ljharb/get-intrinsic#readme",
+	"dependencies": {
+		"call-bind-apply-helpers": "^1.0.2",
+		"es-define-property": "^1.0.1",
+		"es-errors": "^1.3.0",
+		"es-object-atoms": "^1.1.1",
+		"function-bind": "^1.1.2",
+		"get-proto": "^1.0.1",
+		"gopd": "^1.2.0",
+		"has-symbols": "^1.1.0",
+		"hasown": "^2.0.2",
+		"math-intrinsics": "^1.1.0"
+	},
 	"devDependencies": {
-		"@ljharb/eslint-config": "^21.1.0",
-		"aud": "^2.0.4",
-		"auto-changelog": "^2.4.0",
-		"call-bind": "^1.0.5",
-		"es-abstract": "^1.22.3",
-		"es-value-fixtures": "^1.4.2",
+		"@ljharb/eslint-config": "^21.1.1",
+		"auto-changelog": "^2.5.0",
+		"call-bound": "^1.0.3",
+		"encoding": "^0.1.13",
+		"es-abstract": "^1.23.9",
+		"es-value-fixtures": "^1.7.1",
 		"eslint": "=8.8.0",
 		"evalmd": "^0.0.19",
-		"for-each": "^0.3.3",
-		"gopd": "^1.0.1",
+		"for-each": "^0.3.5",
 		"make-async-function": "^1.0.0",
 		"make-async-generator-function": "^1.0.0",
 		"make-generator-function": "^2.0.0",
-		"mock-property": "^1.0.3",
+		"mock-property": "^1.1.0",
 		"npmignore": "^0.3.1",
 		"nyc": "^10.3.2",
-		"object-inspect": "^1.13.1",
+		"object-inspect": "^1.13.4",
 		"safe-publish-latest": "^2.0.0",
-		"tape": "^5.7.4"
+		"tape": "^5.9.0"
 	},
 	"auto-changelog": {
 		"output": "CHANGELOG.md",
@@ -72,13 +83,6 @@
 		"backfillLimit": false,
 		"hideCredit": true
 	},
-	"dependencies": {
-		"es-errors": "^1.3.0",
-		"function-bind": "^1.1.2",
-		"has-proto": "^1.0.1",
-		"has-symbols": "^1.0.3",
-		"hasown": "^2.0.0"
-	},
 	"testling": {
 		"files": "test/GetIntrinsic.js"
 	},

backend/node_modules/get-intrinsic/test/GetIntrinsic.js

@@ -10,10 +10,10 @@ var asyncFns = require('make-async-function').list();
 var asyncGenFns = require('make-async-generator-function')();
 var mockProperty = require('mock-property');
 
-var callBound = require('call-bind/callBound');
+var callBound = require('call-bound');
 var v = require('es-value-fixtures');
 var $gOPD = require('gopd');
-var DefinePropertyOrThrow = require('es-abstract/2021/DefinePropertyOrThrow');
+var DefinePropertyOrThrow = require('es-abstract/2023/DefinePropertyOrThrow');
 
 var $isProto = callBound('%Object.prototype.isPrototypeOf%');
 

backend/node_modules/gopd/CHANGELOG.md

@@ -5,6 +5,26 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/)
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [v1.2.0](https://github.com/ljharb/gopd/compare/v1.1.0...v1.2.0) - 2024-12-03
+
+### Commits
+
+- [New] add `gOPD` entry point; remove `get-intrinsic` [`5b61232`](https://github.com/ljharb/gopd/commit/5b61232dedea4591a314bcf16101b1961cee024e)
+
+## [v1.1.0](https://github.com/ljharb/gopd/compare/v1.0.1...v1.1.0) - 2024-11-29
+
+### Commits
+
+- [New] add types [`f585e39`](https://github.com/ljharb/gopd/commit/f585e397886d270e4ba84e53d226e4f9ca2eb0e6)
+- [Dev Deps] update `@ljharb/eslint-config`, `auto-changelog`, `tape` [`0b8e4fd`](https://github.com/ljharb/gopd/commit/0b8e4fded64397a7726a9daa144a6cc9a5e2edfa)
+- [Dev Deps] update `aud`, `npmignore`, `tape` [`48378b2`](https://github.com/ljharb/gopd/commit/48378b2443f09a4f7efbd0fb6c3ee845a6cabcf3)
+- [Dev Deps] update `@ljharb/eslint-config`, `aud`, `tape` [`78099ee`](https://github.com/ljharb/gopd/commit/78099eeed41bfdc134c912280483689cc8861c31)
+- [Tests] replace `aud` with `npm audit` [`4e0d0ac`](https://github.com/ljharb/gopd/commit/4e0d0ac47619d24a75318a8e1f543ee04b2a2632)
+- [meta] add missing `engines.node` [`1443316`](https://github.com/ljharb/gopd/commit/14433165d07835c680155b3dfd62d9217d735eca)
+- [Deps] update `get-intrinsic` [`eee5f51`](https://github.com/ljharb/gopd/commit/eee5f51769f3dbaf578b70e2a3199116b01aa670)
+- [Deps] update `get-intrinsic` [`550c378`](https://github.com/ljharb/gopd/commit/550c3780e3a9c77b62565712a001b4ed64ea61f5)
+- [Dev Deps] add missing peer dep [`8c2ecf8`](https://github.com/ljharb/gopd/commit/8c2ecf848122e4e30abfc5b5086fb48b390dce75)
+
 ## [v1.0.1](https://github.com/ljharb/gopd/compare/v1.0.0...v1.0.1) - 2022-11-01
 
 ### Commits

backend/node_modules/gopd/index.js

@@ -1,8 +1,7 @@
 'use strict';
 
-var GetIntrinsic = require('get-intrinsic');
-
-var $gOPD = GetIntrinsic('%Object.getOwnPropertyDescriptor%', true);
+/** @type {import('.')} */
+var $gOPD = require('./gOPD');
 
 if ($gOPD) {
 	try {

backend/node_modules/gopd/package.json

@@ -1,10 +1,11 @@
 {
 	"name": "gopd",
-	"version": "1.0.1",
+	"version": "1.2.0",
 	"description": "`Object.getOwnPropertyDescriptor`, but accounts for IE's broken implementation.",
 	"main": "index.js",
 	"exports": {
 		".": "./index.js",
+		"./gOPD": "./gOPD.js",
 		"./package.json": "./package.json"
 	},
 	"sideEffects": false,
@@ -12,12 +13,13 @@
 		"prepack": "npmignore --auto --commentLines=autogenerated",
 		"prepublishOnly": "safe-publish-latest",
 		"prepublish": "not-in-publish || npm run prepublishOnly",
+		"prelint": "tsc -p . && attw -P",
 		"lint": "eslint --ext=js,mjs .",
 		"postlint": "evalmd README.md",
 		"pretest": "npm run lint",
 		"tests-only": "tape 'test/**/*.js'",
 		"test": "npm run tests-only",
-		"posttest": "aud --production",
+		"posttest": "npx npm@'>=10.2' audit --production",
 		"version": "auto-changelog && git add CHANGELOG.md",
 		"postversion": "auto-changelog && git add CHANGELOG.md && git commit --no-edit --amend && git tag -f \"v$(node -e \"console.log(require('./package.json').version)\")\""
 	},
@@ -41,19 +43,20 @@
 		"url": "https://github.com/ljharb/gopd/issues"
 	},
 	"homepage": "https://github.com/ljharb/gopd#readme",
-	"dependencies": {
-		"get-intrinsic": "^1.1.3"
-	},
 	"devDependencies": {
-		"@ljharb/eslint-config": "^21.0.0",
-		"aud": "^2.0.1",
-		"auto-changelog": "^2.4.0",
+		"@arethetypeswrong/cli": "^0.17.0",
+		"@ljharb/eslint-config": "^21.1.1",
+		"@ljharb/tsconfig": "^0.2.0",
+		"@types/tape": "^5.6.5",
+		"auto-changelog": "^2.5.0",
+		"encoding": "^0.1.13",
 		"eslint": "=8.8.0",
 		"evalmd": "^0.0.19",
 		"in-publish": "^2.0.1",
-		"npmignore": "^0.3.0",
+		"npmignore": "^0.3.1",
 		"safe-publish-latest": "^2.0.0",
-		"tape": "^5.6.1"
+		"tape": "^5.9.0",
+		"typescript": "next"
 	},
 	"auto-changelog": {
 		"output": "CHANGELOG.md",
@@ -67,5 +70,8 @@
 		"ignore": [
 			".github/workflows"
 		]
+	},
+	"engines": {
+		"node": ">= 0.4"
 	}
 }

backend/node_modules/gopd/test/index.js

@@ -10,6 +10,7 @@ test('gOPD', function (t) {
 		var obj = { x: 1 };
 		st.ok('x' in obj, 'property exists');
 
+		// @ts-expect-error TS can't figure out narrowing from `skip`
 		var desc = gOPD(obj, 'x');
 		st.deepEqual(
 			desc,
@@ -25,7 +26,7 @@ test('gOPD', function (t) {
 		st.end();
 	});
 
-	t.test('not supported', { skip: gOPD }, function (st) {
+	t.test('not supported', { skip: !!gOPD }, function (st) {
 		st.notOk(gOPD, 'is falsy');
 
 		st.end();

backend/node_modules/has-proto/.eslintrc

@@ -1,5 +0,0 @@
-{
-	"root": true,
-
-	"extends": "@ljharb",
-}

backend/node_modules/has-proto/.github/FUNDING.yml

@@ -1,12 +0,0 @@
-# These are supported funding model platforms
-
-github: [ljharb]
-patreon: # Replace with a single Patreon username
-open_collective: # Replace with a single Open Collective username
-ko_fi: # Replace with a single Ko-fi username
-tidelift: npm/has-proto
-community_bridge: # Replace with a single Community Bridge project-name e.g., cloud-foundry
-liberapay: # Replace with a single Liberapay username
-issuehunt: # Replace with a single IssueHunt username
-otechie: # Replace with a single Otechie username
-custom: # Replace with up to 4 custom sponsorship URLs e.g., ['link1', 'link2']

backend/node_modules/has-proto/CHANGELOG.md

@@ -1,38 +0,0 @@
-# Changelog
-
-All notable changes to this project will be documented in this file.
-
-The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/)
-and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
-
-## [v1.0.3](https://github.com/inspect-js/has-proto/compare/v1.0.2...v1.0.3) - 2024-02-19
-
-### Commits
-
-- [types] add missing declaration file [`26ecade`](https://github.com/inspect-js/has-proto/commit/26ecade05d253bb5dc376945ee3186d1fbe334f8)
-
-## [v1.0.2](https://github.com/inspect-js/has-proto/compare/v1.0.1...v1.0.2) - 2024-02-19
-
-### Commits
-
-- add types [`6435262`](https://github.com/inspect-js/has-proto/commit/64352626cf511c0276d5f4bb6be770a0bf0f8524)
-- [Dev Deps] update `@ljharb/eslint-config`, `aud`, `npmignore`, `tape` [`f16a5e4`](https://github.com/inspect-js/has-proto/commit/f16a5e4121651e551271419f9d60fdd3561fd82c)
-- [Refactor] tiny cleanup [`d1f1a4b`](https://github.com/inspect-js/has-proto/commit/d1f1a4bdc135f115a10f148ce302676224534702)
-- [meta] add `sideEffects` flag [`e7ab1a6`](https://github.com/inspect-js/has-proto/commit/e7ab1a6f153b3e80dee68d1748b71e46767a0531)
-
-## [v1.0.1](https://github.com/inspect-js/has-proto/compare/v1.0.0...v1.0.1) - 2022-12-21
-
-### Commits
-
-- [meta] correct URLs and description [`ef34483`](https://github.com/inspect-js/has-proto/commit/ef34483ca0d35680f271b6b96e35526151b25dfc)
-- [patch] add an additional criteria [`e81959e`](https://github.com/inspect-js/has-proto/commit/e81959ed7c7a77fbf459f00cb4ef824f1099497f)
-- [Dev Deps] update `aud` [`2bec2c4`](https://github.com/inspect-js/has-proto/commit/2bec2c47b072b122ff5443fba0263f6dc649531f)
-
-## v1.0.0 - 2022-12-12
-
-### Commits
-
-- Initial implementation, tests, readme [`6886fea`](https://github.com/inspect-js/has-proto/commit/6886fea578f67daf69a7920b2eb7637ea6ebb0bc)
-- Initial commit [`99129c8`](https://github.com/inspect-js/has-proto/commit/99129c8f42471ac89cb681ba9cb9d52a583eb94f)
-- npm init [`2844ad8`](https://github.com/inspect-js/has-proto/commit/2844ad8e75b84d66a46765b3bab9d2e8ea692e10)
-- Only apps should have lockfiles [`c65bc5e`](https://github.com/inspect-js/has-proto/commit/c65bc5e40b9004463f7336d47c67245fb139a36a)

backend/node_modules/has-proto/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2022 Inspect JS
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

backend/node_modules/has-proto/README.md

@@ -1,38 +0,0 @@
-# has-proto <sup>[![Version Badge][npm-version-svg]][package-url]</sup>
-
-[![github actions][actions-image]][actions-url]
-[![coverage][codecov-image]][codecov-url]
-[![License][license-image]][license-url]
-[![Downloads][downloads-image]][downloads-url]
-
-[![npm badge][npm-badge-png]][package-url]
-
-Does this environment have the ability to set the [[Prototype]] of an object on creation with `__proto__`?
-
-## Example
-
-```js
-var hasProto = require('has-proto');
-var assert = require('assert');
-
-assert.equal(typeof hasProto(), 'boolean');
-```
-
-## Tests
-Simply clone the repo, `npm install`, and run `npm test`
-
-[package-url]: https://npmjs.org/package/has-proto
-[npm-version-svg]: https://versionbadg.es/inspect-js/has-proto.svg
-[deps-svg]: https://david-dm.org/inspect-js/has-proto.svg
-[deps-url]: https://david-dm.org/inspect-js/has-proto
-[dev-deps-svg]: https://david-dm.org/inspect-js/has-proto/dev-status.svg
-[dev-deps-url]: https://david-dm.org/inspect-js/has-proto#info=devDependencies
-[npm-badge-png]: https://nodei.co/npm/has-proto.png?downloads=true&stars=true
-[license-image]: https://img.shields.io/npm/l/has-proto.svg
-[license-url]: LICENSE
-[downloads-image]: https://img.shields.io/npm/dm/has-proto.svg
-[downloads-url]: https://npm-stat.com/charts.html?package=has-proto
-[codecov-image]: https://codecov.io/gh/inspect-js/has-proto/branch/main/graphs/badge.svg
-[codecov-url]: https://app.codecov.io/gh/inspect-js/has-proto/
-[actions-image]: https://img.shields.io/endpoint?url=https://github-actions-badge-u3jn4tfpocch.runkit.sh/inspect-js/has-proto
-[actions-url]: https://github.com/inspect-js/has-proto/actions

backend/node_modules/has-proto/index.d.ts

@@ -1,3 +0,0 @@
-declare function hasProto(): boolean;
-
-export = hasProto;

backend/node_modules/has-proto/index.js

@@ -1,15 +0,0 @@
-'use strict';
-
-var test = {
-	__proto__: null,
-	foo: {}
-};
-
-var $Object = Object;
-
-/** @type {import('.')} */
-module.exports = function hasProto() {
-	// @ts-expect-error: TS errors on an inherited property for some reason
-	return { __proto__: test }.foo === test.foo
-		&& !(test instanceof $Object);
-};

backend/node_modules/has-proto/package.json

@@ -1,78 +0,0 @@
-{
-	"name": "has-proto",
-	"version": "1.0.3",
-	"description": "Does this environment have the ability to get the [[Prototype]] of an object on creation with `__proto__`?",
-	"main": "index.js",
-	"exports": {
-		".": "./index.js",
-		"./package.json": "./package.json"
-	},
-	"sideEffects": false,
-	"scripts": {
-		"prepack": "npmignore --auto --commentLines=autogenerated",
-		"prepublishOnly": "safe-publish-latest",
-		"prepublish": "not-in-publish || npm run prepublishOnly",
-		"lint": "eslint --ext=js,mjs .",
-		"postlint": "tsc -p .",
-		"pretest": "npm run lint",
-		"tests-only": "tape 'test/**/*.js'",
-		"test": "npm run tests-only",
-		"posttest": "aud --production",
-		"version": "auto-changelog && git add CHANGELOG.md",
-		"postversion": "auto-changelog && git add CHANGELOG.md && git commit --no-edit --amend && git tag -f \"v$(node -e \"console.log(require('./package.json').version)\")\""
-	},
-	"repository": {
-		"type": "git",
-		"url": "git+https://github.com/inspect-js/has-proto.git"
-	},
-	"keywords": [
-		"prototype",
-		"proto",
-		"set",
-		"get",
-		"__proto__",
-		"getPrototypeOf",
-		"setPrototypeOf",
-		"has"
-	],
-	"author": "Jordan Harband <ljharb@gmail.com>",
-	"funding": {
-		"url": "https://github.com/sponsors/ljharb"
-	},
-	"license": "MIT",
-	"bugs": {
-		"url": "https://github.com/inspect-js/has-proto/issues"
-	},
-	"homepage": "https://github.com/inspect-js/has-proto#readme",
-	"testling": {
-		"files": "test/index.js"
-	},
-	"devDependencies": {
-		"@ljharb/eslint-config": "^21.1.0",
-		"@types/tape": "^5.6.4",
-		"aud": "^2.0.4",
-		"auto-changelog": "^2.4.0",
-		"eslint": "=8.8.0",
-		"in-publish": "^2.0.1",
-		"npmignore": "^0.3.1",
-		"safe-publish-latest": "^2.0.0",
-		"tape": "^5.7.5",
-		"typescript": "next"
-	},
-	"engines": {
-		"node": ">= 0.4"
-	},
-	"auto-changelog": {
-		"output": "CHANGELOG.md",
-		"template": "keepachangelog",
-		"unreleased": false,
-		"commitLimit": false,
-		"backfillLimit": false,
-		"hideCredit": true
-	},
-	"publishConfig": {
-		"ignore": [
-			".github/workflows"
-		]
-	}
-}

backend/node_modules/has-proto/test/index.js

@@ -1,19 +0,0 @@
-'use strict';
-
-var test = require('tape');
-var hasProto = require('../');
-
-test('hasProto', function (t) {
-	var result = hasProto();
-	t.equal(typeof result, 'boolean', 'returns a boolean (' + result + ')');
-
-	var obj = { __proto__: null };
-	if (result) {
-		t.notOk('toString' in obj, 'null object lacks toString');
-	} else {
-		t.ok('toString' in obj, 'without proto, null object has toString');
-		t.equal(obj.__proto__, null); // eslint-disable-line no-proto
-	}
-
-	t.end();
-});

backend/node_modules/has-proto/tsconfig.json

@@ -1,49 +0,0 @@
-{
-  "compilerOptions": {
-    /* Visit https://aka.ms/tsconfig to read more about this file */
-
-    /* Projects */
-
-    /* Language and Environment */
-    "target": "ESNext",                                  /* Set the JavaScript language version for emitted JavaScript and include compatible library declarations. */
-    // "lib": [],                                        /* Specify a set of bundled library declaration files that describe the target runtime environment. */
-    // "noLib": true,                                    /* Disable including any library files, including the default lib.d.ts. */
-    "useDefineForClassFields": true,                     /* Emit ECMAScript-standard-compliant class fields. */
-    // "moduleDetection": "auto",                        /* Control what method is used to detect module-format JS files. */
-
-    /* Modules */
-    "module": "commonjs",                                /* Specify what module code is generated. */
-    // "rootDir": "./",                                  /* Specify the root folder within your source files. */
-    // "moduleResolution": "node10",                     /* Specify how TypeScript looks up a file from a given module specifier. */
-    // "baseUrl": "./",                                  /* Specify the base directory to resolve non-relative module names. */
-    // "paths": {},                                      /* Specify a set of entries that re-map imports to additional lookup locations. */
-    // "rootDirs": [],                                   /* Allow multiple folders to be treated as one when resolving modules. */
-    "typeRoots": ["types"],                              /* Specify multiple folders that act like './node_modules/@types'. */
-    "resolveJsonModule": true,                           /* Enable importing .json files. */
-    // "allowArbitraryExtensions": true,                 /* Enable importing files with any extension, provided a declaration file is present. */
-
-    /* JavaScript Support */
-    "allowJs": true,                                     /* Allow JavaScript files to be a part of your program. Use the 'checkJS' option to get errors from these files. */
-    "checkJs": true,                                     /* Enable error reporting in type-checked JavaScript files. */
-    "maxNodeModuleJsDepth": 0,                           /* Specify the maximum folder depth used for checking JavaScript files from 'node_modules'. Only applicable with 'allowJs'. */
-
-    /* Emit */
-    "declaration": true,                                 /* Generate .d.ts files from TypeScript and JavaScript files in your project. */
-    "declarationMap": true,                              /* Create sourcemaps for d.ts files. */
-    "noEmit": true,                                      /* Disable emitting files from a compilation. */
-
-    /* Interop Constraints */
-    "allowSyntheticDefaultImports": true,                /* Allow 'import x from y' when a module doesn't have a default export. */
-    "esModuleInterop": true,                             /* Emit additional JavaScript to ease support for importing CommonJS modules. This enables 'allowSyntheticDefaultImports' for type compatibility. */
-    "forceConsistentCasingInFileNames": true,            /* Ensure that casing is correct in imports. */
-
-    /* Type Checking */
-    "strict": true,                                      /* Enable all strict type-checking options. */
-
-    /* Completeness */
-    //"skipLibCheck": true                                 /* Skip type checking all .d.ts files. */
-  },
-  "exclude": [
-    "coverage"
-  ]
-}

backend/node_modules/has-symbols/CHANGELOG.md

@@ -5,6 +5,22 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/)
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [v1.1.0](https://github.com/inspect-js/has-symbols/compare/v1.0.3...v1.1.0) - 2024-12-02
+
+### Commits
+
+- [actions] update workflows [`548c0bf`](https://github.com/inspect-js/has-symbols/commit/548c0bf8c9b1235458df7a1c0490b0064647a282)
+- [actions] further shard; update action deps [`bec56bb`](https://github.com/inspect-js/has-symbols/commit/bec56bb0fb44b43a786686b944875a3175cf3ff3)
+- [meta] use `npmignore` to autogenerate an npmignore file [`ac81032`](https://github.com/inspect-js/has-symbols/commit/ac81032809157e0a079e5264e9ce9b6f1275777e)
+- [New] add types [`6469cbf`](https://github.com/inspect-js/has-symbols/commit/6469cbff1866cfe367b2b3d181d9296ec14b2a3d)
+- [actions] update rebase action to use reusable workflow [`9c9d4d0`](https://github.com/inspect-js/has-symbols/commit/9c9d4d0d8938e4b267acdf8e421f4e92d1716d72)
+- [Dev Deps] update `eslint`, `@ljharb/eslint-config`, `aud`, `tape` [`adb5887`](https://github.com/inspect-js/has-symbols/commit/adb5887ca9444849b08beb5caaa9e1d42320cdfb)
+- [Dev Deps] update `@ljharb/eslint-config`, `aud`, `tape` [`13ec198`](https://github.com/inspect-js/has-symbols/commit/13ec198ec80f1993a87710af1606a1970b22c7cb)
+- [Dev Deps] update `auto-changelog`, `core-js`, `tape` [`941be52`](https://github.com/inspect-js/has-symbols/commit/941be5248387cab1da72509b22acf3fdb223f057)
+- [Tests] replace `aud` with `npm audit` [`74f49e9`](https://github.com/inspect-js/has-symbols/commit/74f49e9a9d17a443020784234a1c53ce765b3559)
+- [Dev Deps] update `npmignore` [`9c0ac04`](https://github.com/inspect-js/has-symbols/commit/9c0ac0452a834f4c2a4b54044f2d6a89f17e9a70)
+- [Dev Deps] add missing peer dep [`52337a5`](https://github.com/inspect-js/has-symbols/commit/52337a5621cced61f846f2afdab7707a8132cc12)
+
 ## [v1.0.3](https://github.com/inspect-js/has-symbols/compare/v1.0.2...v1.0.3) - 2022-03-01
 
 ### Commits

backend/node_modules/has-symbols/index.js

@@ -3,6 +3,7 @@
 var origSymbol = typeof Symbol !== 'undefined' && Symbol;
 var hasSymbolSham = require('./shams');
 
+/** @type {import('.')} */
 module.exports = function hasNativeSymbols() {
 	if (typeof origSymbol !== 'function') { return false; }
 	if (typeof Symbol !== 'function') { return false; }

backend/node_modules/has-symbols/package.json

@@ -1,21 +1,23 @@
 {
 	"name": "has-symbols",
-	"version": "1.0.3",
+	"version": "1.1.0",
 	"description": "Determine if the JS environment has Symbol support. Supports spec, or shams.",
 	"main": "index.js",
 	"scripts": {
+		"prepack": "npmignore --auto --commentLines=autogenerated",
 		"prepublishOnly": "safe-publish-latest",
 		"prepublish": "not-in-publish || npm run prepublishOnly",
 		"pretest": "npm run --silent lint",
 		"test": "npm run tests-only",
-		"posttest": "aud --production",
-		"tests-only": "npm run test:stock && npm run test:staging && npm run test:shams",
+		"posttest": "npx npm@'>=10.2' audit --production",
+		"tests-only": "npm run test:stock && npm run test:shams",
 		"test:stock": "nyc node test",
 		"test:staging": "nyc node --harmony --es-staging test",
 		"test:shams": "npm run --silent test:shams:getownpropertysymbols && npm run --silent test:shams:corejs",
 		"test:shams:corejs": "nyc node test/shams/core-js.js",
 		"test:shams:getownpropertysymbols": "nyc node test/shams/get-own-property-symbols.js",
 		"lint": "eslint --ext=js,mjs .",
+		"postlint": "tsc -p . && attw -P",
 		"version": "auto-changelog && git add CHANGELOG.md",
 		"postversion": "auto-changelog && git add CHANGELOG.md && git commit --no-edit --amend && git tag -f \"v$(node -e \"console.log(require('./package.json').version)\")\""
 	},
@@ -54,15 +56,22 @@
 	},
 	"homepage": "https://github.com/ljharb/has-symbols#readme",
 	"devDependencies": {
-		"@ljharb/eslint-config": "^20.2.3",
-		"aud": "^2.0.0",
-		"auto-changelog": "^2.4.0",
+		"@arethetypeswrong/cli": "^0.17.0",
+		"@ljharb/eslint-config": "^21.1.1",
+		"@ljharb/tsconfig": "^0.2.0",
+		"@types/core-js": "^2.5.8",
+		"@types/tape": "^5.6.5",
+		"auto-changelog": "^2.5.0",
 		"core-js": "^2.6.12",
+		"encoding": "^0.1.13",
 		"eslint": "=8.8.0",
 		"get-own-property-symbols": "^0.9.5",
+		"in-publish": "^2.0.1",
+		"npmignore": "^0.3.1",
 		"nyc": "^10.3.2",
 		"safe-publish-latest": "^2.0.0",
-		"tape": "^5.5.2"
+		"tape": "^5.9.0",
+		"typescript": "next"
 	},
 	"testling": {
 		"files": "test/index.js",
@@ -93,9 +102,10 @@
 		"backfillLimit": false,
 		"hideCredit": true
 	},
-	"greenkeeper": {
+	"publishConfig": {
 		"ignore": [
-			"core-js"
+			".github/workflows",
+			"types"
 		]
 	}
 }

backend/node_modules/has-symbols/shams.js

@@ -1,10 +1,12 @@
 'use strict';
 
+/** @type {import('./shams')} */
 /* eslint complexity: [2, 18], max-statements: [2, 33] */
 module.exports = function hasSymbols() {
 	if (typeof Symbol !== 'function' || typeof Object.getOwnPropertySymbols !== 'function') { return false; }
 	if (typeof Symbol.iterator === 'symbol') { return true; }
 
+	/** @type {{ [k in symbol]?: unknown }} */
 	var obj = {};
 	var sym = Symbol('test');
 	var symObj = Object(sym);
@@ -23,7 +25,7 @@ module.exports = function hasSymbols() {
 
 	var symVal = 42;
 	obj[sym] = symVal;
-	for (sym in obj) { return false; } // eslint-disable-line no-restricted-syntax, no-unreachable-loop
+	for (var _ in obj) { return false; } // eslint-disable-line no-restricted-syntax, no-unreachable-loop
 	if (typeof Object.keys === 'function' && Object.keys(obj).length !== 0) { return false; }
 
 	if (typeof Object.getOwnPropertyNames === 'function' && Object.getOwnPropertyNames(obj).length !== 0) { return false; }
@@ -34,7 +36,8 @@ module.exports = function hasSymbols() {
 	if (!Object.prototype.propertyIsEnumerable.call(obj, sym)) { return false; }
 
 	if (typeof Object.getOwnPropertyDescriptor === 'function') {
-		var descriptor = Object.getOwnPropertyDescriptor(obj, sym);
+		// eslint-disable-next-line no-extra-parens
+		var descriptor = /** @type {PropertyDescriptor} */ (Object.getOwnPropertyDescriptor(obj, sym));
 		if (descriptor.value !== symVal || descriptor.enumerable !== true) { return false; }
 	}
 

backend/node_modules/has-symbols/test/shams/core-js.js

@@ -8,6 +8,7 @@ if (typeof Symbol === 'function' && typeof Symbol() === 'symbol') {
 		t.equal(typeof Symbol(), 'symbol');
 		t.end();
 	});
+	// @ts-expect-error TS is stupid and doesn't know about top level return
 	return;
 }
 

backend/node_modules/has-symbols/test/shams/get-own-property-symbols.js

@@ -8,6 +8,7 @@ if (typeof Symbol === 'function' && typeof Symbol() === 'symbol') {
 		t.equal(typeof Symbol(), 'symbol');
 		t.end();
 	});
+	// @ts-expect-error TS is stupid and doesn't know about top level return
 	return;
 }
 

backend/node_modules/has-symbols/test/tests.js

@@ -1,5 +1,6 @@
 'use strict';
 
+/** @type {(t: import('tape').Test) => false | void} */
 // eslint-disable-next-line consistent-return
 module.exports = function runSymbolTests(t) {
 	t.equal(typeof Symbol, 'function', 'global Symbol is a function');
@@ -31,6 +32,7 @@ module.exports = function runSymbolTests(t) {
 
 	t.equal(typeof Object.getOwnPropertySymbols, 'function', 'Object.getOwnPropertySymbols is a function');
 
+	/** @type {{ [k in symbol]?: unknown }} */
 	var obj = {};
 	var sym = Symbol('test');
 	var symObj = Object(sym);
@@ -40,8 +42,8 @@ module.exports = function runSymbolTests(t) {
 
 	var symVal = 42;
 	obj[sym] = symVal;
-	// eslint-disable-next-line no-restricted-syntax
-	for (sym in obj) { t.fail('symbol property key was found in for..in of object'); }
+	// eslint-disable-next-line no-restricted-syntax, no-unused-vars
+	for (var _ in obj) { t.fail('symbol property key was found in for..in of object'); }
 
 	t.deepEqual(Object.keys(obj), [], 'no enumerable own keys on symbol-valued object');
 	t.deepEqual(Object.getOwnPropertyNames(obj), [], 'no own names on symbol-valued object');

backend/package-lock.json

@@ -10,10 +10,12 @@
       "hasInstallScript": true,
       "license": "ISC",
       "dependencies": {
+        "axios": "^1.12.2",
         "bcrypt": "^5.1.1",
         "cors": "^2.8.5",
         "crypto": "^1.0.1",
         "csv-parser": "^3.0.0",
+        "date-fns": "^2.30.0",
         "dotenv": "^16.4.5",
         "express": "^4.19.2",
         "iconv-lite": "^0.6.3",
@@ -30,6 +32,15 @@
         "vue-eslint-parser": "9.4.3"
       }
     },
+    "node_modules/@babel/runtime": {
+      "version": "7.28.4",
+      "resolved": "https://registry.npmjs.org/@babel/runtime/-/runtime-7.28.4.tgz",
+      "integrity": "sha512-Q/N6JNWvIvPnLDvjlE1OUBLPQHH6l3CltCEsHIujp45zQUSSh8K+gHnaEX45yAT1nyngnINhvWtzN+Nb9D8RAQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
     "node_modules/@emnapi/runtime": {
       "version": "1.2.0",
       "resolved": "https://registry.npmjs.org/@emnapi/runtime/-/runtime-1.2.0.tgz",
@@ -820,6 +831,12 @@
       "resolved": "https://registry.npmjs.org/array-flatten/-/array-flatten-1.1.1.tgz",
       "integrity": "sha512-PCVAQswWemu6UdxsDFFX/+gVeYqKAod3D3UVm91jHwynguOwAvYPhx8nNlM++NqRcK6CxxpUafjmhIdKiHibqg=="
     },
+    "node_modules/asynckit": {
+      "version": "0.4.0",
+      "resolved": "https://registry.npmjs.org/asynckit/-/asynckit-0.4.0.tgz",
+      "integrity": "sha512-Oei9OH4tRh0YqU3GxhX79dM/mwVgvbZJaSNaRk+bshkj0S5cfHcgYakreBjrHwatXKbz+IoIdYLxrKim2MjW0Q==",
+      "license": "MIT"
+    },
     "node_modules/aws-ssl-profiles": {
       "version": "1.1.1",
       "resolved": "https://registry.npmjs.org/aws-ssl-profiles/-/aws-ssl-profiles-1.1.1.tgz",
@@ -828,6 +845,17 @@
         "node": ">= 6.0.0"
       }
     },
+    "node_modules/axios": {
+      "version": "1.12.2",
+      "resolved": "https://registry.npmjs.org/axios/-/axios-1.12.2.tgz",
+      "integrity": "sha512-vMJzPewAlRyOgxV2dU0Cuz2O8zzzx9VYtbJOaBgXFeLc4IV/Eg50n4LowmehOOR61S8ZMpc2K5Sa7g6A4jfkUw==",
+      "license": "MIT",
+      "dependencies": {
+        "follow-redirects": "^1.15.6",
+        "form-data": "^4.0.4",
+        "proxy-from-env": "^1.1.0"
+      }
+    },
     "node_modules/balanced-match": {
       "version": "1.0.2",
       "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-1.0.2.tgz",
@@ -965,6 +993,19 @@
         "url": "https://github.com/sponsors/ljharb"
       }
     },
+    "node_modules/call-bind-apply-helpers": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/call-bind-apply-helpers/-/call-bind-apply-helpers-1.0.2.tgz",
+      "integrity": "sha512-Sp1ablJ0ivDkSzjcaJdxEunN5/XvksFJ2sMBFfq6x0ryhQV/2b/KwFe21cMpmHtPOSij8K99/wSfoEuTObmuMQ==",
+      "license": "MIT",
+      "dependencies": {
+        "es-errors": "^1.3.0",
+        "function-bind": "^1.1.2"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
     "node_modules/callsites": {
       "version": "3.1.0",
       "resolved": "https://registry.npmjs.org/callsites/-/callsites-3.1.0.tgz",
@@ -1094,6 +1135,18 @@
         "color-support": "bin.js"
       }
     },
+    "node_modules/combined-stream": {
+      "version": "1.0.8",
+      "resolved": "https://registry.npmjs.org/combined-stream/-/combined-stream-1.0.8.tgz",
+      "integrity": "sha512-FQN4MRfuJeHf7cBbBMJFXhKSDq+2kAArBlmRBvcvFE5BB1HZKXtSFASDhdlz9zOYwxh8lDdnvmMOe/+5cdoEdg==",
+      "license": "MIT",
+      "dependencies": {
+        "delayed-stream": "~1.0.0"
+      },
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
     "node_modules/concat-map": {
       "version": "0.0.1",
       "resolved": "https://registry.npmjs.org/concat-map/-/concat-map-0.0.1.tgz",
@@ -1237,6 +1290,22 @@
         "node": ">= 10"
       }
     },
+    "node_modules/date-fns": {
+      "version": "2.30.0",
+      "resolved": "https://registry.npmjs.org/date-fns/-/date-fns-2.30.0.tgz",
+      "integrity": "sha512-fnULvOpxnC5/Vg3NCiWelDsLiUc9bRwAPs/+LfTLNvetFCtCTN+yQz15C/fs4AwX1R9K5GLtLfn8QW+dWisaAw==",
+      "license": "MIT",
+      "dependencies": {
+        "@babel/runtime": "^7.21.0"
+      },
+      "engines": {
+        "node": ">=0.11"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/date-fns"
+      }
+    },
     "node_modules/debug": {
       "version": "2.6.9",
       "resolved": "https://registry.npmjs.org/debug/-/debug-2.6.9.tgz",
@@ -1269,6 +1338,15 @@
         "url": "https://github.com/sponsors/ljharb"
       }
     },
+    "node_modules/delayed-stream": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/delayed-stream/-/delayed-stream-1.0.0.tgz",
+      "integrity": "sha512-ZySD7Nf91aLB0RxL4KGrKHBXl7Eds1DAmEdcoVawXnLD7SDhpNgtuII2aAkg7a7QS41jxPSZ17p4VdGnMHk3MQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.4.0"
+      }
+    },
     "node_modules/delegates": {
       "version": "1.0.0",
       "resolved": "https://registry.npmjs.org/delegates/-/delegates-1.0.0.tgz",
@@ -1325,6 +1403,20 @@
       "resolved": "https://registry.npmjs.org/dottie/-/dottie-2.0.6.tgz",
       "integrity": "sha512-iGCHkfUc5kFekGiqhe8B/mdaurD+lakO9txNnTvKtA6PISrw86LgqHvRzWYPyoE2Ph5aMIrCw9/uko6XHTKCwA=="
     },
+    "node_modules/dunder-proto": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/dunder-proto/-/dunder-proto-1.0.1.tgz",
+      "integrity": "sha512-KIN/nDJBQRcXw0MLVhZE9iQHmG68qAVIBg9CqmUYjmQIhgij9U5MFvrqkUL5FbtyyzZuOeOt0zdeRe4UY7ct+A==",
+      "license": "MIT",
+      "dependencies": {
+        "call-bind-apply-helpers": "^1.0.1",
+        "es-errors": "^1.3.0",
+        "gopd": "^1.2.0"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
     "node_modules/ecdsa-sig-formatter": {
       "version": "1.0.11",
       "resolved": "https://registry.npmjs.org/ecdsa-sig-formatter/-/ecdsa-sig-formatter-1.0.11.tgz",
@@ -1352,13 +1444,10 @@
       }
     },
     "node_modules/es-define-property": {
-      "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/es-define-property/-/es-define-property-1.0.0.tgz",
-      "integrity": "sha512-jxayLKShrEqqzJ0eumQbVhTYQM27CfT1T35+gCgDFoL82JLsXqTJ76zv6A0YLOgEnLUMvLzsDsGIrl8NFpT2gQ==",
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/es-define-property/-/es-define-property-1.0.1.tgz",
+      "integrity": "sha512-e3nRfgfUZ4rNGL232gUgX06QNyyez04KdjFrF+LTRoOXmrOgFKDg4BCdsjW8EnT69eqdYGmRpJwiPVYNrCaW3g==",
       "license": "MIT",
-      "dependencies": {
-        "get-intrinsic": "^1.2.4"
-      },
       "engines": {
         "node": ">= 0.4"
       }
@@ -1372,6 +1461,33 @@
         "node": ">= 0.4"
       }
     },
+    "node_modules/es-object-atoms": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/es-object-atoms/-/es-object-atoms-1.1.1.tgz",
+      "integrity": "sha512-FGgH2h8zKNim9ljj7dankFPcICIK9Cp5bm+c2gQSYePhpaG5+esrLODihIorn+Pe6FGJzWhXQotPv73jTaldXA==",
+      "license": "MIT",
+      "dependencies": {
+        "es-errors": "^1.3.0"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/es-set-tostringtag": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/es-set-tostringtag/-/es-set-tostringtag-2.1.0.tgz",
+      "integrity": "sha512-j6vWzfrGVfyXxge+O0x5sh6cvxAog0a/4Rdd2K36zCMV5eJ+/+tOAngRO8cODMNWbVRdVlmGZQL2YS3yR8bIUA==",
+      "license": "MIT",
+      "dependencies": {
+        "es-errors": "^1.3.0",
+        "get-intrinsic": "^1.2.6",
+        "has-tostringtag": "^1.0.2",
+        "hasown": "^2.0.2"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
     "node_modules/escape-html": {
       "version": "1.0.3",
       "resolved": "https://registry.npmjs.org/escape-html/-/escape-html-1.0.3.tgz",
@@ -1762,6 +1878,42 @@
       "dev": true,
       "peer": true
     },
+    "node_modules/follow-redirects": {
+      "version": "1.15.11",
+      "resolved": "https://registry.npmjs.org/follow-redirects/-/follow-redirects-1.15.11.tgz",
+      "integrity": "sha512-deG2P0JfjrTxl50XGCDyfI97ZGVCxIpfKYmfyrQ54n5FO/0gfIES8C/Psl6kWVDolizcaaxZJnTS0QSMxvnsBQ==",
+      "funding": [
+        {
+          "type": "individual",
+          "url": "https://github.com/sponsors/RubenVerborgh"
+        }
+      ],
+      "license": "MIT",
+      "engines": {
+        "node": ">=4.0"
+      },
+      "peerDependenciesMeta": {
+        "debug": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/form-data": {
+      "version": "4.0.4",
+      "resolved": "https://registry.npmjs.org/form-data/-/form-data-4.0.4.tgz",
+      "integrity": "sha512-KrGhL9Q4zjj0kiUt5OO4Mr/A/jlI2jDYs5eHBpYHPcBEVSiipAvn2Ko2HnPe20rmcuuvMHNdZFp+4IlGTMF0Ow==",
+      "license": "MIT",
+      "dependencies": {
+        "asynckit": "^0.4.0",
+        "combined-stream": "^1.0.8",
+        "es-set-tostringtag": "^2.1.0",
+        "hasown": "^2.0.2",
+        "mime-types": "^2.1.12"
+      },
+      "engines": {
+        "node": ">= 6"
+      }
+    },
     "node_modules/forwarded": {
       "version": "0.2.0",
       "resolved": "https://registry.npmjs.org/forwarded/-/forwarded-0.2.0.tgz",
@@ -1858,16 +2010,21 @@
       }
     },
     "node_modules/get-intrinsic": {
-      "version": "1.2.4",
-      "resolved": "https://registry.npmjs.org/get-intrinsic/-/get-intrinsic-1.2.4.tgz",
-      "integrity": "sha512-5uYhsJH8VJBTv7oslg4BznJYhDoRI6waYCxMmCdnTrcCrHA/fCFKoTFz2JKKE0HdDFUF7/oQuhzumXJK7paBRQ==",
+      "version": "1.3.0",
+      "resolved": "https://registry.npmjs.org/get-intrinsic/-/get-intrinsic-1.3.0.tgz",
+      "integrity": "sha512-9fSjSaos/fRIVIp+xSJlE6lfwhES7LNtKaCBIamHsjr2na1BiABJPo0mOjjz8GJDURarmCPGqaiVg5mfjb98CQ==",
       "license": "MIT",
       "dependencies": {
+        "call-bind-apply-helpers": "^1.0.2",
+        "es-define-property": "^1.0.1",
         "es-errors": "^1.3.0",
+        "es-object-atoms": "^1.1.1",
         "function-bind": "^1.1.2",
-        "has-proto": "^1.0.1",
-        "has-symbols": "^1.0.3",
-        "hasown": "^2.0.0"
+        "get-proto": "^1.0.1",
+        "gopd": "^1.2.0",
+        "has-symbols": "^1.1.0",
+        "hasown": "^2.0.2",
+        "math-intrinsics": "^1.1.0"
       },
       "engines": {
         "node": ">= 0.4"
@@ -1876,6 +2033,19 @@
         "url": "https://github.com/sponsors/ljharb"
       }
     },
+    "node_modules/get-proto": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/get-proto/-/get-proto-1.0.1.tgz",
+      "integrity": "sha512-sTSfBjoXBp89JvIKIefqw7U2CCebsc74kiY6awiGogKtoSGbgjYE/G/+l9sF3MWFPNc9IcoOC4ODfKHfxFmp0g==",
+      "license": "MIT",
+      "dependencies": {
+        "dunder-proto": "^1.0.1",
+        "es-object-atoms": "^1.0.0"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
     "node_modules/glob": {
       "version": "7.2.3",
       "resolved": "https://registry.npmjs.org/glob/-/glob-7.2.3.tgz",
@@ -1922,12 +2092,12 @@
       }
     },
     "node_modules/gopd": {
-      "version": "1.0.1",
-      "resolved": "https://registry.npmjs.org/gopd/-/gopd-1.0.1.tgz",
-      "integrity": "sha512-d65bNlIadxvpb/A2abVdlqKqV563juRnZ1Wtk6s1sIR8uNsXR70xqIzVqxVf1eTqDunwT2MkczEeaezCKTZhwA==",
+      "version": "1.2.0",
+      "resolved": "https://registry.npmjs.org/gopd/-/gopd-1.2.0.tgz",
+      "integrity": "sha512-ZUKRh6/kUFoAiTAtTYPZJ3hw9wNxx+BIBOijnlG9PnrJsCcSjs1wyyD6vJpaYtgnzDrKYRSqf3OO6Rfa93xsRg==",
       "license": "MIT",
-      "dependencies": {
-        "get-intrinsic": "^1.1.3"
+      "engines": {
+        "node": ">= 0.4"
       },
       "funding": {
         "url": "https://github.com/sponsors/ljharb"
@@ -1954,10 +2124,10 @@
         "url": "https://github.com/sponsors/ljharb"
       }
     },
-    "node_modules/has-proto": {
-      "version": "1.0.3",
-      "resolved": "https://registry.npmjs.org/has-proto/-/has-proto-1.0.3.tgz",
-      "integrity": "sha512-SJ1amZAJUiZS+PhsVLf5tGydlaVB8EdFpaSO4gmiUKUOxk8qzn5AIy4ZeJUmh22znIdk/uMAUT2pl3FxzVUH+Q==",
+    "node_modules/has-symbols": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/has-symbols/-/has-symbols-1.1.0.tgz",
+      "integrity": "sha512-1cDNdwJ2Jaohmb3sg4OmKaMBwuC48sYni5HUw2DvsC8LjGTLK9h+eb1X6RyuOHe4hT0ULCW68iomhjUoKUqlPQ==",
       "license": "MIT",
       "engines": {
         "node": ">= 0.4"
@@ -1966,11 +2136,14 @@
         "url": "https://github.com/sponsors/ljharb"
       }
     },
-    "node_modules/has-symbols": {
-      "version": "1.0.3",
-      "resolved": "https://registry.npmjs.org/has-symbols/-/has-symbols-1.0.3.tgz",
-      "integrity": "sha512-l3LCuF6MgDNwTDKkdYGEihYjt5pRPbEg46rtlmnSPlUbgmB8LOIrKJbYYFBSbnPaJexMKtiPO8hmeRjRz2Td+A==",
+    "node_modules/has-tostringtag": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/has-tostringtag/-/has-tostringtag-1.0.2.tgz",
+      "integrity": "sha512-NqADB8VjPFLM2V0VvHUewwwsw0ZWBaIdgo+ieHtK3hasLz4qeCRjYcqfB6AQrBggRKppKF8L52/VqdVsO47Dlw==",
       "license": "MIT",
+      "dependencies": {
+        "has-symbols": "^1.0.3"
+      },
       "engines": {
         "node": ">= 0.4"
       },
@@ -2414,6 +2587,15 @@
         "semver": "bin/semver.js"
       }
     },
+    "node_modules/math-intrinsics": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/math-intrinsics/-/math-intrinsics-1.1.0.tgz",
+      "integrity": "sha512-/IXtbwEk5HTPyEwyKX6hGkYXxM9nbj64B+ilVJnC/R6B0pH5G4V3b0pVbL7DBj4tkhBAppbQUlf6F6Xl9LHu1g==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
     "node_modules/media-typer": {
       "version": "0.3.0",
       "resolved": "https://registry.npmjs.org/media-typer/-/media-typer-0.3.0.tgz",
@@ -2981,6 +3163,12 @@
         "node": ">= 0.10"
       }
     },
+    "node_modules/proxy-from-env": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/proxy-from-env/-/proxy-from-env-1.1.0.tgz",
+      "integrity": "sha512-D+zkORCbA9f1tdWRK0RaCR3GPv50cMxcrz4X8k5LTSUD1Dkw47mKJEZQNunItRTkWwgtaUSo1RVFRIG9ZXiFYg==",
+      "license": "MIT"
+    },
     "node_modules/pstree.remy": {
       "version": "1.1.8",
       "resolved": "https://registry.npmjs.org/pstree.remy/-/pstree.remy-1.1.8.tgz",

backend/package.json

@@ -14,6 +14,7 @@
   "license": "ISC",
   "description": "",
   "dependencies": {
+    "axios": "^1.12.2",
     "bcrypt": "^5.1.1",
     "cors": "^2.8.5",
     "crypto": "^1.0.1",

backend/routes/externalServiceRoutes.js

@@ -0,0 +1,36 @@
+import express from 'express';
+import externalServiceController from '../controllers/externalServiceController.js';
+import { authenticate } from '../middleware/authMiddleware.js';
+
+const router = express.Router();
+
+// All routes require authentication
+router.use(authenticate);
+
+// GET /api/external-service/account?service=mytischtennis - Get account
+router.get('/account', externalServiceController.getAccount);
+
+// GET /api/external-service/status?service=mytischtennis - Check status
+router.get('/status', externalServiceController.getStatus);
+
+// POST /api/external-service/account - Create or update account
+router.post('/account', externalServiceController.upsertAccount);
+
+// DELETE /api/external-service/account?service=mytischtennis - Delete account
+router.delete('/account', externalServiceController.deleteAccount);
+
+// POST /api/external-service/verify - Verify login
+router.post('/verify', externalServiceController.verifyLogin);
+
+// GET /api/external-service/session?service=mytischtennis - Get stored session
+router.get('/session', externalServiceController.getSession);
+
+// HeTTV specific routes
+// GET /api/external-service/hettv/main-page - Load HeTTV main page and find downloads
+router.get('/hettv/main-page', externalServiceController.loadHettvMainPage);
+
+// POST /api/external-service/hettv/download-page - Load specific HeTTV download page
+router.post('/hettv/download-page', externalServiceController.loadHettvDownloadPage);
+
+export default router;
+

backend/routes/memberRoutes.js

@@ -1,4 +1,4 @@
-import { getClubMembers, getWaitingApprovals, setClubMembers, uploadMemberImage, getMemberImage } from '../controllers/memberController.js';
+import { getClubMembers, getWaitingApprovals, setClubMembers, uploadMemberImage, getMemberImage, updateRatingsFromMyTischtennis } from '../controllers/memberController.js';
 import express from 'express';
 import { authenticate } from '../middleware/authMiddleware.js';
 import multer from 'multer';
@@ -13,5 +13,6 @@ router.get('/image/:clubId/:memberId', authenticate, getMemberImage);
 router.get('/get/:id/:showAll', authenticate, getClubMembers);
 router.post('/set/:id', authenticate, setClubMembers);
 router.get('/notapproved/:id', authenticate, getWaitingApprovals);
+router.post('/update-ratings/:id', authenticate, updateRatingsFromMyTischtennis);
 
 export default router;

backend/routes/predefinedActivityRoutes.js

@@ -23,6 +23,7 @@ router.get('/', authenticate, getAllPredefinedActivities);
 router.get('/:id', authenticate, getPredefinedActivityById);
 router.put('/:id', authenticate, updatePredefinedActivity);
 router.post('/:id/image', authenticate, upload.single('image'), uploadPredefinedActivityImage);
+router.put('/:id/image', authenticate, upload.single('image'), uploadPredefinedActivityImage);
 router.delete('/:id/image/:imageId', authenticate, deletePredefinedActivityImage);
 router.get('/search/query', authenticate, searchPredefinedActivities);
 router.post('/merge', authenticate, mergePredefinedActivities);

backend/server.js

@@ -8,7 +8,7 @@ import {
   DiaryNote, DiaryTag, MemberDiaryTag, DiaryDateTag, DiaryMemberNote, DiaryMemberTag,
   PredefinedActivity, PredefinedActivityImage, DiaryDateActivity, DiaryMemberActivity, Match, League, Team, Group,
   GroupActivity, Tournament, TournamentGroup, TournamentMatch, TournamentResult,
-  TournamentMember, Accident, UserToken, OfficialTournament, OfficialCompetition, OfficialCompetitionMember
+  TournamentMember, Accident, UserToken, OfficialTournament, OfficialCompetition, OfficialCompetitionMember, MyTischtennis
 } from './models/index.js';
 import authRoutes from './routes/authRoutes.js';
 import clubRoutes from './routes/clubRoutes.js';
@@ -33,6 +33,7 @@ import tournamentRoutes from './routes/tournamentRoutes.js';
 import accidentRoutes from './routes/accidentRoutes.js';
 import trainingStatsRoutes from './routes/trainingStatsRoutes.js';
 import officialTournamentRoutes from './routes/officialTournamentRoutes.js';
+import myTischtennisRoutes from './routes/myTischtennisRoutes.js';
 
 const app = express();
 const port = process.env.PORT || 3000;
@@ -40,7 +41,12 @@ const port = process.env.PORT || 3000;
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 
-app.use(cors());
+app.use(cors({
+  origin: true,
+  credentials: true,
+  methods: ['GET', 'POST', 'PUT', 'DELETE', 'OPTIONS'],
+  allowedHeaders: ['Content-Type', 'Authorization', 'authcode', 'userid']
+}));
 app.use(express.json());
 
 // Globale Fehlerbehandlung, damit der Server bei unerwarteten Fehlern nicht hart abstürzt
@@ -72,6 +78,7 @@ app.use('/api/tournament', tournamentRoutes);
 app.use('/api/accident', accidentRoutes);
 app.use('/api/training-stats', trainingStatsRoutes);
 app.use('/api/official-tournaments', officialTournamentRoutes);
+app.use('/api/mytischtennis', myTischtennisRoutes);
 
 app.use(express.static(path.join(__dirname, '../frontend/dist')));
 
@@ -171,6 +178,7 @@ app.get('*', (req, res) => {
     await safeSync(TournamentResult);
     await safeSync(Accident);
     await safeSync(UserToken);
+    await safeSync(MyTischtennis);
 
     app.listen(port, () => {
       console.log(`Server is running on http://localhost:${port}`);

backend/services/accidentService.js

@@ -3,6 +3,7 @@ import DiaryDate from '../models/DiaryDates.js';
 import Member from '../models/Member.js';
 import { checkAccess, getUserByToken} from '../utils/userUtils.js';
 
+import { devLog } from '../utils/logger.js';
 class AccidentService {
     async createAccident(userToken, clubId, memberId, diaryDateId, accident) {
         await checkAccess(userToken, clubId);
@@ -14,7 +15,7 @@ class AccidentService {
         if (!member || member.clubId != clubId) {
             throw new Error('Member not found');
         }
-        console.log(diaryDateId);
+        devLog(diaryDateId);
         const diaryDate = await DiaryDate.findByPk(diaryDateId);
         if (!diaryDate || diaryDate.clubId != clubId) {
             throw new Error('Diary date not found');

backend/services/authService.js

@@ -4,6 +4,7 @@ import User from '../models/User.js';
 import UserToken from '../models/UserToken.js';
 import { sendActivationEmail } from './emailService.js';
 
+import { devLog } from '../utils/logger.js';
 const register = async (email, password) => {
   try {
     const activationCode = Math.random().toString(36).substring(2, 15);
@@ -11,7 +12,7 @@ const register = async (email, password) => {
     await sendActivationEmail(email, activationCode);
     return user;
   } catch (error) {
-    console.log(error);
+    devLog(error);
     return null;
   }
 };
@@ -33,11 +34,11 @@ const login = async (email, password) => {
   if (!user || !(await bcrypt.compare(password, user.password))) {
     throw { status: 401, message: 'Ungültige Anmeldedaten' };
   }
-  const token = jwt.sign({ userId: user.id }, process.env.JWT_SECRET, { expiresIn: '1h' });
+  const token = jwt.sign({ userId: user.id }, process.env.JWT_SECRET, { expiresIn: '3h' });
   await UserToken.create({
     userId: user.id,
     token,
-    expiresAt: new Date(Date.now() + 3600 * 1000),
+    expiresAt: new Date(Date.now() + 3 * 3600 * 1000),
   });
   return { token };
 };

backend/services/diaryDateActivityService.js

@@ -2,47 +2,81 @@ import DiaryDateActivity from '../models/DiaryDateActivity.js';
 import GroupActivity from '../models/GroupActivity.js';
 import Group from '../models/Group.js';
 import PredefinedActivity from '../models/PredefinedActivity.js';
+import PredefinedActivityImage from '../models/PredefinedActivityImage.js';
 import { checkAccess } from '../utils/userUtils.js';
 import { Op } from 'sequelize';
 
+import { devLog } from '../utils/logger.js';
 class DiaryDateActivityService {
 
     async createActivity(userToken, clubId, data) {
-        console.log('[DiaryDateActivityService::createActivity] - check user access');
+        devLog('[DiaryDateActivityService::createActivity] - check user access');
         await checkAccess(userToken, clubId);
-        console.log('[DiaryDateActivityService::createActivity] - add: ', data);
+        devLog('[DiaryDateActivityService::createActivity] - add: ', data);
         const { activity, ...restData } = data;
-        let predefinedActivity = await PredefinedActivity.findOne({ where: { name: data.activity } });
+        // Versuche, die PredefinedActivity robust zu finden:
+        // 1) per übergebener ID
+        // 2) per Name ODER Code (das Feld "activity" kann Kürzel oder Name sein)
+        // 3) erst dann neu anlegen
+        let predefinedActivity = null;
+
+        if (data.predefinedActivityId) {
+            predefinedActivity = await PredefinedActivity.findByPk(data.predefinedActivityId);
+        }
+
+        if (!predefinedActivity) {
+            const normalized = (data.activity || '').trim();
+            if (normalized) {
+                predefinedActivity = await PredefinedActivity.findOne({
+                    where: {
+                        [Op.or]: [
+                            { name: normalized },
+                            { code: normalized }
+                        ]
+                    }
+                });
+            }
+        }
+
         if (!predefinedActivity) {
             predefinedActivity = await PredefinedActivity.create({
-                name: data.activity,
-                description: '',
-                duration: data.duration
+                name: data.name || data.activity || '',
+                code: data.code || (data.activity || ''),
+                description: data.description || '',
+                duration: data.duration && data.duration !== '' ? parseInt(data.duration) : null
             });
         }
         restData.predefinedActivityId = predefinedActivity.id; 
+        
+        // Bereinige duration-Feld für DiaryDateActivity
+        if (restData.duration === '' || restData.duration === undefined) {
+            restData.duration = null;
+        } else if (typeof restData.duration === 'string') {
+            restData.duration = parseInt(restData.duration);
+        }
+        
         const maxOrderId = await DiaryDateActivity.max('orderId', {
             where: { diaryDateId: data.diaryDateId } 
         });
         const newOrderId = maxOrderId !== null ? maxOrderId + 1 : 1;
         restData.orderId = newOrderId;
-        console.log('[DiaryDateActivityService::createActivity] - create diary date activity');
+        devLog('[DiaryDateActivityService::createActivity] - create diary date activity');
         return await DiaryDateActivity.create(restData);
     }
 
     async updateActivity(userToken, clubId, id, data) {
-        console.log('[DiaryDateActivityService::updateActivity] - check user access');
+        devLog('[DiaryDateActivityService::updateActivity] - check user access');
         await checkAccess(userToken, clubId);
-        console.log('[DiaryDateActivityService::updateActivity] - load activity', id);
+        devLog('[DiaryDateActivityService::updateActivity] - load activity', id);
         const activity = await DiaryDateActivity.findByPk(id);
         if (!activity) {
-            console.log('[DiaryDateActivityService::updateActivity] - activity not found');
+            devLog('[DiaryDateActivityService::updateActivity] - activity not found');
             throw new Error('Activity not found');
         }
 
         // Wenn customActivityName gesendet wird, müssen wir die PredefinedActivity behandeln
         if (data.customActivityName) {
-            console.log('[DiaryDateActivityService::updateActivity] - handling customActivityName:', data.customActivityName);
+            devLog('[DiaryDateActivityService::updateActivity] - handling customActivityName:', data.customActivityName);
             
             // Suche nach einer existierenden PredefinedActivity mit diesem Namen
             let predefinedActivity = await PredefinedActivity.findOne({ 
@@ -51,11 +85,11 @@ class DiaryDateActivityService {
             
             if (!predefinedActivity) {
                 // Erstelle eine neue PredefinedActivity
-                console.log('[DiaryDateActivityService::updateActivity] - creating new PredefinedActivity');
+                devLog('[DiaryDateActivityService::updateActivity] - creating new PredefinedActivity');
                 predefinedActivity = await PredefinedActivity.create({
                     name: data.customActivityName,
-                    description: '',
-                    duration: data.duration || activity.duration
+                    description: data.description || '',
+                    duration: data.duration && data.duration !== '' ? parseInt(data.duration) : (activity.duration || null)
                 });
             }
             
@@ -66,7 +100,7 @@ class DiaryDateActivityService {
             delete data.customActivityName;
         }
 
-        console.log('[DiaryDateActivityService::updateActivity] - update activity', clubId, id, data, JSON.stringify(data));
+        devLog('[DiaryDateActivityService::updateActivity] - update activity', clubId, id, data, JSON.stringify(data));
         return await activity.update(data);
     }
 
@@ -80,22 +114,22 @@ class DiaryDateActivityService {
     }
 
     async updateActivityOrder(userToken, clubId, id, newOrderId) {
-        console.log(`[DiaryDateActivityService::updateActivityOrder] - Start update for activity id: ${id}`);
-        console.log(`[DiaryDateActivityService::updateActivityOrder] - User token: ${userToken}, Club id: ${clubId}, New order id: ${newOrderId}`);
-        console.log('[DiaryDateActivityService::updateActivityOrder] - Checking user access');
+        devLog(`[DiaryDateActivityService::updateActivityOrder] - Start update for activity id: ${id}`);
+        devLog(`[DiaryDateActivityService::updateActivityOrder] - User token: ${userToken}, Club id: ${clubId}, New order id: ${newOrderId}`);
+        devLog('[DiaryDateActivityService::updateActivityOrder] - Checking user access');
         await checkAccess(userToken, clubId);
-        console.log('[DiaryDateActivityService::updateActivityOrder] - User access confirmed');
-        console.log(`[DiaryDateActivityService::updateActivityOrder] - Finding activity with id: ${id}`);
+        devLog('[DiaryDateActivityService::updateActivityOrder] - User access confirmed');
+        devLog(`[DiaryDateActivityService::updateActivityOrder] - Finding activity with id: ${id}`);
         const activity = await DiaryDateActivity.findByPk(id);
         if (!activity) {
             console.error('[DiaryDateActivityService::updateActivityOrder] - Activity not found, throwing error');
             throw new Error('Activity not found');
         }
-        console.log('[DiaryDateActivityService::updateActivityOrder] - Activity found:', activity);
+        devLog('[DiaryDateActivityService::updateActivityOrder] - Activity found:', activity);
         const currentOrderId = activity.orderId;
-        console.log(`[DiaryDateActivityService::updateActivityOrder] - Current order id: ${currentOrderId}`);
+        devLog(`[DiaryDateActivityService::updateActivityOrder] - Current order id: ${currentOrderId}`);
         if (newOrderId < currentOrderId) {
-            console.log(`[DiaryDateActivityService::updateActivityOrder] - Shifting items down. Moving activities with orderId between ${newOrderId} and ${currentOrderId - 1}`);
+            devLog(`[DiaryDateActivityService::updateActivityOrder] - Shifting items down. Moving activities with orderId between ${newOrderId} and ${currentOrderId - 1}`);
             await DiaryDateActivity.increment(
                 { orderId: 1 },
                 {
@@ -105,9 +139,9 @@ class DiaryDateActivityService {
                     },
                 }
             );
-            console.log(`[DiaryDateActivityService::updateActivityOrder] - Items shifted down`);
+            devLog(`[DiaryDateActivityService::updateActivityOrder] - Items shifted down`);
         } else if (newOrderId > currentOrderId) {
-            console.log(`[DiaryDateActivityService::updateActivityOrder] - Shifting items up. Moving activities with orderId between ${currentOrderId + 1} and ${newOrderId}`);
+            devLog(`[DiaryDateActivityService::updateActivityOrder] - Shifting items up. Moving activities with orderId between ${currentOrderId + 1} and ${newOrderId}`);
             await DiaryDateActivity.decrement(
                 { orderId: 1 },
                 {
@@ -117,23 +151,21 @@ class DiaryDateActivityService {
                     },
                 }
             );
-            console.log(`[DiaryDateActivityService::updateActivityOrder] - Items shifted up`);
+            devLog(`[DiaryDateActivityService::updateActivityOrder] - Items shifted up`);
         } else {
-            console.log('[DiaryDateActivityService::updateActivityOrder] - New order id is the same as the current order id. No shift required.');
+            devLog('[DiaryDateActivityService::updateActivityOrder] - New order id is the same as the current order id. No shift required.');
         }
-        console.log(`[DiaryDateActivityService::updateActivityOrder] - Setting new order id for activity id: ${id}`);
+        devLog(`[DiaryDateActivityService::updateActivityOrder] - Setting new order id for activity id: ${id}`);
         activity.orderId = newOrderId;
-        console.log('[DiaryDateActivityService::updateActivityOrder] - Saving activity with new order id');
+        devLog('[DiaryDateActivityService::updateActivityOrder] - Saving activity with new order id');
         const savedActivity = await activity.save();
-        console.log('[DiaryDateActivityService::updateActivityOrder] - Activity saved:', savedActivity);
-        console.log(`[DiaryDateActivityService::updateActivityOrder] - Finished update for activity id: ${id}`);
+        devLog('[DiaryDateActivityService::updateActivityOrder] - Activity saved:', savedActivity);
+        devLog(`[DiaryDateActivityService::updateActivityOrder] - Finished update for activity id: ${id}`);
         return savedActivity;
     }
 
     async getActivities(userToken, clubId, diaryDateId) {
-        console.log('[DiaryDateActivityService::getActivities] - check user access');
         await checkAccess(userToken, clubId);
-        console.log(`[DiaryDateActivityService::getActivities] - fetch activities for diaryDateId: ${diaryDateId}`);
         const activities = await DiaryDateActivity.findAll({
             where: { diaryDateId },
             order: [['orderId', 'ASC']],
@@ -141,6 +173,12 @@ class DiaryDateActivityService {
                 {
                     model: PredefinedActivity,
                     as: 'predefinedActivity',
+                    include: [
+                        {
+                            model: PredefinedActivityImage,
+                            as: 'images'
+                        }
+                    ]
                 },
                 {
                     model: GroupActivity, 
@@ -158,14 +196,70 @@ class DiaryDateActivityService {
                 }
             ]
         });
-        console.log(`[DiaryDateActivityService::getActivities] - found ${activities.length} activities`);
-        return activities;
+        
+        // Füge imageUrl zu jeder PredefinedActivity hinzu
+        const activitiesWithImages = await Promise.all(activities.map(async activity => {
+            // Konvertiere zu JSON und zurück, um alle Eigenschaften zu serialisieren
+            const activityData = activity.toJSON();
+            
+            if (activityData.predefinedActivity) {
+                // Hole die erste verfügbare Image-ID direkt aus der Datenbank
+                const allImages = await PredefinedActivityImage.findAll({
+                    where: { predefinedActivityId: activityData.predefinedActivity.id },
+                    order: [['createdAt', 'ASC']]
+                });
+                
+                const firstImage = allImages.length > 0 ? allImages[0] : null;
+                
+                // Füge Zeichnungsdaten hinzu, falls vorhanden
+                if (firstImage && firstImage.drawingData) {
+                    try {
+                        activityData.predefinedActivity.drawingData = JSON.parse(firstImage.drawingData);
+                    } catch (error) {
+                        console.error(`Activity ${activityData.predefinedActivity.id}: Error parsing drawingData:`, error);
+                    }
+                }
+                
+                if (firstImage) {
+                    // Füge sowohl imageUrl als auch imageLink mit Image-ID hinzu
+                    activityData.predefinedActivity.imageUrl = `/api/predefined-activities/${activityData.predefinedActivity.id}/image/${firstImage.id}`;
+                    activityData.predefinedActivity.imageLink = `/api/predefined-activities/${activityData.predefinedActivity.id}/image/${firstImage.id}`;
+                } else {
+                    // Fallback: Verwende den Basis-Pfad ohne Image-ID
+                    activityData.predefinedActivity.imageUrl = `/api/predefined-activities/${activityData.predefinedActivity.id}/image`;
+                    activityData.predefinedActivity.imageLink = `/api/predefined-activities/${activityData.predefinedActivity.id}/image`;
+                }
+            }
+            
+            // Auch für GroupActivities
+            if (activityData.groupActivities && activityData.groupActivities.length > 0) {
+                for (const groupActivity of activityData.groupActivities) {
+                    if (groupActivity.groupPredefinedActivity) {
+                        // Hole die erste verfügbare Image-ID direkt aus der Datenbank
+                        const firstImage = await PredefinedActivityImage.findOne({
+                            where: { predefinedActivityId: groupActivity.groupPredefinedActivity.id },
+                            order: [['createdAt', 'ASC']]
+                        });
+                        
+                        if (firstImage) {
+                            groupActivity.groupPredefinedActivity.imageUrl = `/api/predefined-activities/${groupActivity.groupPredefinedActivity.id}/image/${firstImage.id}`;
+                            groupActivity.groupPredefinedActivity.imageLink = `/api/predefined-activities/${groupActivity.groupPredefinedActivity.id}/image/${firstImage.id}`;
+                        } else {
+                            groupActivity.groupPredefinedActivity.imageUrl = `/api/predefined-activities/${groupActivity.groupPredefinedActivity.id}/image`;
+                            groupActivity.groupPredefinedActivity.imageLink = `/api/predefined-activities/${groupActivity.groupPredefinedActivity.id}/image`;
+                        }
+                    }
+                }
+            }
+            return activityData;
+        }));
+        return activitiesWithImages;
     }
 
     async addGroupActivity(userToken, clubId, diaryDateId, groupId, activity) {
-        console.log('[DiaryDateActivityService::addGroupActivity] Check user access');
+        devLog('[DiaryDateActivityService::addGroupActivity] Check user access');
         await checkAccess(userToken, clubId);
-        console.log('[DiaryDateActivityService::addGroupActivity] Check diary date');
+        devLog('[DiaryDateActivityService::addGroupActivity] Check diary date');
         const diaryDateActivity = await DiaryDateActivity.findOne({
             where: {
                 diaryDateId,
@@ -178,26 +272,26 @@ class DiaryDateActivityService {
             console.error('[DiaryDateActivityService::addGroupActivity] Activity not found');
             throw new Error('Activity not found');
         }
-        console.log('[DiaryDateActivityService::addGroupActivity] Check group');
+        devLog('[DiaryDateActivityService::addGroupActivity] Check group');
         const group = await Group.findByPk(groupId);
         if (!group || group.diaryDateId !== diaryDateActivity.diaryDateId) {
             console.error('[DiaryDateActivityService::addGroupActivity] Group and date don\'t fit');
             throw new Error('Group isn\'t related to date');
         }
-        console.log('[DiaryDateActivityService::addGroupActivity] Get predefined activity');
+        devLog('[DiaryDateActivityService::addGroupActivity] Get predefined activity');
         const [predefinedActivity, created] = await PredefinedActivity.findOrCreate({
             where: {
                 name: activity
             }
         });
-        console.log('[DiaryDateActivityService::addGroupActivity] Add group activity');
-        console.log(predefinedActivity);
+        devLog('[DiaryDateActivityService::addGroupActivity] Add group activity');
+        devLog(predefinedActivity);
         const activityData = {
             diaryDateActivity: diaryDateActivity.id,
             groupId: groupId,
             customActivity: predefinedActivity.id
         }
-        console.log(activityData);
+        devLog(activityData);
         return await GroupActivity.create(activityData);
     }
 }

backend/services/diaryDateTagService.js

@@ -6,6 +6,7 @@ import Member from "../models/Member.js";
 import { checkAccess } from '../utils/userUtils.js';
 import { Op, literal } from "sequelize";
 
+import { devLog } from '../utils/logger.js';
 class DiaryDateTagService {
     async getDiaryDateMemberTags(userToken, clubId, memberId) {
         await checkAccess(userToken, clubId);
@@ -35,7 +36,7 @@ class DiaryDateTagService {
     }
 
     async addDiaryDateTag(userToken, clubId, diaryDateId, memberId, tag) {
-        console.log(userToken, clubId, diaryDateId, memberId, tag);
+        devLog(userToken, clubId, diaryDateId, memberId, tag);
         await checkAccess(userToken, clubId);
         const tagObject = await DiaryTag.findOne({ where: { id: tag.id } });
         if (!tagObject) {

backend/services/diaryMemberService.js

@@ -3,6 +3,7 @@ import DiaryMemberTag from '../models/DiaryMemberTag.js';
 import { DiaryTag } from '../models/DiaryTag.js';
 import { checkAccess } from '../utils/userUtils.js';
 
+import { devLog } from '../utils/logger.js';
 class DiaryMemberService {
     async addNoteToMember(userToken, clubId, diaryDateId, memberId, content) {
         await checkAccess(userToken, clubId);
@@ -14,7 +15,7 @@ class DiaryMemberService {
 
     async getNotesForMember(userToken, clubId, diaryDateId, memberId) {
         await checkAccess(userToken, clubId);
-        console.log(clubId, diaryDateId, memberId);
+        devLog(clubId, diaryDateId, memberId);
         return await DiaryMemberNote.findAll({ where: { diaryDateId, memberId }, order: [['createdAt', 'DESC']] });
     }
 
@@ -50,7 +51,7 @@ class DiaryMemberService {
         if (tagLink) {
             await tagLink.destroy();
         } else {
-            console.log(diaryDateId, memberId, tagId);
+            devLog(diaryDateId, memberId, tagId);
             throw new Error('Das Tag ist nicht verknüpft.');
         }
     }

backend/services/diaryService.js

@@ -7,16 +7,17 @@ import DiaryDateTag from '../models/DiaryDateTag.js';
 import { checkAccess } from '../utils/userUtils.js';
 import HttpError from '../exceptions/HttpError.js';
 
+import { devLog } from '../utils/logger.js';
 class DiaryService {
     async getDatesForClub(userToken, clubId) {
-        console.log('[DiaryService::getDatesForClub] - Check user access');
+        devLog('[DiaryService::getDatesForClub] - Check user access');
         await checkAccess(userToken, clubId);
-        console.log('[DiaryService::getDatesForClub] - Validate club existence');
+        devLog('[DiaryService::getDatesForClub] - Validate club existence');
         const club = await Club.findByPk(clubId);
         if (!club) {
             throw new HttpError('Club not found', 404);
         }
-        console.log('[DiaryService::getDatesForClub] - Load diary dates');
+        devLog('[DiaryService::getDatesForClub] - Load diary dates');
         const dates = await DiaryDate.findAll({
             where: { clubId },
             include: [
@@ -29,14 +30,14 @@ class DiaryService {
     }
 
     async createDateForClub(userToken, clubId, date, trainingStart, trainingEnd) {
-        console.log('[DiaryService::createDateForClub] - Check user access');
+        devLog('[DiaryService::createDateForClub] - Check user access');
         await checkAccess(userToken, clubId);
-        console.log('[DiaryService::createDateForClub] - Validate club existence');
+        devLog('[DiaryService::createDateForClub] - Validate club existence');
         const club = await Club.findByPk(clubId);
         if (!club) {
             throw new HttpError('Club not found', 404);
         }
-        console.log('[DiaryService::createDateForClub] - Validate date');
+        devLog('[DiaryService::createDateForClub] - Validate date');
         const parsedDate = new Date(date);
         if (isNaN(parsedDate.getTime())) {
             throw new HttpError('Invalid date format', 400);
@@ -44,7 +45,7 @@ class DiaryService {
         if (trainingStart && trainingEnd && trainingStart >= trainingEnd) {
             throw new HttpError('Training start time must be before training end time', 400);
         }
-        console.log('[DiaryService::createDateForClub] - Create new diary date');
+        devLog('[DiaryService::createDateForClub] - Create new diary date');
         const newDate = await DiaryDate.create({
             date: parsedDate,
             clubId,
@@ -56,9 +57,9 @@ class DiaryService {
     }
 
     async updateTrainingTimes(userToken, clubId, dateId, trainingStart, trainingEnd) {
-        console.log('[DiaryService::updateTrainingTimes] - Check user access');
+        devLog('[DiaryService::updateTrainingTimes] - Check user access');
         await checkAccess(userToken, clubId);
-        console.log('[DiaryService::updateTrainingTimes] - Validate date');
+        devLog('[DiaryService::updateTrainingTimes] - Validate date');
         const diaryDate = await DiaryDate.findOne({ where: { clubId, id: dateId } });
         if (!diaryDate) {
             throw new HttpError('Diary entry not found', 404);
@@ -66,7 +67,7 @@ class DiaryService {
         if (trainingStart && trainingEnd && trainingStart >= trainingEnd) {
             throw new HttpError('Training start time must be before training end time', 400);
         }
-        console.log('[DiaryService::updateTrainingTimes] - Update training times');
+        devLog('[DiaryService::updateTrainingTimes] - Update training times');
         diaryDate.trainingStart = trainingStart || null;
         diaryDate.trainingEnd = trainingEnd || null;
         await diaryDate.save();
@@ -74,14 +75,14 @@ class DiaryService {
     }
 
     async addNoteToDate(userToken, diaryDateId, content) {
-        console.log('[DiaryService::addNoteToDate] - Add note');
+        devLog('[DiaryService::addNoteToDate] - Add note');
         await checkAccess(userToken, diaryDateId);
         await DiaryNote.create({ diaryDateId, content });
         return await DiaryNote.findAll({ where: { diaryDateId }, order: [['createdAt', 'DESC']] });
     }
 
     async deleteNoteFromDate(userToken, noteId) {
-        console.log('[DiaryService::deleteNoteFromDate] - Delete note');
+        devLog('[DiaryService::deleteNoteFromDate] - Delete note');
         const note = await DiaryNote.findByPk(noteId);
         if (!note) {
             throw new HttpError('Note not found', 404);
@@ -92,7 +93,7 @@ class DiaryService {
     }
 
     async addTagToDate(userToken, diaryDateId, tagName) {
-        console.log('[DiaryService::addTagToDate] - Add tag');
+        devLog('[DiaryService::addTagToDate] - Add tag');
         await checkAccess(userToken, diaryDateId);
         let tag = await DiaryTag.findOne({ where: { name: tagName } });
         if (!tag) {
@@ -105,29 +106,29 @@ class DiaryService {
 
     async addTagToDiaryDate(userToken, clubId, diaryDateId, tagId) {
         checkAccess(userToken, clubId);
-        console.log(`[DiaryService::addTagToDiaryDate] - diaryDateId: ${diaryDateId}, tagId: ${tagId}`);
+        devLog(`[DiaryService::addTagToDiaryDate] - diaryDateId: ${diaryDateId}, tagId: ${tagId}`);
         const diaryDate = await DiaryDate.findByPk(diaryDateId);
         if (!diaryDate) {
             throw new HttpError('DiaryDate not found', 404);
         }
-        console.log('[DiaryService::addTagToDiaryDate] - Add tag to diary date');
+        devLog('[DiaryService::addTagToDiaryDate] - Add tag to diary date');
         const existingEntry = await DiaryDateTag.findOne({
             where: { diaryDateId, tagId }
         });
         if (existingEntry) {
             return;
         }
-        console.log('[DiaryService::addTagToDiaryDate] - Tag not found, creating new entry');
+        devLog('[DiaryService::addTagToDiaryDate] - Tag not found, creating new entry');
         const tag = await DiaryTag.findByPk(tagId);  
         if (!tag) {
             throw new HttpError('Tag not found', 404);
         }
-        console.log('[DiaryService::addTagToDiaryDate] - Add tag to diary date');
+        devLog('[DiaryService::addTagToDiaryDate] - Add tag to diary date');
         await DiaryDateTag.create({
             diaryDateId,
             tagId
         });
-        console.log('[DiaryService::addTagToDiaryDate] - Get tags');
+        devLog('[DiaryService::addTagToDiaryDate] - Get tags');
         const tags = await DiaryDateTag.findAll({ where: {
             diaryDateId: diaryDateId },
             include: {
@@ -135,12 +136,12 @@ class DiaryService {
                 as: 'tag'
             }
         });  
-        console.log(tags);
+        devLog(tags);
         return tags.map(tag => tag.tag);
     }
 
     async getDiaryNotesForDateAndMember(diaryDateId, memberId) {
-        console.log('[DiaryService::getDiaryNotesForDateAndMember] - Fetching notes');
+        devLog('[DiaryService::getDiaryNotesForDateAndMember] - Fetching notes');
         return await DiaryNote.findAll({
             where: { diaryDateId, memberId },
             order: [['createdAt', 'DESC']]
@@ -153,19 +154,19 @@ class DiaryService {
     }
 
     async removeDateForClub(userToken, clubId, dateId) {
-        console.log('[DiaryService::removeDateForClub] - Check user access');
+        devLog('[DiaryService::removeDateForClub] - Check user access');
         await checkAccess(userToken, clubId);
-        console.log('[DiaryService::removeDateForClub] - Validate date');
+        devLog('[DiaryService::removeDateForClub] - Validate date');
         const diaryDate = await DiaryDate.findOne({ where: { id: dateId, clubId } });
         if (!diaryDate) {
             throw new HttpError('Diary entry not found', 404);
         }
-        console.log('[DiaryService::removeDateForClub] - Check for activities');
+        devLog('[DiaryService::removeDateForClub] - Check for activities');
         const activityCount = await DiaryDateActivity.count({ where: { diaryDateId: dateId } });
         if (activityCount > 0) {
             throw new HttpError('Cannot delete date with activities', 409);
         }
-        console.log('[DiaryService::removeDateForClub] - Delete diary date');
+        devLog('[DiaryService::removeDateForClub] - Delete diary date');
         await diaryDate.destroy();
         return { ok: true };
     }

backend/services/externalServiceService.js

@@ -0,0 +1,347 @@
+import ExternalServiceAccount from '../models/ExternalServiceAccount.js';
+import User from '../models/User.js';
+import myTischtennisClient from '../clients/myTischtennisClient.js';
+import hettvClient from '../clients/hettvClient.js';
+import HttpError from '../exceptions/HttpError.js';
+
+class ExternalServiceService {
+  /**
+   * Get the appropriate client for a service
+   */
+  getClientForService(service) {
+    switch (service) {
+      case 'mytischtennis':
+        return myTischtennisClient;
+      case 'hettv':
+        return hettvClient;
+      default:
+        throw new HttpError(400, `Unbekannter Service: ${service}`);
+    }
+  }
+
+  /**
+   * Get account for user and service
+   */
+  async getAccount(userId, service = 'mytischtennis') {
+    const account = await ExternalServiceAccount.findOne({
+      where: { userId, service },
+      attributes: ['id', 'service', 'email', 'savePassword', 'lastLoginAttempt', 'lastLoginSuccess', 'expiresAt', 'userData', 'clubId', 'clubName', 'fedNickname', 'createdAt', 'updatedAt']
+    });
+    return account;
+  }
+
+  /**
+   * Create or update external service account
+   */
+  async upsertAccount(userId, email, password, savePassword, userPassword, service = 'mytischtennis') {
+    // Verify user's app password
+    const user = await User.findByPk(userId);
+    if (!user) {
+      throw new HttpError(404, 'Benutzer nicht gefunden');
+    }
+
+    let loginResult = null;
+    
+    // Wenn ein Passwort gesetzt/geändert wird, App-Passwort verifizieren
+    if (password) {
+      const isValidPassword = await user.validatePassword(userPassword);
+      if (!isValidPassword) {
+        throw new HttpError(401, 'Ungültiges Passwort');
+      }
+
+      // Login-Versuch beim entsprechenden Service
+      const client = this.getClientForService(service);
+      loginResult = await client.login(email, password);
+      if (!loginResult.success) {
+        throw new HttpError(401, loginResult.error || `${service}-Login fehlgeschlagen. Bitte überprüfen Sie Ihre Zugangsdaten.`);
+      }
+    }
+
+    // Find or create account
+    let account = await ExternalServiceAccount.findOne({ where: { userId, service } });
+    
+    const now = new Date();
+    
+    if (account) {
+      // Update existing
+      account.email = email;
+      account.savePassword = savePassword;
+      
+      if (password && savePassword) {
+        account.setPassword(password);
+      } else if (!savePassword) {
+        account.encryptedPassword = null;
+      }
+      
+      if (loginResult && loginResult.success) {
+        account.lastLoginAttempt = now;
+        account.lastLoginSuccess = now;
+        account.accessToken = loginResult.accessToken;
+        account.refreshToken = loginResult.refreshToken;
+        account.expiresAt = loginResult.expiresAt;
+        account.cookie = loginResult.cookie;
+        account.userData = loginResult.user;
+        
+        // Hole Club-ID und Federation (nur für myTischtennis)
+        if (service === 'mytischtennis') {
+          console.log('[externalServiceService] - Getting user profile...');
+          const profileResult = await myTischtennisClient.getUserProfile(loginResult.cookie);
+          console.log('[externalServiceService] - Profile result:', {
+            success: profileResult.success,
+            clubId: profileResult.clubId,
+            clubName: profileResult.clubName,
+            fedNickname: profileResult.fedNickname
+          });
+          
+          if (profileResult.success) {
+            account.clubId = profileResult.clubId;
+            account.clubName = profileResult.clubName;
+            account.fedNickname = profileResult.fedNickname;
+            console.log('[externalServiceService] - Updated account with club data');
+          } else {
+            console.error('[externalServiceService] - Failed to get profile:', profileResult.error);
+          }
+        }
+      } else if (password) {
+        account.lastLoginAttempt = now;
+      }
+      
+      console.log('[externalServiceService] - Speichere Account (update).');
+      try {
+        await account.save();
+      } catch (e) {
+        console.error('[externalServiceService] - Fehler beim Speichern (update):', e.message, e.parent?.sqlMessage);
+        throw e;
+      }
+    } else {
+      // Create new
+      const accountData = {
+        userId,
+        service,
+        email,
+        savePassword,
+        lastLoginAttempt: password ? now : null,
+        lastLoginSuccess: loginResult?.success ? now : null
+      };
+      
+      if (loginResult && loginResult.success) {
+        accountData.accessToken = loginResult.accessToken;
+        accountData.refreshToken = loginResult.refreshToken;
+        accountData.expiresAt = loginResult.expiresAt;
+        accountData.cookie = loginResult.cookie;
+        accountData.userData = loginResult.user;
+        
+        // Hole Club-/Verbandsdaten nur für myTischtennis
+        if (service === 'mytischtennis') {
+          const profileResult = await myTischtennisClient.getUserProfile(loginResult.cookie);
+          if (profileResult.success) {
+            accountData.clubId = profileResult.clubId;
+            accountData.clubName = profileResult.clubName;
+            accountData.fedNickname = profileResult.fedNickname;
+          }
+        }
+      }
+      
+      console.log('[externalServiceService] - Erstelle Account (create).');
+      try {
+        account = await ExternalServiceAccount.create(accountData);
+      } catch (e) {
+        console.error('[externalServiceService] - Fehler beim Erstellen (create):', e.message, e.parent?.sqlMessage);
+        throw e;
+      }
+      
+      if (password && savePassword) {
+        account.setPassword(password);
+        console.log('[externalServiceService] - Speichere Passwort (nach create).');
+        try {
+          await account.save();
+        } catch (e) {
+          console.error('[externalServiceService] - Fehler beim Speichern (nach create):', e.message, e.parent?.sqlMessage);
+          throw e;
+        }
+      }
+    }
+
+    return {
+      id: account.id,
+      email: account.email,
+      savePassword: account.savePassword,
+      lastLoginAttempt: account.lastLoginAttempt,
+      lastLoginSuccess: account.lastLoginSuccess,
+      expiresAt: account.expiresAt
+    };
+  }
+
+  /**
+   * Delete external service account
+   */
+  async deleteAccount(userId, service = 'mytischtennis') {
+    const deleted = await ExternalServiceAccount.destroy({
+      where: { userId, service }
+    });
+    return deleted > 0;
+  }
+
+  /**
+   * Verify login with stored or provided credentials
+   */
+  async verifyLogin(userId, providedPassword = null, service = 'mytischtennis') {
+    const account = await ExternalServiceAccount.findOne({ where: { userId, service } });
+    
+    if (!account) {
+      throw new HttpError(404, `Kein ${service}-Account verknüpft`);
+    }
+
+    let password = providedPassword;
+    
+    // Wenn kein Passwort übergeben wurde, versuche gespeichertes Passwort zu verwenden
+    if (!password) {
+      if (!account.savePassword || !account.encryptedPassword) {
+        throw new HttpError(400, 'Kein Passwort gespeichert. Bitte geben Sie Ihr Passwort ein.');
+      }
+      password = account.getPassword();
+    }
+
+    // Login-Versuch
+    const now = new Date();
+    account.lastLoginAttempt = now;
+    const client = this.getClientForService(service);
+    const loginResult = await client.login(account.email, password);
+    
+    if (loginResult.success) {
+      account.lastLoginSuccess = now;
+      account.accessToken = loginResult.accessToken;
+      account.refreshToken = loginResult.refreshToken;
+      account.expiresAt = loginResult.expiresAt;
+      account.cookie = loginResult.cookie;
+      account.userData = loginResult.user;
+      
+      // Hole Club-/Verbandsdaten nur für myTischtennis
+      if (service === 'mytischtennis') {
+        console.log('[externalServiceService] - Getting myTischtennis user profile...');
+        const profileResult = await myTischtennisClient.getUserProfile(loginResult.cookie);
+        console.log('[externalServiceService] - Profile result:', {
+          success: profileResult.success,
+          clubId: profileResult.clubId,
+          clubName: profileResult.clubName,
+          fedNickname: profileResult.fedNickname
+        });
+        
+        if (profileResult.success) {
+          account.clubId = profileResult.clubId;
+          account.clubName = profileResult.clubName;
+          account.fedNickname = profileResult.fedNickname;
+          console.log('[externalServiceService] - Updated account with club data');
+        } else {
+          console.error('[externalServiceService] - Failed to get profile:', profileResult.error);
+        }
+      }
+      
+      await account.save();
+      
+      return {
+        success: true,
+        accessToken: loginResult.accessToken,
+        refreshToken: loginResult.refreshToken,
+        expiresAt: loginResult.expiresAt,
+        user: loginResult.user,
+        clubId: account.clubId,
+        clubName: account.clubName
+      };
+    } else {
+      await account.save(); // Save lastLoginAttempt
+      throw new HttpError(401, loginResult.error || 'myTischtennis-Login fehlgeschlagen');
+    }
+  }
+
+  /**
+   * Check if account is configured and ready
+   */
+  async checkAccountStatus(userId, service = 'mytischtennis') {
+    const account = await ExternalServiceAccount.findOne({ where: { userId, service } });
+    
+    return {
+      exists: !!account,
+      hasEmail: !!account?.email,
+      hasPassword: !!(account?.savePassword && account?.encryptedPassword),
+      hasValidSession: !!account?.accessToken && account?.expiresAt > Date.now() / 1000,
+      needsConfiguration: !account || !account.email,
+      needsPassword: !!account && (!account.savePassword || !account.encryptedPassword)
+    };
+  }
+  
+  /**
+   * Get stored session for user (for authenticated API requests)
+   */
+  async getSession(userId, service = 'mytischtennis') {
+    const account = await ExternalServiceAccount.findOne({ where: { userId, service } });
+    
+    if (!account) {
+      throw new HttpError(404, `Kein ${service}-Account verknüpft`);
+    }
+    
+    // Check if session is valid
+    if (service === 'hettv') {
+      // HeTTV nutzt Cookie-basierte Session, kein expiresAt verfügbar
+      if (!account.cookie) {
+        throw new HttpError(401, 'Session abgelaufen. Bitte erneut einloggen.');
+      }
+    } else {
+      if (!account.accessToken || !account.expiresAt || account.expiresAt < Date.now() / 1000) {
+        throw new HttpError(401, 'Session abgelaufen. Bitte erneut einloggen.');
+      }
+    }
+    
+    return {
+      accessToken: account.accessToken,
+      refreshToken: account.refreshToken,
+      cookie: account.cookie,
+      expiresAt: account.expiresAt,
+      userData: account.userData
+    };
+  }
+
+  /**
+   * Load HeTTV main page and find download links
+   */
+  async loadHettvMainPage(userId) {
+    const client = this.getClientForService('hettv');
+    let session = await this.getSession(userId, 'hettv');
+
+    const finalUrl = session.userData?.finalUrl || null;
+    let result = await client.getMainPageWithDownloads(session.cookie, finalUrl);
+
+    // Wenn Session abgelaufen: versuche automatischen Re-Login mit gespeichertem Passwort
+    if (!result.success && result.status === 401) {
+      const account = await ExternalServiceAccount.findOne({ where: { userId, service: 'hettv' } });
+      if (account && account.savePassword && account.encryptedPassword) {
+        const password = account.getPassword();
+        const login = await client.login(account.email, password);
+        if (login.success) {
+          // Session aktualisieren
+          account.cookie = login.cookie;
+          account.userData = login.user;
+          await account.save();
+          // Erneut versuchen
+          result = await client.getMainPageWithDownloads(login.cookie, login.user?.finalUrl || null);
+        }
+      }
+    }
+
+    return result;
+  }
+
+  /**
+   * Load specific HeTTV download page
+   */
+  async loadHettvDownloadPage(userId, downloadUrl) {
+    const session = await this.getSession(userId, 'hettv');
+    const client = this.getClientForService('hettv');
+
+    const finalUrl = session.userData?.finalUrl || null;
+    return await client.loadDownloadPage(downloadUrl, session.cookie, finalUrl);
+  }
+}
+
+export default new ExternalServiceService();
+

backend/services/groupService.js

@@ -3,6 +3,7 @@ import DiaryDate from '../models/DiaryDates.js';
 import HttpError from '../exceptions/HttpError.js';
 import Group from '../models/Group.js';
 
+import { devLog } from '../utils/logger.js';
 class GroupService {
 
     async checkDiaryDateToClub(clubId, dateId) {
@@ -40,7 +41,7 @@ class GroupService {
     }
 
     async changeGroup(userToken, groupId, clubId, dateId, name, lead) {
-        console.log("changeGroup: ", groupId, clubId, dateId, name, lead);
+        devLog("changeGroup: ", groupId, clubId, dateId, name, lead);
         await checkAccess(userToken, clubId);
         await this.checkDiaryDateToClub(clubId, dateId);
         const group = await Group.findOne({

backend/services/matchService.js

@@ -10,6 +10,7 @@ import Team from '../models/Team.js';
 import { checkAccess } from '../utils/userUtils.js';
 import { Op } from 'sequelize';
 
+import { devLog } from '../utils/logger.js';
 class MatchService {
 
     generateSeasonString(date = new Date()) {
@@ -78,7 +79,7 @@ class MatchService {
             return result;
 
         } catch (error) {
-            console.log('Error during CSV import:', error);
+            devLog('Error during CSV import:', error);
             throw error;
         }
     }

backend/services/memberNoteService.js

@@ -1,6 +1,7 @@
 import MemberNote from '../models/MemberNote.js';
 import { checkAccess } from '../utils/userUtils.js';
 
+import { devLog } from '../utils/logger.js';
 class MemberNoteService {
     async addNoteToMember(userToken, clubId, memberId, content) {
         await checkAccess(userToken, clubId);
@@ -8,7 +9,7 @@ class MemberNoteService {
     }
 
     async getNotesForMember(userToken, clubId, memberId) {
-        console.log(userToken, clubId);
+        devLog(userToken, clubId);
         await checkAccess(userToken, clubId);
         return await MemberNote.findAll({ 
             where: { memberId },

backend/services/memberService.js

@@ -6,13 +6,14 @@ import path from 'path';
 import fs from 'fs';
 import sharp from 'sharp';
 
+import { devLog } from '../utils/logger.js';
 class MemberService {
     async getApprovalRequests(userToken, clubId) {
-        console.log('[MemberService::getApprovalRequest] - Check user access');
+        devLog('[MemberService::getApprovalRequest] - Check user access');
         await checkAccess(userToken, clubId);
-        console.log('[MemberService::getApprovalRequest] - Load user');
+        devLog('[MemberService::getApprovalRequest] - Load user');
         const user = await getUserByToken(userToken);
-        console.log('[MemberService::getApprovalRequest] - Load userclub');
+        devLog('[MemberService::getApprovalRequest] - Load userclub');
         return await UserClub.findAll({
             where: {
                 clubId: clubId,
@@ -23,9 +24,9 @@ class MemberService {
     }
 
     async getClubMembers(userToken, clubId, showAll) {
-        console.log('[getClubMembers] - Check access');
+        devLog('[getClubMembers] - Check access');
         await checkAccess(userToken, clubId);
-        console.log('[getClubMembers] - Find members');
+        devLog('[getClubMembers] - Find members');
         const where = {
             clubId: clubId
         };
@@ -44,7 +45,7 @@ class MemberService {
                 });
             })
             .then(membersWithImageStatus => {
-                console.log('[getClubMembers] - return members');
+                devLog('[getClubMembers] - return members');
                 return membersWithImageStatus;
             })
             .catch(error => {
@@ -54,17 +55,17 @@ class MemberService {
     }
 
     async setClubMember(userToken, clubId, memberId, firstName, lastName, street, city, birthdate, phone, email, active = true, testMembership = false,
-        picsInInternetAllowed = false, gender = 'unknown') {
+        picsInInternetAllowed = false, gender = 'unknown', ttr = null, qttr = null) {
         try {
-            console.log('[setClubMembers] - Check access');
+            devLog('[setClubMembers] - Check access');
             await checkAccess(userToken, clubId);
-            console.log('[setClubMembers] - set default member');
+            devLog('[setClubMembers] - set default member');
             let member = null;
-            console.log('[setClubMembers] - load member if possible');
+            devLog('[setClubMembers] - load member if possible');
             if (memberId) {
                 member = await Member.findOne({ where: { id: memberId } });
             }
-            console.log('[setClubMembers] - set member');
+            devLog('[setClubMembers] - set member');
             if (member) {
                 member.firstName = firstName;
                 member.lastName = lastName;
@@ -77,6 +78,8 @@ class MemberService {
                 member.testMembership = testMembership;
                 member.picsInInternetAllowed = picsInInternetAllowed;
                 if (gender) member.gender = gender;
+                if (ttr !== undefined) member.ttr = ttr;
+                if (qttr !== undefined) member.qttr = qttr;
                 await member.save();
             } else {
                 await Member.create({
@@ -92,15 +95,17 @@ class MemberService {
                     testMembership: testMembership,
                     picsInInternetAllowed: picsInInternetAllowed,
                     gender: gender || 'unknown',
+                    ttr: ttr,
+                    qttr: qttr,
                 });
             }
-            console.log('[setClubMembers] - return response');
+            devLog('[setClubMembers] - return response');
             return {
                 status: 200,
                 response: { result: "success" },
             }
         } catch (error) {
-            console.log(error);
+            devLog(error);
             return {
                 status: error.statusCode || 500,
                 response: { error: "nocreation" }
@@ -110,7 +115,7 @@ class MemberService {
 
     async uploadMemberImage(userToken, clubId, memberId, imageBuffer) {
         try {
-            console.log('------>', userToken, clubId, memberId, imageBuffer);
+            devLog('------>', userToken, clubId, memberId, imageBuffer);
             await checkAccess(userToken, clubId);
             const member = await Member.findOne({ where: { id: memberId, clubId: clubId } });
             if (!member) {
@@ -146,6 +151,189 @@ class MemberService {
             return { status: 500, error: 'Failed to retrieve image' };
         }
     }
+
+    async updateRatingsFromMyTischtennis(userToken, clubId) {
+        devLog('[updateRatingsFromMyTischtennis] - Check access');
+        await checkAccess(userToken, clubId);
+        
+        const user = await getUserByToken(userToken);
+        devLog('[updateRatingsFromMyTischtennis] - User:', user.id);
+        
+        const externalServiceService = (await import('./externalServiceService.js')).default;
+        const myTischtennisClient = (await import('../clients/myTischtennisClient.js')).default;
+        
+        try {
+            // 1. myTischtennis-Session abrufen
+            devLog('[updateRatingsFromMyTischtennis] - Get session for user', user.id);
+            const session = await externalServiceService.getSession(user.id, 'mytischtennis');
+            devLog('[updateRatingsFromMyTischtennis] - Session retrieved:', {
+                hasAccessToken: !!session.accessToken,
+                hasCookie: !!session.cookie,
+                expiresAt: session.expiresAt
+            });
+            
+            const account = await externalServiceService.getAccount(user.id, 'mytischtennis');
+            devLog('[updateRatingsFromMyTischtennis] - Account data:', {
+                id: account?.id,
+                email: account?.email,
+                clubId: account?.clubId,
+                clubName: account?.clubName,
+                fedNickname: account?.fedNickname,
+                hasSession: !!(account?.accessToken)
+            });
+            
+            if (!account) {
+                console.error('[updateRatingsFromMyTischtennis] - No account found!');
+                return {
+                    status: 400,
+                    response: { 
+                        message: 'Kein myTischtennis-Account gefunden.',
+                        updated: 0,
+                        errors: [],
+                        debug: { userId: user.id }
+                    }
+                };
+            }
+            
+            if (!account.clubId || !account.fedNickname) {
+                console.error('[updateRatingsFromMyTischtennis] - Missing clubId or fedNickname:', {
+                    clubId: account.clubId,
+                    fedNickname: account.fedNickname
+                });
+                return {
+                    status: 400,
+                    response: { 
+                        message: 'Club-ID oder Verbandskürzel nicht verfügbar. Bitte einmal einloggen.',
+                        updated: 0,
+                        errors: [],
+                        debug: {
+                            hasClubId: !!account.clubId,
+                            hasFedNickname: !!account.fedNickname,
+                            clubId: account.clubId,
+                            fedNickname: account.fedNickname
+                        }
+                    }
+                };
+            }
+            
+            // 2. Rangliste vom Verein abrufen
+            devLog('[updateRatingsFromMyTischtennis] - Get club rankings', {
+                clubId: account.clubId,
+                fedNickname: account.fedNickname,
+                hasCookie: !!session.cookie
+            });
+            
+            const rankings = await myTischtennisClient.getClubRankings(
+                session.cookie,
+                account.clubId,
+                account.fedNickname
+            );
+            
+            devLog('[updateRatingsFromMyTischtennis] - Rankings result:', {
+                success: rankings.success,
+                entriesCount: rankings.entries?.length || 0,
+                error: rankings.error
+            });
+            
+            if (!rankings.success) {
+                return {
+                    status: 500,
+                    response: { 
+                        message: rankings.error || 'Fehler beim Abrufen der Rangliste',
+                        updated: 0,
+                        errors: [],
+                        debug: {
+                            clubId: account.clubId,
+                            fedNickname: account.fedNickname,
+                            rankingsError: rankings.error
+                        }
+                    }
+                };
+            }
+            
+            // 3. Alle Mitglieder des Clubs laden
+            devLog('[updateRatingsFromMyTischtennis] - Load club members for clubId:', clubId);
+            const members = await Member.findAll({ where: { clubId } });
+            devLog('[updateRatingsFromMyTischtennis] - Found members:', members.length);
+            
+            let updated = 0;
+            const errors = [];
+            const notFound = [];
+            const matched = [];
+            
+            // 4. Für jedes Mitglied TTR aktualisieren
+            for (const member of members) {
+                const firstName = member.firstName;
+                const lastName = member.lastName;
+                
+                // Suche nach Match in rankings entries
+                const rankingEntry = rankings.entries.find(entry => 
+                    entry.firstname.toLowerCase() === firstName.toLowerCase() &&
+                    entry.lastname.toLowerCase() === lastName.toLowerCase()
+                );
+                
+                if (rankingEntry) {
+                    try {
+                        // fedRank ist der TTR-Wert
+                        const oldTtr = member.ttr;
+                        member.ttr = rankingEntry.fedRank;
+                        // TODO: QTTR muss von einem anderen Endpoint geholt werden
+                        await member.save();
+                        updated++;
+                        matched.push({
+                            name: `${firstName} ${lastName}`,
+                            oldTtr: oldTtr,
+                            newTtr: rankingEntry.fedRank
+                        });
+                        devLog(`[updateRatingsFromMyTischtennis] - Updated ${firstName} ${lastName}: TTR ${oldTtr} → ${rankingEntry.fedRank}`);
+                    } catch (error) {
+                        console.error(`[updateRatingsFromMyTischtennis] - Error updating ${firstName} ${lastName}:`, error);
+                        errors.push({
+                            member: `${firstName} ${lastName}`,
+                            error: error.message
+                        });
+                    }
+                } else {
+                    notFound.push(`${firstName} ${lastName}`);
+                    devLog(`[updateRatingsFromMyTischtennis] - Not found in rankings: ${firstName} ${lastName}`);
+                }
+            }
+            
+            devLog('[updateRatingsFromMyTischtennis] - Update complete');
+            devLog(`Updated: ${updated}, Not found: ${notFound.length}, Errors: ${errors.length}`);
+            
+            let message = `${updated} Mitglied(er) aktualisiert.`;
+            if (notFound.length > 0) {
+                message += ` ${notFound.length} nicht in myTischtennis-Rangliste gefunden.`;
+            }
+            if (errors.length > 0) {
+                message += ` ${errors.length} Fehler beim Speichern.`;
+            }
+            
+            return {
+                status: 200,
+                response: { 
+                    message: message,
+                    updated: updated,
+                    matched: matched,
+                    notFound: notFound,
+                    errors: errors,
+                    totalEntries: rankings.entries.length,
+                    totalMembers: members.length
+                }
+            };
+        } catch (error) {
+            console.error('[updateRatingsFromMyTischtennis] - Error:', error);
+            return {
+                status: 500,
+                response: { 
+                    message: error.message || 'Fehler beim Aktualisieren',
+                    updated: 0,
+                    errors: [error.message]
+                }
+            };
+        }
+    }
 }
 
 export default new MemberService();

backend/services/predefinedActivityService.js

@@ -5,9 +5,10 @@ import PredefinedActivityImage from '../models/PredefinedActivityImage.js';
 import sequelize from '../database.js';
 import { Op } from 'sequelize';
 
+import { devLog } from '../utils/logger.js';
 class PredefinedActivityService {
     async createPredefinedActivity(data) {
-        console.log('[PredefinedActivityService::createPredefinedActivity] - Creating predefined activity');
+        devLog('[PredefinedActivityService::createPredefinedActivity] - Creating predefined activity');
         return await PredefinedActivity.create({
             name: data.name,
             code: data.code,
@@ -15,14 +16,15 @@ class PredefinedActivityService {
             durationText: data.durationText,
             duration: data.duration,
             imageLink: data.imageLink,
+            drawingData: data.drawingData ? JSON.stringify(data.drawingData) : null,
         });
     }
 
     async updatePredefinedActivity(id, data) {
-        console.log(`[PredefinedActivityService::updatePredefinedActivity] - Updating predefined activity with id: ${id}`);
+        devLog(`[PredefinedActivityService::updatePredefinedActivity] - Updating predefined activity with id: ${id}`);
         const activity = await PredefinedActivity.findByPk(id);
         if (!activity) {
-            console.log('[PredefinedActivityService::updatePredefinedActivity] - Activity not found');
+            devLog('[PredefinedActivityService::updatePredefinedActivity] - Activity not found');
             throw new Error('Predefined activity not found');
         }
         return await activity.update({
@@ -32,11 +34,12 @@ class PredefinedActivityService {
             durationText: data.durationText,
             duration: data.duration,
             imageLink: data.imageLink,
+            drawingData: data.drawingData ? JSON.stringify(data.drawingData) : null,
         });
     }
 
     async getAllPredefinedActivities() {
-        console.log('[PredefinedActivityService::getAllPredefinedActivities] - Fetching all predefined activities');
+        devLog('[PredefinedActivityService::getAllPredefinedActivities] - Fetching all predefined activities');
         return await PredefinedActivity.findAll({
             order: [
                 [sequelize.literal('code IS NULL'), 'ASC'], // Non-null codes first
@@ -47,10 +50,10 @@ class PredefinedActivityService {
     }
 
     async getPredefinedActivityById(id) {
-        console.log(`[PredefinedActivityService::getPredefinedActivityById] - Fetching predefined activity with id: ${id}`);
+        devLog(`[PredefinedActivityService::getPredefinedActivityById] - Fetching predefined activity with id: ${id}`);
         const activity = await PredefinedActivity.findByPk(id);
         if (!activity) {
-            console.log('[PredefinedActivityService::getPredefinedActivityById] - Activity not found');
+            devLog('[PredefinedActivityService::getPredefinedActivityById] - Activity not found');
             throw new Error('Predefined activity not found');
         }
         return activity;
@@ -78,7 +81,7 @@ class PredefinedActivityService {
     }
 
     async mergeActivities(sourceId, targetId) {
-        console.log(`[PredefinedActivityService::mergeActivities] - Merge ${sourceId} -> ${targetId}`);
+        devLog(`[PredefinedActivityService::mergeActivities] - Merge ${sourceId} -> ${targetId}`);
         if (!sourceId || !targetId) throw new Error('sourceId and targetId are required');
         if (Number(sourceId) === Number(targetId)) throw new Error('sourceId and targetId must differ');
 
@@ -118,7 +121,7 @@ class PredefinedActivityService {
     }
 
     async deduplicateActivities() {
-        console.log('[PredefinedActivityService::deduplicateActivities] - Start');
+        devLog('[PredefinedActivityService::deduplicateActivities] - Start');
         const all = await PredefinedActivity.findAll();
         const nameToActivities = new Map();
         for (const activity of all) {
@@ -140,7 +143,7 @@ class PredefinedActivityService {
                 mergedCount++;
             }
         }
-        console.log('[PredefinedActivityService::deduplicateActivities] - Done', { mergedCount, groupCount });
+        devLog('[PredefinedActivityService::deduplicateActivities] - Done', { mergedCount, groupCount });
         return { mergedCount, groupCount };
     }
 }

backend/services/tournamentService.js

@@ -9,6 +9,7 @@ import { checkAccess } from '../utils/userUtils.js';
 import { Op, literal } from 'sequelize';
 
 
+import { devLog } from '../utils/logger.js';
 function getRoundName(size) {
     switch (size) {
         case 2: return "Finale";
@@ -88,7 +89,7 @@ class TournamentService {
             include: [{
                 model: Member,
                 as: 'member',
-                attributes: ['id', 'firstName', 'lastName'],
+                attributes: ['id', 'firstName', 'lastName', 'ttr', 'qttr'],
             }],
             order: [[{ model: Member, as: 'member' }, 'firstName', 'ASC']]
         });
@@ -186,7 +187,7 @@ class TournamentService {
         
         if (alreadyAssigned.length > 0) {
             // Spieler sind bereits manuell zugeordnet - nicht neu verteilen
-            console.log(`${alreadyAssigned.length} Spieler bereits zugeordnet, ${unassigned.length} noch nicht zugeordnet`);
+            devLog(`${alreadyAssigned.length} Spieler bereits zugeordnet, ${unassigned.length} noch nicht zugeordnet`);
         } else {
             // Keine manuellen Zuordnungen - zufällig verteilen
             const shuffled = members.slice();
@@ -202,11 +203,11 @@ class TournamentService {
         }
 
         // 4) Round‑Robin anlegen wie gehabt - NUR innerhalb jeder Gruppe
-        console.log(`[fillGroups] Erstelle Matches für ${groups.length} Gruppen`);
+        devLog(`[fillGroups] Erstelle Matches für ${groups.length} Gruppen`);
         for (const g of groups) {
-            console.log(`[fillGroups] Verarbeite Gruppe ${g.id}`);
+            devLog(`[fillGroups] Verarbeite Gruppe ${g.id}`);
             const gm = await TournamentMember.findAll({ where: { groupId: g.id } });
-            console.log(`[fillGroups] Gruppe ${g.id} hat ${gm.length} Teilnehmer:`, gm.map(m => ({ id: m.id, name: m.member?.firstName + ' ' + m.member?.lastName })));
+            devLog(`[fillGroups] Gruppe ${g.id} hat ${gm.length} Teilnehmer:`, gm.map(m => ({ id: m.id, name: m.member?.firstName + ' ' + m.member?.lastName })));
             
             if (gm.length < 2) {
                 console.warn(`Gruppe ${g.id} hat nur ${gm.length} Teilnehmer - keine Matches erstellt`);
@@ -214,10 +215,10 @@ class TournamentService {
             }
             
             const rounds = this.generateRoundRobinSchedule(gm);
-            console.log(`[fillGroups] Gruppe ${g.id} hat ${rounds.length} Runden`);
+            devLog(`[fillGroups] Gruppe ${g.id} hat ${rounds.length} Runden`);
             
             for (let roundIndex = 0; roundIndex < rounds.length; roundIndex++) {
-                console.log(`[fillGroups] Runde ${roundIndex + 1} für Gruppe ${g.id}:`, rounds[roundIndex]);
+                devLog(`[fillGroups] Runde ${roundIndex + 1} für Gruppe ${g.id}:`, rounds[roundIndex]);
                 for (const [p1Id, p2Id] of rounds[roundIndex]) {
                     // Prüfe, ob beide Spieler zur gleichen Gruppe gehören
                     const p1 = gm.find(p => p.id === p1Id);
@@ -231,7 +232,7 @@ class TournamentService {
                             player2Id: p2Id,
                             groupRound: roundIndex + 1
                         });
-                        console.log(`[fillGroups] Match erstellt: ${match.id} - Spieler ${p1Id} vs ${p2Id} in Gruppe ${g.id}`);
+                        devLog(`[fillGroups] Match erstellt: ${match.id} - Spieler ${p1Id} vs ${p2Id} in Gruppe ${g.id}`);
                     } else {
                         console.warn(`Spieler gehören nicht zur gleichen Gruppe: ${p1Id} (${p1?.groupId}) vs ${p2Id} (${p2?.groupId}) in Gruppe ${g.id}`);
                     }

backend/utils/logger.js

@@ -0,0 +1,19 @@
+// Zentrale Logger-Utility für dev/prod Umgebungen
+const isDev = process.env.STAGE === 'dev';
+
+// Debug-Logs nur im dev-Modus
+export const devLog = (...args) => isDev && console.log(...args);
+
+// Fehler-Logs immer ausgeben
+export const errorLog = (...args) => console.error(...args);
+
+// Info-Logs immer ausgeben (für wichtige Produktions-Events)
+export const infoLog = (...args) => console.log(...args);
+
+export default {
+  devLog,
+  errorLog,
+  infoLog,
+  isDev
+};
+

backend/utils/userUtils.js

@@ -2,9 +2,10 @@ import jwt from 'jsonwebtoken';
 import { Op } from 'sequelize';
 import User from '../models/User.js';
 import UserToken from '../models/UserToken.js';
-import UserClub from '../models/UserClub.js';    // <-- hier hinzufügen
+import UserClub from '../models/UserClub.js';
 import HttpError from '../exceptions/HttpError.js';
 import { config } from 'dotenv';
+import { devLog } from './logger.js';
 config(); // sorgt dafür, dass process.env.JWT_SECRET geladen wird
 
 export const getUserByToken = async (token) => {
@@ -41,7 +42,7 @@ export const getUserByToken = async (token) => {
 
 export const hasUserClubAccess = async (userId, clubId) => {
     try {
-        console.log('[hasUserClubAccess]');
+        devLog('[hasUserClubAccess]');
         const userClub = await UserClub.findOne({
             where: {
                 user_id: userId,
@@ -51,10 +52,9 @@ export const hasUserClubAccess = async (userId, clubId) => {
         });
         return userClub !== null;
     } catch (error) {
-        console.log(error);
+        console.error('[hasUserClubAccess] - error:', error);
         throw new HttpError('notfound', 500);
     }
-    console.log('---- no user found');
 }
 
 export const checkAccess = async (userToken, clubId) => {
@@ -62,11 +62,11 @@ export const checkAccess = async (userToken, clubId) => {
         const user = await getUserByToken(userToken);
         const hasAccess = await hasUserClubAccess(user.id, clubId);
         if (!hasAccess) {
-            console.log('no club access');
+            devLog('[checkAccess] - no club access');
             throw new HttpError('noaccess', 403);
         }
     } catch (error) {
-        console.log(error);
+        devLog('[checkAccess] - error:', error);
         throw error;
     }
 };
@@ -76,7 +76,7 @@ export const checkGlobalAccess = async (userToken) => {
         const user = await getUserByToken(userToken);
         return user; // Einfach den User zurückgeben, da globale Zugriffe nur Authentifizierung benötigen
     } catch (error) {
-        console.log(error);
+        devLog('[checkGlobalAccess] - error:', error);
         throw error;
     }
 };

frontend/src/App.vue

@@ -67,6 +67,20 @@
               </a>
             </div>
           </nav>
+          
+          <nav class="sidebar-footer">
+            <div class="nav-section">
+              <h4 class="nav-title">Einstellungen</h4>
+              <a href="/mytischtennis-account" class="nav-link">
+                <span class="nav-icon">🔗</span>
+                myTischtennis-Account
+              </a>
+              <a href="/hettv-account" class="nav-link">
+                <span class="nav-icon">🔗</span>
+                HeTTV-Account
+              </a>
+            </div>
+          </nav>
 
           <div class="sidebar-footer">
             <button @click="logout()" class="btn-secondary logout-btn">
@@ -123,7 +137,7 @@ export default {
       if (newVal === 'new') {
         this.$router.push('/createclub');
       } else if (newVal) {
-        this.$router.push(`/showclub/${newVal}`);
+        this.$router.push('/training-stats');
       }
     },
     isAuthenticated(newVal) {
@@ -161,7 +175,7 @@ export default {
 
     loadClub() {
       this.setCurrentClub(this.currentClub);
-      this.$router.push(`/showclub/${this.currentClub}`);
+      this.$router.push('/training-stats');
     },
 
     async checkSession() {
@@ -331,6 +345,15 @@ export default {
   overflow-y: auto;
 }
 
+.nav-menu-no-flex {
+  display: flex;
+  flex-direction: column;
+  gap: 0.75rem;
+  flex: 0;
+  min-height: 0;
+  overflow-y: auto;
+}
+
 .nav-section {
   display: flex;
   flex-direction: column;

frontend/src/components/CourtDrawingRender.vue

@@ -0,0 +1,442 @@
+<template>
+  <div class="render-container">
+    <canvas
+      ref="canvas"
+      :width="config.canvas.width"
+      :height="config.canvas.height"
+      style="margin:0 auto;"
+    ></canvas>
+  </div>
+  
+</template>
+
+<script>
+export default {
+  name: 'CourtDrawingRender',
+  props: {
+    drawingData: {
+      type: Object,
+      required: true
+    },
+    width: {
+      type: Number,
+      default: 600
+    },
+    height: {
+      type: Number,
+      default: 400
+    }
+  },
+  data() {
+    return {
+      canvas: null,
+      ctx: null,
+      config: {
+        // Mehr Platz links für die drei Startkreise (Rand außerhalb des Tisches)
+        canvas: { width: 640, height: 400 },
+        table: {
+          // Tabelle etwas schmaler und weiter rechts platzieren
+          width: 500,
+          height: 300,
+          color: '#2d5a2d',
+          borderWidth: 2,
+          borderColor: '#000000',
+          outerFrameWidth: 5,
+          outerFrameColor: '#ffffff',
+          outerFrameBorderWidth: 0.5,
+          outerFrameBorderColor: '#000000'
+        },
+        horizontalLine: { color: '#cfd8dc', width: 2, gap: 10, edgeMargin: 10 },
+        net: { color: '#ffffff', width: 4, overhang: 14, borderColor: '#000000', borderWidth: 0.5 },
+        serviceLine: { color: 'rgba(255,255,255,0.0)', width: 0 },
+        startCircles: {
+          radius: 10,
+          // Abstand vom linken Canvas-Rand (größer = weiter links, da wir von tableX abziehen)
+          x: 20,
+          topYOffset: 35,
+          bottomYOffset: 35,
+          selectedColor: '#ff4444',
+          unselectedColor: '#9e9e9e',
+          selectedBorderColor: '#ffffff',
+          unselectedBorderColor: '#555555',
+          selectedBorderWidth: 2,
+          unselectedBorderWidth: 1
+        },
+        arrows: {
+          primaryColor: '#d32f2f', // rechts -> target (rot)
+          secondaryColor: '#1565c0', // zurück (blau)
+          width: 6,
+          headLength: 24,
+          vhOffsetX: 5,
+          vhOffsetY: 8,
+          rhOffsetX: 10,
+          rhOffsetY: 0
+        },
+        targetCircles: {
+          radius: 13,
+          rightXOffset: 20,
+          middleXOffset: 40,
+          topYOffset: 45,
+          bottomYOffset: 45,
+          transparency: 0.25
+        },
+        leftTargetCircles: {
+          radius: 10,
+          leftXOffset: 20,
+          rightXOffset: 40,
+          topYOffset: 40,
+          bottomYOffset: 40
+        },
+        hitMarker: {
+          radius: 10.5,
+          fill: '#ffffff',
+          stroke: '#000000',
+          lineWidth: 1
+        }
+      }
+    };
+  },
+  watch: {
+    drawingData: {
+      handler() {
+        this.redraw();
+      },
+      deep: true,
+      immediate: true
+    }
+  },
+  mounted() {
+    // apply custom dimensions if provided
+    this.config.canvas.width = this.width || 600;
+    this.config.canvas.height = this.height || 400;
+    this.$nextTick(() => {
+      console.log('CourtDrawingRender: mounted with drawingData =', this.drawingData);
+      this.init();
+      this.redraw();
+    });
+  },
+  methods: {
+    init() {
+      this.canvas = this.$refs.canvas;
+      if (this.canvas) {
+        this.ctx = this.canvas.getContext('2d');
+        console.log('CourtDrawingRender: canvas/context initialized');
+      }
+    },
+    redraw() {
+      console.log('CourtDrawingRender: redraw called with data =', this.drawingData);
+      if (!this.ctx) return;
+      const { width, height } = this.config.canvas;
+      // clear and background
+      this.ctx.clearRect(0, 0, width, height);
+      this.ctx.fillStyle = '#f0f0f0';
+      this.ctx.fillRect(0, 0, width, height);
+      this.drawTable();
+      this.drawStartCircles();
+      this.drawArrowsAndLabels();
+    },
+    drawTable() {
+      const ctx = this.ctx;
+      const { table, horizontalLine, net, outerFrameWidth } = {
+        ...this.config,
+        outerFrameWidth: this.config.table.outerFrameWidth
+      };
+      const tableWidth = this.config.table.width;
+      const tableHeight = this.config.table.height;
+      const tableX = (this.config.canvas.width - tableWidth) / 2;
+      const tableY = (this.config.canvas.height - tableHeight) / 2;
+
+      // table fill
+      ctx.fillStyle = table.color;
+      ctx.fillRect(tableX, tableY, tableWidth, tableHeight);
+
+      // table stroke
+      ctx.strokeStyle = table.borderColor;
+      ctx.lineWidth = table.borderWidth;
+      ctx.strokeRect(tableX, tableY, tableWidth, tableHeight);
+
+      // outer white frame
+      ctx.strokeStyle = table.outerFrameColor;
+      ctx.lineWidth = table.outerFrameWidth;
+      ctx.strokeRect(
+        tableX - table.outerFrameWidth,
+        tableY - table.outerFrameWidth,
+        tableWidth + table.outerFrameWidth * 2,
+        tableHeight + table.outerFrameWidth * 2
+      );
+
+      // black thin frame around white
+      ctx.strokeStyle = table.outerFrameBorderColor;
+      ctx.lineWidth = table.outerFrameBorderWidth;
+      ctx.strokeRect(
+        tableX - table.outerFrameWidth - table.outerFrameBorderWidth,
+        tableY - table.outerFrameWidth - table.outerFrameBorderWidth,
+        tableWidth + (table.outerFrameWidth + table.outerFrameBorderWidth) * 2,
+        tableHeight + (table.outerFrameWidth + table.outerFrameBorderWidth) * 2
+      );
+
+      // horizontal split line (two segments)
+      ctx.strokeStyle = horizontalLine.color;
+      ctx.lineWidth = horizontalLine.width;
+      const centerY = tableY + tableHeight / 2;
+      const centerX = tableX + tableWidth / 2;
+      const gap = horizontalLine.gap;
+      const edge = horizontalLine.edgeMargin;
+      ctx.beginPath();
+      ctx.moveTo(tableX + edge, centerY);
+      ctx.lineTo(centerX - gap, centerY);
+      ctx.stroke();
+      ctx.beginPath();
+      ctx.moveTo(centerX + gap, centerY);
+      ctx.lineTo(tableX + tableWidth - edge, centerY);
+      ctx.stroke();
+
+      // net vertical
+      ctx.strokeStyle = net.color;
+      ctx.lineWidth = net.width;
+      ctx.beginPath();
+      ctx.moveTo(centerX, tableY - net.overhang);
+      ctx.lineTo(centerX, tableY + tableHeight + net.overhang);
+      ctx.stroke();
+
+      ctx.strokeStyle = net.borderColor;
+      ctx.lineWidth = net.borderWidth;
+      ctx.beginPath();
+      ctx.moveTo(centerX, tableY - net.overhang);
+      ctx.lineTo(centerX, tableY + tableHeight + net.overhang);
+      ctx.stroke();
+    },
+    drawStartCircles() {
+      const ctx = this.ctx;
+      const cfg = this.config.startCircles;
+      const tableWidth = this.config.table.width;
+      const tableHeight = this.config.table.height;
+      const tableX = (this.config.canvas.width - tableWidth) / 2;
+      const tableY = (this.config.canvas.height - tableHeight) / 2;
+
+      // Startkreis links VOR dem Tisch positionieren – nur den Kreis zeichnen,
+      // von dem auch der rote Pfeil startet
+      const circleX = tableX - cfg.x; // Links vom Tisch
+      const topY = tableY + cfg.topYOffset;
+      const midY = tableY + tableHeight / 2;
+      const botY = tableY + tableHeight - cfg.bottomYOffset;
+
+      // Mapping und Fallback: bei "AS" auf 'middle'
+      const map = { AS1: 'top', AS2: 'middle', AS3: 'bottom', AS: 'middle' };
+      const selKey = this.drawingData?.selectedStartPosition || 'AS';
+      const selectedPos = map[selKey] || 'middle';
+      const y = selectedPos === 'top' ? topY : selectedPos === 'bottom' ? botY : midY;
+
+      ctx.fillStyle = cfg.selectedColor;
+      ctx.beginPath();
+      ctx.arc(circleX, y, cfg.radius, 0, Math.PI * 2);
+      ctx.fill();
+      ctx.strokeStyle = cfg.selectedBorderColor;
+      ctx.lineWidth = cfg.selectedBorderWidth;
+      ctx.stroke();
+    },
+    computeRightTargetPosition(number) {
+      // Geometrie wie im Tool: nutzt rightXOffset/middleXOffset
+      const tableWidth = this.config.table.width;
+      const tableHeight = this.config.table.height;
+      const tableX = (this.config.canvas.width - tableWidth) / 2;
+      const tableY = (this.config.canvas.height - tableHeight) / 2;
+      const cfg = this.config.targetCircles;
+
+      const x1 = tableX + tableWidth - cfg.rightXOffset; // (1,2,3)
+      const x3 = tableX + tableWidth / 2 + cfg.middleXOffset; // (7,8,9)
+      const xdiff = x3 - x1;
+      const x2 = x3 - xdiff / 2; // (4,5,6)
+
+      const positions = {
+        1: { x: x1, y: tableY + cfg.topYOffset },
+        2: { x: x1, y: tableY + tableHeight / 2 },
+        3: { x: x1, y: tableY + tableHeight - cfg.bottomYOffset },
+        4: { x: x2, y: tableY + cfg.topYOffset },
+        5: { x: x2, y: tableY + tableHeight / 2 },
+        6: { x: x2, y: tableY + tableHeight - cfg.bottomYOffset },
+        7: { x: x3, y: tableY + cfg.topYOffset },
+        8: { x: x3, y: tableY + tableHeight / 2 },
+        9: { x: x3, y: tableY + tableHeight - cfg.bottomYOffset }
+      };
+      return positions[number] || null;
+    },
+    getStartPoint() {
+      // Startpunkt wie im Tool abhängig von Schlagseite (VH/RH)
+      const sc = this.config.startCircles;
+      const ar = this.config.arrows;
+      const tblW = this.config.table.width;
+      const tblH = this.config.table.height;
+      const tableX = (this.config.canvas.width - tblW) / 2;
+      const tableY = (this.config.canvas.height - tblH) / 2;
+      const circleX = tableX - sc.x; // Kreis links vor dem Tisch
+      const map = { AS1: 'top', AS2: 'middle', AS3: 'bottom', AS: 'middle' };
+      const pos = map[this.drawingData?.selectedStartPosition] || 'middle';
+      const y = pos === 'top' ? tableY + sc.topYOffset : pos === 'bottom' ? tableY + tblH - sc.bottomYOffset : tableY + tblH / 2;
+      const isVH = (this.drawingData?.strokeType || 'VH') === 'VH';
+      const startX = isVH
+        ? circleX + sc.radius + ar.vhOffsetX
+        : circleX + sc.radius + ar.rhOffsetX;
+      // VH: unterhalb seitlich (circleRadius + vhOffsetY), RH: rechts (rhOffsetY = 0)
+      const startYOffset = isVH ? (sc.radius + ar.vhOffsetY) : ar.rhOffsetY;
+      return { x: startX, y: y + startYOffset };
+    },
+    drawArrow(ctx, from, to, color, label) {
+      const { width, headLength } = this.config.arrows;
+      ctx.strokeStyle = color;
+      ctx.fillStyle = color;
+      ctx.lineWidth = width;
+      // line
+      ctx.beginPath();
+      ctx.moveTo(from.x, from.y);
+      ctx.lineTo(to.x, to.y);
+      ctx.stroke();
+      // arrow head
+      const angle = Math.atan2(to.y - from.y, to.x - from.x);
+      ctx.beginPath();
+      ctx.moveTo(to.x, to.y);
+      ctx.lineTo(to.x - headLength * Math.cos(angle - Math.PI / 6), to.y - headLength * Math.sin(angle - Math.PI / 6));
+      ctx.lineTo(to.x - headLength * Math.cos(angle + Math.PI / 6), to.y - headLength * Math.sin(angle + Math.PI / 6));
+      ctx.closePath();
+      ctx.fill();
+    },
+    drawLabelBelow(ctx, text, anchor) {
+      if (!text) return;
+      ctx.font = 'bold 13px Helvetica';
+      const padding = 6;
+      const yOffset = 23; // 5px tiefer
+      const metrics = ctx.measureText(text);
+      const textWidth = metrics.width;
+      let x = anchor.x - textWidth / 2; // zentriert unter dem Punkt
+      let y = anchor.y + yOffset;
+      // clamp innerhalb Canvas
+      x = Math.max(4, Math.min(this.config.canvas.width - textWidth - 4, x));
+      y = Math.max(14, Math.min(this.config.canvas.height - 4, y));
+      ctx.fillStyle = '#ffffff';
+      ctx.strokeStyle = '#000000';
+      ctx.lineWidth = 2;
+      ctx.strokeText(text, x, y);
+      ctx.fillText(text, x, y);
+    },
+    drawArrowsAndLabels() {
+      if (!this.drawingData) return;
+      const ctx = this.ctx;
+      const from = this.getStartPoint();
+
+      // First arrow: to right target
+      const tp = Number(this.drawingData.targetPosition);
+      if (tp) {
+        const to = this.computeRightTargetPosition(tp);
+        // Zielmarkierung (unter dem Pfeilkopf)
+        this.drawHitMarker(ctx, to);
+        const strokeSide = this.drawingData.strokeType || '';
+        const spinAbbrev = this.abbrevSpin(this.drawingData.spinType);
+        // Text gehört an die Quelle (ohne "target")
+        const sourceLabel = `${strokeSide} ${spinAbbrev}`.trim();
+        const toEnd = { x: to.x - this.config.targetCircles.radius, y: to.y };
+        this.drawArrow(ctx, from, toEnd, this.config.arrows.primaryColor);
+        // Unter dem Startkreis beschriften
+        const startCenter = this.getStartCircleCenter();
+        this.drawLabelBelow(ctx, sourceLabel, startCenter);
+      }
+
+      // Second arrow (optional): from right source to left target
+      const leftTarget = this.drawingData.nextStrokeTargetPosition ? Number(this.drawingData.nextStrokeTargetPosition) : null;
+      if (tp && leftTarget) {
+        // source near previous right target
+        const sourceRightCenter = this.computeRightTargetPosition(tp);
+        // left target mapping: mirror scheme to left half
+        const toLeftCenter = this.computeLeftTargetPosition(leftTarget);
+        // Zielmarkierung links
+        this.drawHitMarker(ctx, toLeftCenter);
+        const side = this.drawingData.nextStrokeSide || '';
+        const type = this.drawingData.nextStrokeType || '';
+        // Text gehört ans Ziel (ohne "extra target")
+        const targetLabel = `${side} ${type}`.trim();
+        const sourceRight = { x: sourceRightCenter.x - this.config.targetCircles.radius, y: sourceRightCenter.y };
+        const toLeft = { x: toLeftCenter.x + this.config.leftTargetCircles.radius, y: toLeftCenter.y };
+        this.drawArrow(ctx, sourceRight, toLeft, this.config.arrows.secondaryColor);
+        // Unter dem rechten Ziel (target der ersten Linie) beschriften
+        this.drawLabelBelow(ctx, targetLabel, sourceRightCenter);
+      }
+    },
+    getStartCircleCenter() {
+      const cfg = this.config.startCircles;
+      const tableWidth = this.config.table.width;
+      const tableHeight = this.config.table.height;
+      const tableX = (this.config.canvas.width - tableWidth) / 2;
+      const tableY = (this.config.canvas.height - tableHeight) / 2;
+      const circleX = tableX - cfg.x;
+      const map = { AS1: 'top', AS2: 'middle', AS3: 'bottom', AS: 'middle' };
+      const selKey = this.drawingData?.selectedStartPosition || 'AS';
+      const selectedPos = map[selKey] || 'middle';
+      const topY = tableY + cfg.topYOffset;
+      const midY = tableY + tableHeight / 2;
+      const botY = tableY + tableHeight - cfg.bottomYOffset;
+      const y = selectedPos === 'top' ? topY : selectedPos === 'bottom' ? botY : midY;
+      return { x: circleX, y };
+    },
+    drawHitMarker(ctx, pos) {
+      if (!pos) return;
+      const mk = this.config.hitMarker;
+      ctx.beginPath();
+      ctx.arc(pos.x, pos.y, mk.radius, 0, Math.PI * 2);
+      ctx.fillStyle = mk.fill;
+      ctx.fill();
+      ctx.lineWidth = mk.lineWidth;
+      ctx.strokeStyle = mk.stroke;
+      ctx.stroke();
+    },
+    computeLeftTargetPosition(number) {
+      // Spiegelung wie im Tool: nutzt leftTargetCircles Offsets
+      const tableWidth = this.config.table.width;
+      const tableHeight = this.config.table.height;
+      const tableX = (this.config.canvas.width - tableWidth) / 2;
+      const tableY = (this.config.canvas.height - tableHeight) / 2;
+      const cfg = this.config.leftTargetCircles;
+
+      const x1 = tableX + cfg.leftXOffset; // linke Spalte (Lang)
+      const x3 = tableX + tableWidth / 2 - cfg.rightXOffset; // nah am Netz (Kurz)
+      const xdiff = x3 - x1;
+      const x2 = x3 - xdiff / 2;
+
+      // Gespiegelte Y-Zuordnung wie im Tool:
+      // 1,4,7 = unten (VH gespiegelt)
+      // 2,5,8 = mitte
+      // 3,6,9 = oben (RH gespiegelt)
+      const positions = {
+        1: { x: x1, y: tableY + tableHeight - cfg.bottomYOffset },
+        2: { x: x1, y: tableY + tableHeight / 2 },
+        3: { x: x1, y: tableY + cfg.topYOffset },
+        4: { x: x2, y: tableY + tableHeight - cfg.bottomYOffset },
+        5: { x: x2, y: tableY + tableHeight / 2 },
+        6: { x: x2, y: tableY + cfg.topYOffset },
+        7: { x: x3, y: tableY + tableHeight - cfg.bottomYOffset },
+        8: { x: x3, y: tableY + tableHeight / 2 },
+        9: { x: x3, y: tableY + cfg.topYOffset }
+      };
+      return positions[number] || null;
+    },
+    abbrevSpin(spin) {
+      if (!spin) return '';
+      const map = {
+        Unterschnitt: 'US',
+        Überschnitt: 'OS',
+        Seitschnitt: 'SR',
+        Seitunterschnitt: 'SU',
+        Gegenläufer: 'GL'
+      };
+      return map[spin] || spin;
+    }
+  }
+};
+</script>
+
+<style scoped>
+.render-container {
+  width: 100%;
+}
+canvas { display: block; max-width: 100%; height: auto; }
+</style>
+
+

frontend/src/components/HettvDialog.vue

@@ -0,0 +1,291 @@
+<template>
+  <div class="modal-overlay" @click.self="$emit('close')">
+    <div class="modal">
+      <div class="modal-header">
+        <h3>{{ account ? 'HeTTV-Account bearbeiten' : 'HeTTV-Account verknüpfen' }}</h3>
+      </div>
+      
+      <div class="modal-body">
+        <div class="form-group">
+          <label for="hettv-email">HeTTV-E-Mail:</label>
+          <input
+            type="email"
+            id="hettv-email"
+            v-model="formData.email"
+            placeholder="Ihre HeTTV-E-Mail-Adresse"
+            required
+          />
+        </div>
+        
+        <div class="form-group">
+          <label for="hettv-password">HeTTV-Passwort:</label>
+          <input
+            type="password"
+            id="hettv-password"
+            v-model="formData.password"
+            :placeholder="account && account.savePassword ? 'Leer lassen um beizubehalten' : 'Ihr HeTTV-Passwort'"
+          />
+        </div>
+        
+        <div class="form-group checkbox-group">
+          <label>
+            <input
+              type="checkbox"
+              v-model="formData.savePassword"
+            />
+            <span>HeTTV-Passwort speichern</span>
+          </label>
+          <p class="hint">
+            Wenn aktiviert, wird Ihr HeTTV-Passwort verschlüsselt gespeichert, 
+            sodass automatische Synchronisationen möglich sind.
+          </p>
+        </div>
+        
+        <div class="form-group" v-if="formData.password">
+          <label for="app-password">Ihr App-Passwort zur Bestätigung:</label>
+          <input
+            type="password"
+            id="app-password"
+            v-model="formData.userPassword"
+            placeholder="Ihr Passwort für diese App"
+            required
+          />
+          <p class="hint">
+            Aus Sicherheitsgründen benötigen wir Ihr App-Passwort, 
+            um das HeTTV-Passwort zu speichern.
+          </p>
+        </div>
+        
+        <div v-if="error" class="error-message">
+          {{ error }}
+        </div>
+      </div>
+      
+      <div class="modal-footer">
+        <button class="btn-secondary" @click="$emit('close')" :disabled="saving">
+          Abbrechen
+        </button>
+        <button class="btn-primary" @click="saveAccount" :disabled="!canSave || saving">
+          {{ saving ? 'Speichere...' : 'Speichern' }}
+        </button>
+      </div>
+    </div>
+  </div>
+</template>
+
+<script>
+import apiClient from '../apiClient.js';
+
+export default {
+  name: 'HettvDialog',
+  props: {
+    account: {
+      type: Object,
+      default: null
+    }
+  },
+  data() {
+    return {
+      formData: {
+        email: this.account?.email || '',
+        password: '',
+        savePassword: this.account?.savePassword || false,
+        userPassword: ''
+      },
+      saving: false,
+      error: null
+    };
+  },
+  computed: {
+    canSave() {
+      if (!this.formData.email.trim()) {
+        return false;
+      }
+      
+      if (this.formData.password && !this.formData.userPassword) {
+        return false;
+      }
+      
+      return true;
+    }
+  },
+  methods: {
+    async saveAccount() {
+      if (!this.canSave) return;
+      
+      this.error = null;
+      this.saving = true;
+      
+      try {
+        const payload = {
+          email: this.formData.email,
+          savePassword: this.formData.savePassword,
+          service: 'hettv'
+        };
+        
+        if (this.formData.password) {
+          payload.password = this.formData.password;
+          payload.userPassword = this.formData.userPassword;
+        }
+        
+        await apiClient.post('/external-service/account', payload);
+        this.$emit('saved');
+      } catch (error) {
+        console.error('Fehler beim Speichern:', error);
+        this.error = error.response?.data?.message || 'Fehler beim Speichern des Accounts';
+      } finally {
+        this.saving = false;
+      }
+    }
+  }
+};
+</script>
+
+<style scoped>
+.modal-overlay {
+  position: fixed;
+  top: 0;
+  left: 0;
+  right: 0;
+  bottom: 0;
+  background-color: rgba(0, 0, 0, 0.5);
+  display: flex;
+  justify-content: center;
+  align-items: center;
+  z-index: 1000;
+}
+
+.modal {
+  background: white;
+  border-radius: 8px;
+  box-shadow: 0 4px 20px rgba(0, 0, 0, 0.3);
+  max-width: 600px;
+  width: 90%;
+  max-height: 90vh;
+  overflow-y: auto;
+  display: flex;
+  flex-direction: column;
+}
+
+.modal-header {
+  padding: 1.5rem;
+  border-bottom: 1px solid #dee2e6;
+}
+
+.modal-header h3 {
+  margin: 0;
+  color: #495057;
+}
+
+.modal-body {
+  padding: 1.5rem;
+  flex: 1;
+}
+
+.modal-footer {
+  padding: 1rem 1.5rem;
+  border-top: 1px solid #dee2e6;
+  display: flex;
+  justify-content: flex-end;
+  gap: 1rem;
+}
+
+.form-group {
+  margin-bottom: 1.5rem;
+}
+
+.form-group label {
+  display: block;
+  margin-bottom: 0.5rem;
+  font-weight: 600;
+  color: #495057;
+}
+
+.form-group input[type="text"],
+.form-group input[type="email"],
+.form-group input[type="password"] {
+  width: 100%;
+  padding: 0.75rem;
+  border: 1px solid #ced4da;
+  border-radius: 4px;
+  font-size: 1rem;
+  box-sizing: border-box;
+}
+
+.form-group input[type="text"]:focus,
+.form-group input[type="email"]:focus,
+.form-group input[type="password"]:focus {
+  outline: none;
+  border-color: #007bff;
+  box-shadow: 0 0 0 0.2rem rgba(0, 123, 255, 0.25);
+}
+
+.checkbox-group label {
+  display: flex;
+  align-items: center;
+  gap: 0.5rem;
+  font-weight: normal;
+  cursor: pointer;
+}
+
+.checkbox-group input[type="checkbox"] {
+  width: auto;
+  margin: 0;
+  cursor: pointer;
+}
+
+.hint {
+  margin-top: 0.5rem;
+  font-size: 0.875rem;
+  color: #6c757d;
+  font-style: italic;
+}
+
+.error-message {
+  padding: 0.75rem;
+  background-color: #f8d7da;
+  border: 1px solid #f5c6cb;
+  border-radius: 4px;
+  color: #721c24;
+  margin-top: 1rem;
+}
+
+.btn-primary, .btn-secondary {
+  padding: 0.75rem 1.5rem;
+  border: none;
+  border-radius: 4px;
+  font-size: 1rem;
+  cursor: pointer;
+  transition: background-color 0.2s ease;
+}
+
+.btn-primary {
+  background-color: #007bff;
+  color: white;
+}
+
+.btn-primary:hover:not(:disabled) {
+  background-color: #0056b3;
+}
+
+.btn-primary:disabled {
+  background-color: #6c757d;
+  cursor: not-allowed;
+  opacity: 0.6;
+}
+
+.btn-secondary {
+  background-color: #6c757d;
+  color: white;
+}
+
+.btn-secondary:hover:not(:disabled) {
+  background-color: #545b62;
+}
+
+.btn-secondary:disabled {
+  cursor: not-allowed;
+  opacity: 0.6;
+}
+</style>
+

frontend/src/components/MyTischtennisDialog.vue

@@ -0,0 +1,294 @@
+<template>
+  <div class="modal-overlay" @click.self="$emit('close')">
+    <div class="modal">
+      <div class="modal-header">
+        <h3>{{ account ? 'myTischtennis-Account bearbeiten' : 'myTischtennis-Account verknüpfen' }}</h3>
+      </div>
+      
+      <div class="modal-body">
+        <div class="form-group">
+          <label for="mtt-email">myTischtennis-E-Mail:</label>
+          <input
+            type="email"
+            id="mtt-email"
+            v-model="formData.email"
+            placeholder="Ihre myTischtennis-E-Mail-Adresse"
+            required
+          />
+        </div>
+        
+        <div class="form-group">
+          <label for="mtt-password">myTischtennis-Passwort:</label>
+          <input
+            type="password"
+            id="mtt-password"
+            v-model="formData.password"
+            :placeholder="account && account.savePassword ? 'Leer lassen um beizubehalten' : 'Ihr myTischtennis-Passwort'"
+          />
+        </div>
+        
+        <div class="form-group checkbox-group">
+          <label>
+            <input
+              type="checkbox"
+              v-model="formData.savePassword"
+            />
+            <span>myTischtennis-Passwort speichern</span>
+          </label>
+          <p class="hint">
+            Wenn aktiviert, wird Ihr myTischtennis-Passwort verschlüsselt gespeichert, 
+            sodass automatische Synchronisationen möglich sind.
+          </p>
+        </div>
+        
+        <div class="form-group" v-if="formData.password">
+          <label for="app-password">Ihr App-Passwort zur Bestätigung:</label>
+          <input
+            type="password"
+            id="app-password"
+            v-model="formData.userPassword"
+            placeholder="Ihr Passwort für diese App"
+            required
+          />
+          <p class="hint">
+            Aus Sicherheitsgründen benötigen wir Ihr App-Passwort, 
+            um das myTischtennis-Passwort zu speichern.
+          </p>
+        </div>
+        
+        <div v-if="error" class="error-message">
+          {{ error }}
+        </div>
+      </div>
+      
+      <div class="modal-footer">
+        <button class="btn-secondary" @click="$emit('close')" :disabled="saving">
+          Abbrechen
+        </button>
+        <button class="btn-primary" @click="saveAccount" :disabled="!canSave || saving">
+          {{ saving ? 'Speichere...' : 'Speichern' }}
+        </button>
+      </div>
+    </div>
+  </div>
+</template>
+
+<script>
+import apiClient from '../apiClient.js';
+
+export default {
+  name: 'MyTischtennisDialog',
+  props: {
+    account: {
+      type: Object,
+      default: null
+    }
+  },
+  data() {
+    return {
+      formData: {
+        email: this.account?.email || '',
+        password: '',
+        savePassword: this.account?.savePassword || false,
+        userPassword: ''
+      },
+      saving: false,
+      error: null
+    };
+  },
+  computed: {
+    canSave() {
+      // E-Mail ist erforderlich
+      if (!this.formData.email.trim()) {
+        return false;
+      }
+      
+      // Wenn ein Passwort eingegeben wurde, muss auch das App-Passwort eingegeben werden
+      if (this.formData.password && !this.formData.userPassword) {
+        return false;
+      }
+      
+      return true;
+    }
+  },
+  methods: {
+    async saveAccount() {
+      if (!this.canSave) return;
+      
+      this.error = null;
+      this.saving = true;
+      
+      try {
+        const payload = {
+          email: this.formData.email,
+          savePassword: this.formData.savePassword,
+          service: 'mytischtennis'
+        };
+        
+        // Nur password und userPassword hinzufügen, wenn ein Passwort eingegeben wurde
+        if (this.formData.password) {
+          payload.password = this.formData.password;
+          payload.userPassword = this.formData.userPassword;
+        }
+        
+        await apiClient.post('/external-service/account', payload);
+        this.$emit('saved');
+      } catch (error) {
+        console.error('Fehler beim Speichern:', error);
+        this.error = error.response?.data?.message || 'Fehler beim Speichern des Accounts';
+      } finally {
+        this.saving = false;
+      }
+    }
+  }
+};
+</script>
+
+<style scoped>
+.modal-overlay {
+  position: fixed;
+  top: 0;
+  left: 0;
+  right: 0;
+  bottom: 0;
+  background-color: rgba(0, 0, 0, 0.5);
+  display: flex;
+  justify-content: center;
+  align-items: center;
+  z-index: 1000;
+}
+
+.modal {
+  background: white;
+  border-radius: 8px;
+  box-shadow: 0 4px 20px rgba(0, 0, 0, 0.3);
+  max-width: 600px;
+  width: 90%;
+  max-height: 90vh;
+  overflow-y: auto;
+  display: flex;
+  flex-direction: column;
+}
+
+.modal-header {
+  padding: 1.5rem;
+  border-bottom: 1px solid #dee2e6;
+}
+
+.modal-header h3 {
+  margin: 0;
+  color: #495057;
+}
+
+.modal-body {
+  padding: 1.5rem;
+  flex: 1;
+}
+
+.modal-footer {
+  padding: 1rem 1.5rem;
+  border-top: 1px solid #dee2e6;
+  display: flex;
+  justify-content: flex-end;
+  gap: 1rem;
+}
+
+.form-group {
+  margin-bottom: 1.5rem;
+}
+
+.form-group label {
+  display: block;
+  margin-bottom: 0.5rem;
+  font-weight: 600;
+  color: #495057;
+}
+
+.form-group input[type="text"],
+.form-group input[type="email"],
+.form-group input[type="password"] {
+  width: 100%;
+  padding: 0.75rem;
+  border: 1px solid #ced4da;
+  border-radius: 4px;
+  font-size: 1rem;
+  box-sizing: border-box;
+}
+
+.form-group input[type="text"]:focus,
+.form-group input[type="email"]:focus,
+.form-group input[type="password"]:focus {
+  outline: none;
+  border-color: #007bff;
+  box-shadow: 0 0 0 0.2rem rgba(0, 123, 255, 0.25);
+}
+
+.checkbox-group label {
+  display: flex;
+  align-items: center;
+  gap: 0.5rem;
+  font-weight: normal;
+  cursor: pointer;
+}
+
+.checkbox-group input[type="checkbox"] {
+  width: auto;
+  margin: 0;
+  cursor: pointer;
+}
+
+.hint {
+  margin-top: 0.5rem;
+  font-size: 0.875rem;
+  color: #6c757d;
+  font-style: italic;
+}
+
+.error-message {
+  padding: 0.75rem;
+  background-color: #f8d7da;
+  border: 1px solid #f5c6cb;
+  border-radius: 4px;
+  color: #721c24;
+  margin-top: 1rem;
+}
+
+.btn-primary, .btn-secondary {
+  padding: 0.75rem 1.5rem;
+  border: none;
+  border-radius: 4px;
+  font-size: 1rem;
+  cursor: pointer;
+  transition: background-color 0.2s ease;
+}
+
+.btn-primary {
+  background-color: #007bff;
+  color: white;
+}
+
+.btn-primary:hover:not(:disabled) {
+  background-color: #0056b3;
+}
+
+.btn-primary:disabled {
+  background-color: #6c757d;
+  cursor: not-allowed;
+  opacity: 0.6;
+}
+
+.btn-secondary {
+  background-color: #6c757d;
+  color: white;
+}
+
+.btn-secondary:hover:not(:disabled) {
+  background-color: #545b62;
+}
+
+.btn-secondary:disabled {
+  cursor: not-allowed;
+  opacity: 0.6;
+}
+</style>
+

frontend/src/router.js

@@ -13,6 +13,8 @@ import TournamentsView from './views/TournamentsView.vue';
 import TrainingStatsView from './views/TrainingStatsView.vue';
 import PredefinedActivities from './views/PredefinedActivities.vue';
 import OfficialTournaments from './views/OfficialTournaments.vue';
+import MyTischtennisAccount from './views/MyTischtennisAccount.vue';
+import HettvAccount from './views/HettvAccount.vue';
 import Impressum from './views/Impressum.vue';
 import Datenschutz from './views/Datenschutz.vue';
 
@@ -31,6 +33,8 @@ const routes = [
   { path: '/training-stats', component: TrainingStatsView },
   { path: '/predefined-activities', component: PredefinedActivities },
   { path: '/official-tournaments', component: OfficialTournaments },
+  { path: '/mytischtennis-account', component: MyTischtennisAccount },
+  { path: '/hettv-account', component: HettvAccount },
   { path: '/impressum', component: Impressum },
   { path: '/datenschutz', component: Datenschutz },
 ];

frontend/src/views/DiaryView.vue

@@ -126,10 +126,11 @@
                                             </span>
                                             <span v-else @click="startActivityEdit(item)" class="clickable activity-label"
                                                  :title="item.predefinedActivity && item.predefinedActivity.name ? item.predefinedActivity.name : ''">
-                                                <span v-if="item.predefinedActivity && item.predefinedActivity.imageLink" 
-                                                      @click.stop="showActivityImage(item.predefinedActivity.imageLink)"
-                                                      class="image-icon" 
-                                                      title="Bild anzeigen">🖼️</span>
+            <!-- Icon öffnet Rendering (falls vorhanden) oder Bild im Modal -->
+            <span v-if="item.predefinedActivity"
+                  @click.stop="openActivityVisual(item.predefinedActivity)"
+                  class="image-icon"
+                  title="Bild/Zeichnung anzeigen">🖼️</span>
                                                 {{ (item.predefinedActivity && item.predefinedActivity.code && item.predefinedActivity.code.trim() !== '')
                                                     ? item.predefinedActivity.code
                                                     : (item.predefinedActivity ? item.predefinedActivity.name : item.activity) }}
@@ -161,10 +162,12 @@
                                             <td></td>
                                             <td>
                                                 <span class="activity-label" :title="(groupItem.groupPredefinedActivity && groupItem.groupPredefinedActivity.name) ? groupItem.groupPredefinedActivity.name : ''">
-                                                    <span v-if="groupItem.groupPredefinedActivity && groupItem.groupPredefinedActivity.imageLink" 
-                                                          @click.stop="showActivityImage(groupItem.groupPredefinedActivity.imageLink)"
-                                                          class="image-icon" 
-                                                          title="Bild anzeigen">🖼️</span>
+                <!-- Icon öffnet Rendering (falls vorhanden) oder Bild im Modal -->
+                <span v-if="groupItem.groupPredefinedActivity"
+                      @click.stop="openActivityVisual(groupItem.groupPredefinedActivity)"
+                      class="image-icon"
+                      title="Bild/Zeichnung anzeigen">🖼️</span>
+                
                                                     {{ (groupItem.groupPredefinedActivity && groupItem.groupPredefinedActivity.code && groupItem.groupPredefinedActivity.code.trim() !== '')
                                                         ? groupItem.groupPredefinedActivity.code
                                                         : groupItem.groupPredefinedActivity.name }}
@@ -319,8 +322,13 @@
                 </div>
             </div>
         </div>
-        <div v-if="showImage" class="memberImage">
-            <img :src="imageUrl" @click="closeImage" />
+        <div v-if="showImage || showRenderModal" class="memberImage" @click="closeImage">
+            <template v-if="showImage">
+                <img :src="imageUrl" />
+            </template>
+            <template v-else>
+                <CourtDrawingRender :drawing-data="renderModalData" :width="560" :height="360" />
+            </template>
         </div>
         <div v-if="showAccidentForm" class="accidentForm">
             <form @submit.prevent="submitAccident">
@@ -345,7 +353,7 @@
                         + accident.accident}}</li>
                 </ul>
             </form>
-        </div>
+        </div> 
 
         <!-- Schnell hinzufügen Dialog -->
         <div v-if="showQuickAddDialog" class="modal-overlay" @click.self="closeQuickAddDialog">
@@ -397,10 +405,11 @@ import apiClient from '../apiClient.js';
 import Multiselect from 'vue-multiselect';
 import Sortable from 'sortablejs';
 import PDFGenerator from '../components/PDFGenerator.js';
+import CourtDrawingRender from '../components/CourtDrawingRender.vue';
 
 export default {
     name: 'DiaryView',
-    components: { Multiselect },
+    components: { Multiselect, CourtDrawingRender },
     data() {
         return {
             date: null,
@@ -436,6 +445,8 @@ export default {
             showDropdown: false,
             showImage: false,
             imageUrl: '',
+            showRenderModal: false,
+            renderModalData: null,
             groups: [],
             currentTimeBlockId: null,
             newGroupName: '',
@@ -526,6 +537,36 @@ export default {
         },
     },
     methods: {
+        drawingDataFor(pa) {
+            // Zeichnungsdaten können bereits als Objekt vorliegen oder als JSON-String
+            try {
+                if (!pa) return null;
+                if (pa.drawingData && typeof pa.drawingData === 'object') {
+                    console.debug('DiaryView: drawingData (object) gefunden für', pa.id);
+                    return pa.drawingData;
+                }
+                if (pa.drawingData && typeof pa.drawingData === 'string') {
+                    const parsed = JSON.parse(pa.drawingData);
+                    console.debug('DiaryView: drawingData (string→parsed) für', pa.id, parsed);
+                    return parsed;
+                }
+                // Fallback: falls über images[0].drawingData geliefert wurde
+                if (pa.images && pa.images.length) {
+                    // Nimm das erste Bild, das drawingData enthält
+                    const withData = pa.images.find(img => !!img.drawingData);
+                    if (withData) {
+                        const parsedImg = typeof withData.drawingData === 'string'
+                            ? JSON.parse(withData.drawingData)
+                            : withData.drawingData;
+                        console.debug('DiaryView: drawingData aus images für', pa.id, 'imageId=', withData.id, parsedImg);
+                        return parsedImg;
+                    }
+                }
+            } catch (e) {
+                console.warn('DiaryView: drawingData parse error:', e);
+            }
+            return null;
+        },
         async init() {
             if (this.isAuthenticated && this.currentClub) {
                 const response = await apiClient.get(`/diary/${this.currentClub}`);
@@ -1119,12 +1160,43 @@ export default {
         },
         closeImage() {
             this.showImage = false;
+            this.showRenderModal = false;
+            this.renderModalData = null;
             this.imageUrl = '';
         },
 
-        showActivityImage(imageLink) {
-            this.imageUrl = imageLink;
-            this.showImage = true;
+        async showActivityImage(imageLink) {
+            try {
+                // Vorherige Object-URL freigeben
+                if (this.imageUrl && this.imageUrl.startsWith('blob:')) {
+                    URL.revokeObjectURL(this.imageUrl);
+                }
+
+                if (imageLink && imageLink.startsWith('/api/')) {
+                    // Über API mit Auth und als Blob laden → vermeidet ORB
+                    const path = imageLink.replace(/^\/api\//, '');
+                    const resp = await apiClient.get(`/${path}`, { responseType: 'blob' });
+                    this.imageUrl = URL.createObjectURL(resp.data);
+                } else {
+                    this.imageUrl = imageLink;
+                }
+                this.showImage = true;
+            } catch (e) {
+                console.error('Bild laden fehlgeschlagen:', e);
+                alert('Bild konnte nicht geladen werden.');
+            }
+        },
+        async openActivityVisual(pa) {
+            // Bevorzugt Rendering, ansonsten Bild
+            const data = this.drawingDataFor(pa);
+            if (data) {
+                // Erzeuge temporär ein PNG im Client: Canvas offscreen rendern über Renderer-Komponente ist aufwändig.
+                // Einfacher: öffne ein kleines Modal mit der Renderer-Komponente statt imageUrl.
+                this.renderModalData = data;
+                this.showRenderModal = true;
+            } else if (pa.imageLink) {
+                await this.showActivityImage(pa.imageLink);
+            }
         },
         async loadMemberImage(member) {
             try {
@@ -1910,6 +1982,12 @@ img {
     margin: 0 auto;
 }
 
+.memberImage > div, .memberImage canvas {
+    /* falls Komponenten-Inhalt (Renderer) da ist, mittig zeigen */
+    display: block;
+    margin: 0 auto;
+}
+
 .groups {
     display: flex;
     flex-direction: row;

frontend/src/views/HettvAccount.vue

@@ -0,0 +1,314 @@
+<template>
+  <div class="page-container">
+    <h1>HeTTV-Account</h1>
+    
+    <div class="account-container">
+      <div v-if="loading" class="loading">Lade...</div>
+      
+      <div v-else-if="account" class="account-info">
+        <div class="info-section">
+          <h2>Verknüpfter Account</h2>
+          
+          <div class="info-row">
+            <label>E-Mail:</label>
+            <span>{{ account.email }}</span>
+          </div>
+          
+          <div class="info-row">
+            <label>Passwort gespeichert:</label>
+            <span>{{ account.savePassword ? 'Ja' : 'Nein' }}</span>
+          </div>
+          
+          <div class="info-row" v-if="account.lastLoginSuccess">
+            <label>Letzter erfolgreicher Login:</label>
+            <span>{{ formatDate(account.lastLoginSuccess) }}</span>
+          </div>
+          
+          <div class="info-row" v-if="account.lastLoginAttempt">
+            <label>Letzter Login-Versuch:</label>
+            <span>{{ formatDate(account.lastLoginAttempt) }}</span>
+          </div>
+          
+          <div class="button-group">
+            <button class="btn-primary" @click="openEditDialog">Account bearbeiten</button>
+            <button class="btn-secondary" @click="testConnection">Erneut einloggen</button>
+            <button class="btn-danger" @click="deleteAccount">Account trennen</button>
+          </div>
+        </div>
+      </div>
+      
+      <div v-else class="no-account">
+        <p>Kein HeTTV-Account verknüpft.</p>
+        <button class="btn-primary" @click="openEditDialog">Account verknüpfen</button>
+      </div>
+
+      <div class="info-box">
+        <h3>Über HeTTV</h3>
+        <p>Durch die Verknüpfung Ihres HeTTV-Accounts können Sie:</p>
+        <ul>
+          <li>Spielerdaten automatisch synchronisieren</li>
+          <li>Ligainformationen abrufen</li>
+          <li>Wettkampfdaten direkt importieren</li>
+        </ul>
+        <p><strong>Hinweis:</strong> Das Speichern des Passworts ist optional. Wenn Sie es nicht speichern, werden Sie bei jeder Synchronisation nach dem Passwort gefragt.</p>
+      </div>
+    </div>
+
+    <!-- Edit Dialog -->
+    <HettvDialog
+      v-if="showDialog"
+      :account="account"
+      @close="closeDialog"
+      @saved="onAccountSaved"
+    />
+  </div>
+</template>
+
+<script>
+import apiClient from '../apiClient.js';
+import HettvDialog from '../components/HettvDialog.vue';
+
+export default {
+  name: 'HettvAccount',
+  components: {
+    HettvDialog
+  },
+  data() {
+    return {
+      loading: true,
+      account: null,
+      showDialog: false
+    };
+  },
+  mounted() {
+    this.loadAccount();
+  },
+  methods: {
+    async loadAccount() {
+      try {
+        this.loading = true;
+        const response = await apiClient.get('/external-service/account', {
+          params: { service: 'hettv' }
+        });
+        this.account = response.data.account;
+      } catch (error) {
+        console.error('Fehler beim Laden des Accounts:', error);
+        this.$store.dispatch('showMessage', {
+          text: 'Fehler beim Laden des HeTTV-Accounts',
+          type: 'error'
+        });
+      } finally {
+        this.loading = false;
+      }
+    },
+    
+    openEditDialog() {
+      this.showDialog = true;
+    },
+    
+    closeDialog() {
+      this.showDialog = false;
+    },
+    
+    async onAccountSaved() {
+      this.closeDialog();
+      await this.loadAccount();
+      this.$store.dispatch('showMessage', {
+        text: 'HeTTV-Account erfolgreich gespeichert',
+        type: 'success'
+      });
+    },
+    
+    async testConnection() {
+      try {
+        await apiClient.post('/external-service/verify', {
+          service: 'hettv'
+        });
+        this.$store.dispatch('showMessage', {
+          text: 'Login erfolgreich! Verbindungsdaten aktualisiert.',
+          type: 'success'
+        });
+        await this.loadAccount();
+      } catch (error) {
+        const message = error.response?.data?.message || 'Login fehlgeschlagen';
+        
+        if (error.response?.status === 400 && message.includes('Kein Passwort gespeichert')) {
+          this.showDialog = true;
+        }
+        
+        this.$store.dispatch('showMessage', {
+          text: message,
+          type: 'error'
+        });
+      }
+    },
+    
+    async deleteAccount() {
+      if (!confirm('Möchten Sie die Verknüpfung zum HeTTV-Account wirklich trennen?')) {
+        return;
+      }
+      
+      try {
+        await apiClient.delete('/external-service/account', {
+          params: { service: 'hettv' }
+        });
+        this.account = null;
+        this.$store.dispatch('showMessage', {
+          text: 'HeTTV-Account erfolgreich getrennt',
+          type: 'success'
+        });
+      } catch (error) {
+        console.error('Fehler beim Löschen des Accounts:', error);
+        this.$store.dispatch('showMessage', {
+          text: 'Fehler beim Trennen des Accounts',
+          type: 'error'
+        });
+      }
+    },
+    
+    formatDate(dateString) {
+      if (!dateString) return '-';
+      const date = new Date(dateString);
+      return date.toLocaleString('de-DE', {
+        year: 'numeric',
+        month: '2-digit',
+        day: '2-digit',
+        hour: '2-digit',
+        minute: '2-digit'
+      });
+    }
+  }
+};
+</script>
+
+<style scoped>
+.page-container {
+  max-width: 800px;
+  margin: 0 auto;
+  padding: 2rem;
+}
+
+h1 {
+  color: var(--text-color, #333);
+  margin-bottom: 2rem;
+}
+
+.account-container {
+  display: flex;
+  flex-direction: column;
+  gap: 2rem;
+}
+
+.loading {
+  text-align: center;
+  padding: 2rem;
+  color: #666;
+}
+
+.account-info, .no-account {
+  background: white;
+  border-radius: 8px;
+  padding: 2rem;
+  box-shadow: 0 2px 4px rgba(0, 0, 0, 0.1);
+}
+
+.info-section h2 {
+  margin-top: 0;
+  margin-bottom: 1.5rem;
+  color: var(--primary-color, #007bff);
+}
+
+.info-row {
+  display: flex;
+  justify-content: space-between;
+  padding: 0.75rem 0;
+  border-bottom: 1px solid #eee;
+}
+
+.info-row:last-of-type {
+  border-bottom: none;
+}
+
+.info-row label {
+  font-weight: 600;
+  color: #555;
+}
+
+.info-row span {
+  color: #333;
+}
+
+.button-group {
+  display: flex;
+  gap: 1rem;
+  margin-top: 2rem;
+  flex-wrap: wrap;
+}
+
+.no-account {
+  text-align: center;
+}
+
+.no-account p {
+  margin-bottom: 1.5rem;
+  color: #666;
+}
+
+.info-box {
+  background: #f8f9fa;
+  border-left: 4px solid var(--primary-color, #007bff);
+  padding: 1.5rem;
+  border-radius: 4px;
+}
+
+.info-box h3 {
+  margin-top: 0;
+  color: var(--primary-color, #007bff);
+}
+
+.info-box ul {
+  margin: 1rem 0;
+  padding-left: 1.5rem;
+}
+
+.info-box li {
+  margin: 0.5rem 0;
+}
+
+.btn-primary, .btn-secondary, .btn-danger {
+  padding: 0.75rem 1.5rem;
+  border: none;
+  border-radius: 4px;
+  font-size: 1rem;
+  cursor: pointer;
+  transition: background-color 0.2s ease;
+}
+
+.btn-primary {
+  background-color: #007bff;
+  color: white;
+}
+
+.btn-primary:hover {
+  background-color: #0056b3;
+}
+
+.btn-secondary {
+  background-color: #6c757d;
+  color: white;
+}
+
+.btn-secondary:hover {
+  background-color: #545b62;
+}
+
+.btn-danger {
+  background-color: #dc3545;
+  color: white;
+}
+
+.btn-danger:hover {
+  background-color: #c82333;
+}
+</style>
+

frontend/src/views/MembersView.vue

@@ -1,8 +1,12 @@
 <template>
     <div>
         <h2>Mitglieder</h2>
-        <div>
-            <button @click="createPhoneList">Telefonliste generieren</button>Es werden nur aktive Mitglieder ausgegeben
+        <div class="action-buttons">
+            <button @click="createPhoneList">Telefonliste generieren</button>
+            <span class="info-text">Es werden nur aktive Mitglieder ausgegeben</span>
+            <button @click="updateRatingsFromMyTischtennis" class="btn-update-ratings" :disabled="isUpdatingRatings">
+                {{ isUpdatingRatings ? 'Aktualisiere...' : 'TTR/QTTR von myTischtennis aktualisieren' }}
+            </button>
         </div>
         <div class="newmember">
             <div class="toggle-new-member">
@@ -56,6 +60,7 @@
                         <th>Bild (Inet?)</th>
                         <th>Testm.</th>
                         <th>Name, Vorname</th>
+                        <th>TTR / QTTR</th>
                         <th>Adresse</th>
                         <th>Geburtsdatum</th>
                         <th>Telefon-Nr.</th>
@@ -80,6 +85,14 @@
                                     <span v-if="!member.active && showInactiveMembers" class="inactive-badge">inaktiv</span>
                                 </span>
                             </td>
+                            <td class="rating-cell">
+                                <span v-if="member.ttr || member.qttr">
+                                    <span v-if="member.ttr" class="ttr-value">{{ member.ttr }}</span>
+                                    <span v-if="member.ttr && member.qttr" class="rating-separator">/</span>
+                                    <span v-if="member.qttr" class="qttr-value">{{ member.qttr }}</span>
+                                </span>
+                                <span v-else class="no-rating">-</span>
+                            </td>
                             <td>{{ member.street }}, {{ member.city }}</td>
                             <td>{{ getFormattedBirthdate(member.birthDate) }}</td>
                             <td>{{ member.phone }}</td>
@@ -152,7 +165,8 @@ export default {
             selectedImageUrl: null,
             testMembership: false,
             showInactiveMembers: false,
-            newPicsInInternetAllowed: false
+            newPicsInInternetAllowed: false,
+            isUpdatingRatings: false
         }
     },
     async mounted() {
@@ -371,6 +385,25 @@ export default {
             if (v === 'female') return '♀';
             if (v === 'diverse') return '⚧';
             return '';
+        },
+        async updateRatingsFromMyTischtennis() {
+            this.isUpdatingRatings = true;
+            try {
+                const response = await apiClient.post(`/clubmembers/update-ratings/${this.currentClub}`);
+                
+                if (response.data.message) {
+                    alert(response.data.message);
+                }
+                
+                // Mitglieder neu laden um aktualisierte Werte anzuzeigen
+                await this.loadMembers();
+            } catch (error) {
+                console.error('Fehler beim Aktualisieren der Ratings:', error);
+                const message = error.response?.data?.error || error.response?.data?.message || 'Fehler beim Aktualisieren der TTR/QTTR-Werte';
+                alert(message);
+            } finally {
+                this.isUpdatingRatings = false;
+            }
         }
     }
 }
@@ -489,4 +522,61 @@ table td {
 .row-inactive { opacity: .6; }
 .is-inactive { text-decoration: line-through; }
 .inactive-badge { margin-left: .5rem; font-size: .85em; color: #666; text-transform: lowercase; }
+
+.rating-cell {
+    font-family: 'Courier New', monospace;
+    font-size: 0.95em;
+}
+
+.ttr-value {
+    font-weight: 600;
+    color: #1a73e8;
+}
+
+.qttr-value {
+    font-weight: 600;
+    color: #d81b60;
+}
+
+.rating-separator {
+    color: #999;
+    margin: 0 0.25rem;
+}
+
+.no-rating {
+    color: #999;
+}
+
+.action-buttons {
+    display: flex;
+    align-items: center;
+    gap: 1rem;
+    margin-bottom: 1rem;
+}
+
+.info-text {
+    font-size: 0.9em;
+    color: #666;
+}
+
+.btn-update-ratings {
+    background-color: #28a745;
+    color: white;
+    border: none;
+    padding: 0.5rem 1rem;
+    border-radius: 4px;
+    cursor: pointer;
+    font-size: 0.9em;
+    transition: background-color 0.2s ease;
+}
+
+.btn-update-ratings:hover:not(:disabled) {
+    background-color: #218838;
+}
+
+.btn-update-ratings:disabled {
+    background-color: #6c757d;
+    cursor: not-allowed;
+    opacity: 0.6;
+}
 </style>

frontend/src/views/MyTischtennisAccount.vue

@@ -0,0 +1,423 @@
+<template>
+  <div class="page-container">
+    <h1>myTischtennis-Account</h1>
+    
+    <div class="account-container">
+      <div v-if="loading" class="loading">Lade...</div>
+      
+      <div v-else-if="account" class="account-info">
+        <div class="info-section">
+          <h2>Verknüpfter Account</h2>
+          
+          <div class="info-row">
+            <label>E-Mail:</label>
+            <span>{{ account.email }}</span>
+          </div>
+          
+          <div class="info-row">
+            <label>Passwort gespeichert:</label>
+            <span>{{ account.savePassword ? 'Ja' : 'Nein' }}</span>
+          </div>
+          
+          <div class="info-row" v-if="account.clubId">
+            <label>Verein (myTischtennis):</label>
+            <span>{{ account.clubName }} ({{ account.clubId }}{{ account.fedNickname ? ' - ' + account.fedNickname : '' }})</span>
+          </div>
+          
+          <div class="info-row" v-if="account.lastLoginSuccess">
+            <label>Letzter erfolgreicher Login:</label>
+            <span>{{ formatDate(account.lastLoginSuccess) }}</span>
+          </div>
+          
+          <div class="info-row" v-if="account.lastLoginAttempt">
+            <label>Letzter Login-Versuch:</label>
+            <span>{{ formatDate(account.lastLoginAttempt) }}</span>
+          </div>
+          
+          <div class="button-group">
+            <button class="btn-primary" @click="openEditDialog">Account bearbeiten</button>
+            <button class="btn-secondary" @click="testConnection">Verbindung testen</button>
+            <button class="btn-secondary" @click="testLoginFlow">Test: Login-Flow</button>
+            <button class="btn-danger" @click="deleteAccount">Account trennen</button>
+          </div>
+        </div>
+        
+        <!-- Test-Ausgabe -->
+        <div v-if="testResult" class="test-result" :class="testResult.type">
+          <h3>Test-Ergebnis:</h3>
+          <pre>{{ testResult.data }}</pre>
+        </div>
+      </div>
+      
+      <div v-else class="no-account">
+        <p>Kein myTischtennis-Account verknüpft.</p>
+        <button class="btn-primary" @click="openEditDialog">Account verknüpfen</button>
+      </div>
+
+      <div class="info-box">
+        <h3>Über myTischtennis</h3>
+        <p>Durch die Verknüpfung Ihres myTischtennis-Accounts können Sie:</p>
+        <ul>
+          <li>Automatisch Turnierdaten importieren</li>
+          <li>Spielerergebnisse synchronisieren</li>
+          <li>Wettkampfdaten direkt abrufen</li>
+        </ul>
+        <p><strong>Hinweis:</strong> Das Speichern des Passworts ist optional. Wenn Sie es nicht speichern, werden Sie bei jeder Synchronisation nach dem Passwort gefragt.</p>
+      </div>
+    </div>
+
+    <!-- Edit Dialog -->
+    <MyTischtennisDialog
+      v-if="showDialog"
+      :account="account"
+      @close="closeDialog"
+      @saved="onAccountSaved"
+    />
+  </div>
+</template>
+
+<script>
+import apiClient from '../apiClient.js';
+import MyTischtennisDialog from '../components/MyTischtennisDialog.vue';
+
+export default {
+  name: 'MyTischtennisAccount',
+  components: {
+    MyTischtennisDialog
+  },
+  data() {
+    return {
+      loading: true,
+      account: null,
+      showDialog: false,
+      testResult: null
+    };
+  },
+  mounted() {
+    this.loadAccount();
+  },
+  methods: {
+    async loadAccount() {
+      try {
+        this.loading = true;
+        const response = await apiClient.get('/mytischtennis/account');
+        this.account = response.data.account;
+      } catch (error) {
+        console.error('Fehler beim Laden des Accounts:', error);
+        this.$store.dispatch('showMessage', {
+          text: 'Fehler beim Laden des myTischtennis-Accounts',
+          type: 'error'
+        });
+      } finally {
+        this.loading = false;
+      }
+    },
+    
+    openEditDialog() {
+      this.showDialog = true;
+    },
+    
+    closeDialog() {
+      this.showDialog = false;
+    },
+    
+    async onAccountSaved() {
+      this.closeDialog();
+      await this.loadAccount();
+      this.$store.dispatch('showMessage', {
+        text: 'myTischtennis-Account erfolgreich gespeichert',
+        type: 'success'
+      });
+    },
+    
+    async testConnection() {
+      this.testResult = null;
+      try {
+        await apiClient.post('/mytischtennis/verify');
+        this.$store.dispatch('showMessage', {
+          text: 'Verbindung erfolgreich! Login funktioniert.',
+          type: 'success'
+        });
+        await this.loadAccount(); // Aktualisiere lastLoginSuccess
+      } catch (error) {
+        const message = error.response?.data?.message || 'Verbindung fehlgeschlagen';
+        
+        if (error.response?.status === 400 && message.includes('Kein Passwort gespeichert')) {
+          // Passwort-Dialog öffnen
+          this.showDialog = true;
+        }
+        
+        this.$store.dispatch('showMessage', {
+          text: message,
+          type: 'error'
+        });
+      }
+    },
+    
+    async testLoginFlow() {
+      this.testResult = null;
+      
+      try {
+        // 1. Verify Login
+        console.log('Testing login...');
+        const verifyResponse = await apiClient.post('/mytischtennis/verify');
+        console.log('Login successful:', verifyResponse.data);
+        
+        // 2. Get Session
+        console.log('Fetching session...');
+        const sessionResponse = await apiClient.get('/mytischtennis/session');
+        console.log('Session data:', sessionResponse.data);
+        
+        // 3. Check Status
+        console.log('Checking status...');
+        const statusResponse = await apiClient.get('/mytischtennis/status');
+        console.log('Status:', statusResponse.data);
+        
+        this.testResult = {
+          type: 'success',
+          data: {
+            message: 'Alle Tests erfolgreich!',
+            login: {
+              accessToken: verifyResponse.data.accessToken ? '✓ vorhanden' : '✗ fehlt',
+              expiresAt: verifyResponse.data.expiresAt,
+              clubId: verifyResponse.data.clubId || '✗ nicht gefunden',
+              clubName: verifyResponse.data.clubName || '✗ nicht gefunden'
+            },
+            session: {
+              accessToken: sessionResponse.data.session?.accessToken ? '✓ vorhanden' : '✗ fehlt',
+              refreshToken: sessionResponse.data.session?.refreshToken ? '✓ vorhanden' : '✗ fehlt',
+              cookie: sessionResponse.data.session?.cookie ? '✓ vorhanden' : '✗ fehlt',
+              userData: sessionResponse.data.session?.userData ? '✓ vorhanden' : '✗ fehlt',
+              expiresAt: sessionResponse.data.session?.expiresAt
+            },
+            status: statusResponse.data
+          }
+        };
+        
+        this.$store.dispatch('showMessage', {
+          text: 'Test erfolgreich! Details siehe unten.',
+          type: 'success'
+        });
+        
+      } catch (error) {
+        console.error('Test failed:', error);
+        
+        this.testResult = {
+          type: 'error',
+          data: {
+            message: 'Test fehlgeschlagen',
+            error: error.response?.data?.message || error.message,
+            status: error.response?.status,
+            details: error.response?.data
+          }
+        };
+        
+        this.$store.dispatch('showMessage', {
+          text: `Test fehlgeschlagen: ${error.response?.data?.message || error.message}`,
+          type: 'error'
+        });
+      }
+    },
+    
+    async deleteAccount() {
+      if (!confirm('Möchten Sie die Verknüpfung zum myTischtennis-Account wirklich trennen?')) {
+        return;
+      }
+      
+      try {
+        await apiClient.delete('/mytischtennis/account');
+        this.account = null;
+        this.$store.dispatch('showMessage', {
+          text: 'myTischtennis-Account erfolgreich getrennt',
+          type: 'success'
+        });
+      } catch (error) {
+        console.error('Fehler beim Löschen des Accounts:', error);
+        this.$store.dispatch('showMessage', {
+          text: 'Fehler beim Trennen des Accounts',
+          type: 'error'
+        });
+      }
+    },
+    
+    formatDate(dateString) {
+      if (!dateString) return '-';
+      const date = new Date(dateString);
+      return date.toLocaleString('de-DE', {
+        year: 'numeric',
+        month: '2-digit',
+        day: '2-digit',
+        hour: '2-digit',
+        minute: '2-digit'
+      });
+    }
+  }
+};
+</script>
+
+<style scoped>
+.page-container {
+  max-width: 800px;
+  margin: 0 auto;
+  padding: 2rem;
+}
+
+h1 {
+  color: var(--text-color, #333);
+  margin-bottom: 2rem;
+}
+
+.account-container {
+  display: flex;
+  flex-direction: column;
+  gap: 2rem;
+}
+
+.loading {
+  text-align: center;
+  padding: 2rem;
+  color: #666;
+}
+
+.account-info, .no-account {
+  background: white;
+  border-radius: 8px;
+  padding: 2rem;
+  box-shadow: 0 2px 4px rgba(0, 0, 0, 0.1);
+}
+
+.info-section h2 {
+  margin-top: 0;
+  margin-bottom: 1.5rem;
+  color: var(--primary-color, #007bff);
+}
+
+.info-row {
+  display: flex;
+  justify-content: space-between;
+  padding: 0.75rem 0;
+  border-bottom: 1px solid #eee;
+}
+
+.info-row:last-of-type {
+  border-bottom: none;
+}
+
+.info-row label {
+  font-weight: 600;
+  color: #555;
+}
+
+.info-row span {
+  color: #333;
+}
+
+.button-group {
+  display: flex;
+  gap: 1rem;
+  margin-top: 2rem;
+  flex-wrap: wrap;
+}
+
+.no-account {
+  text-align: center;
+}
+
+.no-account p {
+  margin-bottom: 1.5rem;
+  color: #666;
+}
+
+.info-box {
+  background: #f8f9fa;
+  border-left: 4px solid var(--primary-color, #007bff);
+  padding: 1.5rem;
+  border-radius: 4px;
+}
+
+.info-box h3 {
+  margin-top: 0;
+  color: var(--primary-color, #007bff);
+}
+
+.info-box ul {
+  margin: 1rem 0;
+  padding-left: 1.5rem;
+}
+
+.info-box li {
+  margin: 0.5rem 0;
+}
+
+.btn-primary, .btn-secondary, .btn-danger {
+  padding: 0.75rem 1.5rem;
+  border: none;
+  border-radius: 4px;
+  font-size: 1rem;
+  cursor: pointer;
+  transition: background-color 0.2s ease;
+}
+
+.btn-primary {
+  background-color: #007bff;
+  color: white;
+}
+
+.btn-primary:hover {
+  background-color: #0056b3;
+}
+
+.btn-secondary {
+  background-color: #6c757d;
+  color: white;
+}
+
+.btn-secondary:hover {
+  background-color: #545b62;
+}
+
+.btn-danger {
+  background-color: #dc3545;
+  color: white;
+}
+
+.btn-danger:hover {
+  background-color: #c82333;
+}
+
+.test-result {
+  background: white;
+  border-radius: 8px;
+  padding: 1.5rem;
+  box-shadow: 0 2px 4px rgba(0, 0, 0, 0.1);
+  margin-top: 1rem;
+}
+
+.test-result.success {
+  border-left: 4px solid #28a745;
+}
+
+.test-result.error {
+  border-left: 4px solid #dc3545;
+}
+
+.test-result h3 {
+  margin-top: 0;
+  margin-bottom: 1rem;
+  color: #333;
+}
+
+.test-result pre {
+  background: #f8f9fa;
+  border: 1px solid #dee2e6;
+  border-radius: 4px;
+  padding: 1rem;
+  overflow-x: auto;
+  font-family: 'Courier New', monospace;
+  font-size: 0.875rem;
+  line-height: 1.5;
+  white-space: pre-wrap;
+  word-wrap: break-word;
+}
+</style>
+

frontend/src/views/PredefinedActivities.vue

@@ -56,7 +56,7 @@
           </label>
           <div class="image-section">
             <h4>Bild hinzufügen</h4>
-            <p class="image-help">Du kannst entweder einen Link zu einem Bild eingeben oder ein Bild hochladen:</p>
+            <p class="image-help">Du kannst entweder einen Link zu einem Bild eingeben, ein Bild hochladen oder eine Übungszeichnung erstellen:</p>
             
             <label>Bild-Link (optional)
               <input type="text" v-model="editModel.imageLink" placeholder="z.B. https://example.com/bild.jpg oder /api/predefined-activities/:id/image/:imageId" />
@@ -74,6 +74,18 @@
               </p>
             </div>
 
+            <!-- Zeichen-Tool -->
+            <div class="drawing-section">
+              <h5>Übungszeichnung erstellen</h5>
+           <CourtDrawingTool 
+             :activity-id="editModel.id"
+             :drawing-data="editModel.drawingData"
+             :allow-image-upload="false"
+             @update-fields="onUpdateFields"
+             @update-drawing-data="onUpdateDrawingData"
+           />
+            </div>
+
             <div class="image-list" v-if="images && images.length">
               <h5>Hochgeladene Bilder:</h5>
               <div class="image-grid">
@@ -97,9 +109,13 @@
 
 <script>
 import apiClient from '../apiClient.js';
+import CourtDrawingTool from '../components/CourtDrawingTool.vue';
 
 export default {
   name: 'PredefinedActivities',
+  components: {
+    CourtDrawingTool
+  },
   data() {
     return {
       activities: [],
@@ -107,6 +123,7 @@ export default {
       editModel: null,
       images: [],
       selectedFile: null,
+      selectedDrawingData: null,
       mergeSourceId: '',
       mergeTargetId: '',
     };
@@ -131,6 +148,15 @@ export default {
     }
   },
   methods: {
+    parseDrawingData(value) {
+      if (!value) return null;
+      if (typeof value === 'object') return value;
+      try { return JSON.parse(value); } catch (e) { return null; }
+    },
+    normalizeActivity(activity, images) {
+      const drawingData = this.parseDrawingData(activity && activity.drawingData);
+      return { ...(activity || {}), drawingData };
+    },
     async reload() {
       const r = await apiClient.get('/predefined-activities');
       this.activities = r.data || [];
@@ -140,7 +166,24 @@ export default {
       const r = await apiClient.get(`/predefined-activities/${a.id}`);
       const { images, ...activity } = r.data;
       this.images = images || [];
-      this.editModel = { ...activity };
+      // Server-Daten normalisieren und ggf. image-drawingData fallbacken
+      let model = this.normalizeActivity(activity, images);
+      if (!model.drawingData && images && images.length > 0 && images[0].drawingData) {
+        model.drawingData = this.parseDrawingData(images[0].drawingData);
+      }
+      this.editModel = model;
+    },
+    async reloadImages() {
+      if (this.editModel && this.editModel.id) {
+        try {
+          const r = await apiClient.get(`/predefined-activities/${this.editModel.id}`);
+          const { images } = r.data;
+          this.images = images || [];
+          console.log('Images reloaded:', this.images);
+        } catch (error) {
+          console.error('Error reloading images:', error);
+        }
+      }
     },
     formatItem(a) {
       return `${a.code ? '[' + a.code + '] ' : ''}${a.name}`;
@@ -164,6 +207,7 @@ export default {
         duration: null,
         durationText: '',
         imageLink: '',
+        drawingData: '',
       };
     },
     cancel() {
@@ -173,36 +217,81 @@ export default {
     },
     async save() {
       if (!this.editModel) return;
+      
+      console.log('Save: selectedFile =', this.selectedFile);
+      
       if (this.editModel.id) {
         const { id, ...payload } = this.editModel;
+        if (payload.drawingData && typeof payload.drawingData === 'object') {
+          payload.drawingData = payload.drawingData;
+        }
         const r = await apiClient.put(`/predefined-activities/${id}`, payload);
-        this.editModel = r.data;
+        this.editModel = this.normalizeActivity(r.data);
       } else {
         const r = await apiClient.post('/predefined-activities', this.editModel);
-        this.editModel = r.data;
-        // Nach dem Erstellen einer neuen Aktivität, falls ein Bild ausgewählt wurde, hochladen
-        if (this.selectedFile) {
-          await this.uploadImage();
-        }
+        this.editModel = this.normalizeActivity(r.data);
       }
+      
+      // Nach dem Speichern (sowohl CREATE als auch UPDATE): Bild hochladen falls vorhanden
+      if (this.selectedFile) {
+        console.log('Uploading image after save...');
+        await this.uploadImage();
+      } else {
+        console.log('No selectedFile to upload');
+      }
+      
       await this.reload();
     },
     onFileChange(e) {
       this.selectedFile = e.target.files && e.target.files[0] ? e.target.files[0] : null;
     },
     imageUrl(img) {
-      return `/api/predefined-activities/${this.editModel.id}/image/${img.id}`;
+      return `http://localhost:3000/api/predefined-activities/${this.editModel.id}/image/${img.id}`;
     },
     async uploadImage() {
-      if (!this.editModel || !this.editModel.id || !this.selectedFile) return;
+      if (!this.editModel || !this.editModel.id || !this.selectedFile) {
+        console.log('Upload skipped: editModel=', this.editModel, 'selectedFile=', this.selectedFile);
+        return;
+      }
+      
+      console.log('Starting image upload...');
+      console.log('editModel:', this.editModel);
+      console.log('selectedActivity:', this.selectedActivity);
+      console.log('Activity ID (editModel.id):', this.editModel.id);
+      console.log('Activity ID (selectedActivity.id):', this.selectedActivity?.id);
+      console.log('File:', this.selectedFile);
+      
       const fd = new FormData();
       fd.append('image', this.selectedFile);
-      await apiClient.post(`/predefined-activities/${this.editModel.id}/image`, fd, {
-        headers: { 'Content-Type': 'multipart/form-data' }
-      });
-      // Nach Upload Details neu laden
-      await this.select(this.editModel);
-      this.selectedFile = null;
+      
+      // Füge Zeichnungsdaten hinzu, falls vorhanden
+      if (this.selectedDrawingData) {
+        fd.append('drawingData', JSON.stringify(this.selectedDrawingData));
+        console.log('Added drawingData to FormData:', this.selectedDrawingData);
+      }
+      
+      // Verwende PUT für Updates, POST für neue Activities
+      const isUpdate = this.selectedActivity && this.selectedActivity.id === this.editModel.id;
+      const method = isUpdate ? 'put' : 'post';
+      
+      console.log('Using method:', method);
+      
+      try {
+        const response = await apiClient[method](`/predefined-activities/${this.editModel.id}/image`, fd, {
+          headers: { 'Content-Type': 'multipart/form-data' }
+        });
+        console.log('Upload successful:', response);
+        
+        // Nach Upload Details neu laden
+        await this.select(this.editModel);
+        this.selectedFile = null;
+        
+        // Bildliste explizit aktualisieren
+        await this.reloadImages();
+      } catch (error) {
+        console.error('Upload failed:', error);
+        throw error;
+      }
     },
     async deleteImage(imageId) {
       if (!this.editModel || !this.editModel.id) return;
@@ -220,6 +309,53 @@ export default {
       if (!confirm('Alle Aktivitäten mit identischem Namen werden zusammengeführt. Fortfahren?')) return;
       await apiClient.post('/predefined-activities/deduplicate', {});
       await this.reload();
+    },
+    onDrawingSave(drawingData) {
+      if (this.editModel) {
+        this.editModel.drawingData = drawingData;
+        // Automatisch als Bild-Link setzen, wenn es eine Zeichnung gibt
+        if (drawingData && !this.editModel.imageLink) {
+          this.editModel.imageLink = drawingData;
+        }
+      }
+      // Nicht automatisch speichern, nur wenn User explizit "Speichern" klickt
+    },
+    onUpdateFields(fields) {
+      if (this.editModel) {
+        this.editModel.code = fields.code;
+        this.editModel.name = fields.name;
+        this.editModel.description = fields.description;
+      }
+    },
+    onUpdateDrawingData(data) {
+      if (this.editModel) {
+        this.editModel.drawingData = data;
+      }
+    },
+    
+    async onDrawingImageUpload(file, drawingData) {
+      console.log('onDrawingImageUpload called with file:', file);
+      console.log('onDrawingImageUpload called with drawingData:', drawingData);
+      console.log('File type:', file?.type);
+      console.log('File size:', file?.size);
+      console.log('File name:', file?.name);
+      
+      // Setze das File und die Zeichnungsdaten für den Upload
+      this.selectedFile = file;
+      this.selectedDrawingData = drawingData;
+      console.log('selectedFile set to:', this.selectedFile);
+      console.log('selectedDrawingData set to:', this.selectedDrawingData);
+      
+      // Upload wird erst beim Speichern durchgeführt
+      console.log('File and drawing data ready for upload when saving');
+    },
+    
+    async onImageUploaded() {
+      console.log('Image uploaded successfully, refreshing image list...');
+      // Bildliste aktualisieren
+      if (this.editModel && this.editModel.id) {
+        await this.select(this.editModel);
+      }
     }
   },
   async mounted() {
@@ -354,5 +490,19 @@ input[type="text"], input[type="number"], textarea { width: 100%; }
 .btn-danger:hover {
   background: #c82333;
 }
+
+.drawing-section {
+  margin: 1rem 0;
+  padding: 1rem;
+  background: white;
+  border-radius: var(--border-radius);
+  border: 1px solid #ddd;
+}
+
+.drawing-section h5 {
+  margin: 0 0 1rem 0;
+  color: #333;
+  font-size: 1rem;
+}
 </style>
 

frontend/src/views/ScheduleView.vue

@@ -1,7 +1,12 @@
 <template>
     <div>
         <h2>Spielpläne</h2>
-        <button @click="openImportModal">Spielplanimport</button>
+        <div class="button-group">
+            <button @click="openImportModal">Spielplanimport</button>
+            <button @click="loadHettvData" :disabled="loadingHettv" class="hettv-button">
+                {{ loadingHettv ? 'Lade HeTTV-Daten...' : 'HeTTV-Daten laden' }}
+            </button>
+        </div>
         <div v-if="hoveredMatch && hoveredMatch.location" class="hover-info">
             <p><strong>{{ hoveredMatch.location.name || 'N/A' }}</strong></p>
             <p>{{ hoveredMatch.location.address || 'N/A' }}</p>
@@ -79,6 +84,8 @@ export default {
             matches: [],
             selectedLeague: '',
             hoveredMatch: null,
+            loadingHettv: false,
+            hettvData: null,
         };
     },
     methods: {
@@ -174,10 +181,15 @@ export default {
         async loadLeagues() {
             try {
                 const clubId = this.currentClub;
+                if (!clubId || clubId === 'null') {
+                    console.log('Kein Club ausgewählt, überspringe Liga-Laden');
+                    return;
+                }
                 const response = await apiClient.get(`/matches/leagues/current/${clubId}`);
                 this.leagues = this.sortLeagues(response.data);
             } catch (error) {
-                alert('Fehler beim Laden der Ligen');
+                console.log('Fehler beim Laden der Ligen:', error.message);
+                // Keine Alert mehr, da das normal ist wenn kein Club-Zugriff vorhanden
             }
         },
         async loadMatchesForLeague(leagueId, leagueName) {
@@ -301,6 +313,39 @@ export default {
             
             return ''; // Keine besondere Farbe
         },
+        async loadHettvData() {
+            this.loadingHettv = true;
+            try {
+                console.log('Lade HeTTV-Hauptseite...');
+                const response = await apiClient.get('/external-service/hettv/main-page');
+                
+                if (response.data.success) {
+                    this.hettvData = response.data.data;
+                    console.log('HeTTV-Daten geladen:', {
+                        downloadLinks: this.hettvData.downloadLinks,
+                        htmlLength: this.hettvData.htmlContent.length,
+                        trace: this.hettvData.trace,
+                        lastUrl: this.hettvData.lastUrl,
+                        lastStatus: this.hettvData.lastStatus,
+                        savedFile: this.hettvData.savedFile
+                    });
+                    
+                    // Zeige gefundene Download-Links
+                    if (this.hettvData.downloadLinks.length > 0) {
+                        alert(`HeTTV-Daten erfolgreich geladen!\n\nGefundene Download-Links:\n${this.hettvData.downloadLinks.join('\n')}`);
+                    } else {
+                        alert('HeTTV-Hauptseite geladen, aber keine Download-Links gefunden.');
+                    }
+                } else {
+                    alert('Fehler beim Laden der HeTTV-Daten: ' + response.data.error);
+                }
+            } catch (error) {
+                console.error('HeTTV-Fehler:', error);
+                alert('Fehler beim Laden der HeTTV-Daten: ' + (error.response?.data?.error || error.message));
+            } finally {
+                this.loadingHettv = false;
+            }
+        },
     },
     async created() {
         await this.loadLeagues();
@@ -451,4 +496,37 @@ li {
 .match-next-week:hover {
     background-color: #b8daff !important; /* Dunkleres Blau beim Hover */
 }
+
+.button-group {
+    margin-bottom: 20px;
+}
+
+.button-group button {
+    margin-right: 10px;
+    padding: 8px 16px;
+    border: 1px solid #ddd;
+    background-color: #f8f9fa;
+    cursor: pointer;
+    border-radius: 4px;
+}
+
+.button-group button:hover {
+    background-color: #e9ecef;
+}
+
+.hettv-button {
+    background-color: #007bff !important;
+    color: white !important;
+    border-color: #007bff !important;
+}
+
+.hettv-button:hover {
+    background-color: #0056b3 !important;
+}
+
+.hettv-button:disabled {
+    background-color: #6c757d !important;
+    border-color: #6c757d !important;
+    cursor: not-allowed;
+}
 </style>

frontend/src/views/TrainingStatsView.vue

@@ -19,8 +19,43 @@
       </div>
     </div>
 
-    <div class="members-table-container">
-      <table class="members-table">
+    <!-- Trainingstage-Tabelle (standardmäßig aufgeklappt) -->
+    <div class="collapsible-section">
+      <div class="section-header" @click="toggleTrainingDays">
+        <h3>Trainingstage (letzte 12 Monate)</h3>
+        <span class="toggle-icon">{{ showTrainingDays ? '▼' : '▶' }}</span>
+      </div>
+      <div v-if="showTrainingDays" class="section-content">
+        <div class="training-days-container">
+          <table class="training-days-table">
+            <thead>
+              <tr>
+                <th>Datum</th>
+                <th>Wochentag</th>
+                <th>Teilnehmer</th>
+              </tr>
+            </thead>
+            <tbody>
+              <tr v-for="day in trainingDays" :key="day.id">
+                <td>{{ formatDate(day.date) }}</td>
+                <td>{{ getWeekday(day.date) }}</td>
+                <td>{{ day.participantCount }}</td>
+              </tr>
+            </tbody>
+          </table>
+        </div>
+      </div>
+    </div>
+
+    <!-- Mitglieder-Tabelle (standardmäßig eingeklappt) -->
+    <div class="collapsible-section">
+      <div class="section-header" @click="toggleMembers">
+        <h3>Mitglieder-Teilnahmen</h3>
+        <span class="toggle-icon">{{ showMembers ? '▼' : '▶' }}</span>
+      </div>
+      <div v-if="showMembers" class="section-content">
+        <div class="members-table-container">
+          <table class="members-table">
         <thead>
           <tr>
             <th @click="sortBy('name')" class="sortable-header">
@@ -74,6 +109,8 @@
         </tbody>
       </table>
     </div>
+      </div>
+    </div>
 
     <!-- Modal für Mitgliedsdetails -->
     <div v-if="showDetailsModal" class="modal">
@@ -126,15 +163,15 @@ export default {
     ...mapGetters(['isAuthenticated', 'currentClub']),
     
     averageParticipation12Months() {
-      if (this.activeMembers.length === 0) return 0;
+      if (this.trainingsCount12Months === 0) return 0;
       const total = this.activeMembers.reduce((sum, member) => sum + member.participation12Months, 0);
-      return total / this.activeMembers.length;
+      return total / this.trainingsCount12Months;
     },
     
     averageParticipation3Months() {
-      if (this.activeMembers.length === 0) return 0;
+      if (this.trainingsCount3Months === 0) return 0;
       const total = this.activeMembers.reduce((sum, member) => sum + member.participation3Months, 0);
-      return total / this.activeMembers.length;
+      return total / this.trainingsCount3Months;
     },
     
     sortedMembers() {
@@ -167,11 +204,16 @@ export default {
   data() {
     return {
       activeMembers: [],
+      trainingsCount12Months: 0,
+      trainingsCount3Months: 0,
+      trainingDays: [],
       showDetailsModal: false,
       selectedMember: {},
       loading: false,
       sortField: 'name',
-      sortDirection: 'asc'
+      sortDirection: 'asc',
+      showTrainingDays: true,
+      showMembers: false
     };
   },
   
@@ -199,7 +241,10 @@ export default {
       this.loading = true;
       try {
         const response = await apiClient.get(`/training-stats/${this.currentClub}`);
-        this.activeMembers = response.data;
+        this.activeMembers = response.data.members || [];
+        this.trainingsCount12Months = response.data.trainingsCount12Months || 0;
+        this.trainingsCount3Months = response.data.trainingsCount3Months || 0;
+        this.trainingDays = response.data.trainingDays || [];
       } catch (error) {
         // Kein Alert - es ist normal, dass nicht alle Daten verfügbar sind
       } finally {
@@ -207,6 +252,20 @@ export default {
       }
     },
     
+    toggleTrainingDays() {
+      this.showTrainingDays = !this.showTrainingDays;
+    },
+    
+    toggleMembers() {
+      this.showMembers = !this.showMembers;
+    },
+    
+    getWeekday(dateString) {
+      const date = new Date(dateString);
+      const weekdays = ['Sonntag', 'Montag', 'Dienstag', 'Mittwoch', 'Donnerstag', 'Freitag', 'Samstag'];
+      return weekdays[date.getDay()];
+    },
+    
     showMemberDetails(member) {
       this.selectedMember = member;
       this.showDetailsModal = true;
@@ -296,12 +355,84 @@ export default {
   color: var(--primary-color);
 }
 
-.members-table-container {
+.collapsible-section {
   background: white;
   border-radius: var(--border-radius-large);
   box-shadow: var(--shadow-light);
-  overflow: hidden;
   border: 1px solid var(--border-color);
+  margin-bottom: 1.5rem;
+  overflow: hidden;
+}
+
+.section-header {
+  padding: 1.25rem 1.5rem;
+  background: var(--bg-light);
+  cursor: pointer;
+  display: flex;
+  justify-content: space-between;
+  align-items: center;
+  user-select: none;
+  transition: background-color 0.2s ease;
+}
+
+.section-header:hover {
+  background: var(--primary-color);
+  color: white;
+}
+
+.section-header:hover h3 {
+  color: white;
+}
+
+.section-header h3 {
+  margin: 0;
+  font-size: 1.125rem;
+  color: var(--text-primary);
+  transition: color 0.2s ease;
+}
+
+.toggle-icon {
+  font-size: 1rem;
+  font-weight: bold;
+  transition: transform 0.3s ease;
+}
+
+.section-content {
+  padding: 0;
+}
+
+.training-days-container {
+  overflow-x: auto;
+}
+
+.training-days-table {
+  width: 100%;
+  border-collapse: collapse;
+}
+
+.training-days-table th,
+.training-days-table td {
+  padding: 1rem;
+  text-align: left;
+  border-bottom: 1px solid var(--border-color);
+}
+
+.training-days-table th {
+  background: var(--bg-light);
+  font-weight: 600;
+  color: var(--text-primary);
+}
+
+.training-days-table tbody tr:hover {
+  background: var(--bg-light);
+}
+
+.training-days-table tbody tr:last-child td {
+  border-bottom: none;
+}
+
+.members-table-container {
+  overflow-x: auto;
 }
 
 .members-table {