ci: migrate GitHub actions to Gitea actions

privat/CV/andreknie.de/server/routes/contact.js

@@ -19,18 +19,19 @@ router.post('/', contactLimiter, antiSpam, async (req, res) => {
     return res.status(400).json({ errors })
   }
 
-  const token = createToken('contact', { name, email, message }, 24)
+  const token = await createToken('contact', { name, email, message }, 24)
   await sendConfirmationEmail(email, 'contact', token)
   res.status(201).json({ ok: true, message: 'Bestätigungs-E-Mail gesendet.' })
 })
 
-router.post('/confirm/:token', async (req, res) => {
-  const entry = verifyToken(req.params.token)
+router.get('/confirm/:token', async (req, res) => {
+  const baseUrl = process.env.BASE_URL || ''
+  const entry = await verifyToken(req.params.token)
   if (!entry) {
-    return res.status(410).json({ error: 'Link abgelaufen oder ungültig.' })
+    return res.redirect(baseUrl + '/bestaetigung?status=error')
   }
   await sendStakeholderNotification('contact', entry.data)
-  res.json({ ok: true, message: 'Nachricht wurde weitergeleitet.' })
+  res.redirect(baseUrl + '/bestaetigung?status=success')
 })
 
 export default router

privat/CV/andreknie.de/server/routes/newsletter.js

@@ -2,6 +2,7 @@ import { Router } from 'express'
 import { readFileSync, writeFileSync, existsSync } from 'fs'
 import { join, dirname } from 'path'
 import { fileURLToPath } from 'url'
+import { Mutex } from 'async-mutex'
 import { newsletterLimiter } from '../middleware/rateLimiter.js'
 import { antiSpam } from '../middleware/antiSpam.js'
 import { createToken, verifyToken } from '../services/confirmationToken.js'
@@ -9,6 +10,7 @@ import { sendConfirmationEmail } from '../services/mailer.js'
 
 const __dirname = dirname(fileURLToPath(import.meta.url))
 const SUBS_FILE = join(__dirname, '..', 'data', 'subscribers.json')
+const subsMutex = new Mutex()
 
 function loadSubscribers() {
   if (!existsSync(SUBS_FILE)) return []
@@ -34,26 +36,29 @@ router.post('/', newsletterLimiter, antiSpam, async (req, res) => {
     return res.status(409).json({ error: 'Diese E-Mail ist bereits abonniert.' })
   }
 
-  const token = createToken('newsletter', { email }, 48)
+  const token = await createToken('newsletter', { email }, 48)
   await sendConfirmationEmail(email, 'newsletter', token)
   res.status(201).json({ ok: true, message: 'Bestätigungs-E-Mail gesendet.' })
 })
 
 router.get('/confirm/:token', async (req, res) => {
-  const entry = verifyToken(req.params.token)
+  const baseUrl = process.env.BASE_URL || ''
+  const entry = await verifyToken(req.params.token)
   if (!entry) {
-    return res.status(410).json({ error: 'Link abgelaufen oder ungültig.' })
+    return res.redirect(baseUrl + '/bestaetigung?status=error')
   }
 
-  const subs = loadSubscribers()
-  subs.push({
-    email: entry.data.email,
-    subscribedAt: new Date().toISOString(),
-    active: true,
+  await subsMutex.runExclusive(async () => {
+    const subs = loadSubscribers()
+    subs.push({
+      email: entry.data.email,
+      subscribedAt: new Date().toISOString(),
+      active: true,
+    })
+    saveSubscribers(subs)
   })
-  saveSubscribers(subs)
 
-  res.json({ ok: true, message: 'Newsletter-Abo bestätigt.' })
+  res.redirect(baseUrl + '/bestaetigung?status=success')
 })
 
 export default router

privat/CV/andreknie.de/server/routes/talk-request.js

@@ -20,18 +20,19 @@ router.post('/', talkRequestLimiter, antiSpam, async (req, res) => {
     return res.status(400).json({ errors })
   }
 
-  const token = createToken('talk-request', { name, email, event_name, topic, message }, 48)
+  const token = await createToken('talk-request', { name, email, event_name, topic, message }, 48)
   await sendConfirmationEmail(email, 'talk-request', token)
   res.status(201).json({ ok: true, message: 'Bestätigungs-E-Mail gesendet.' })
 })
 
-router.post('/confirm/:token', async (req, res) => {
-  const entry = verifyToken(req.params.token)
+router.get('/confirm/:token', async (req, res) => {
+  const baseUrl = process.env.BASE_URL || ''
+  const entry = await verifyToken(req.params.token)
   if (!entry) {
-    return res.status(410).json({ error: 'Link abgelaufen oder ungültig.' })
+    return res.redirect(baseUrl + '/bestaetigung?status=error')
   }
   await sendStakeholderNotification('talk-request', entry.data)
-  res.json({ ok: true, message: 'Vortragsanfrage wurde weitergeleitet.' })
+  res.redirect(baseUrl + '/bestaetigung?status=success')
 })
 
 export default router

privat/CV/andreknie.de/server/services/confirmationToken.js

@@ -2,10 +2,12 @@ import crypto from 'crypto'
 import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'fs'
 import { join, dirname } from 'path'
 import { fileURLToPath } from 'url'
+import { Mutex } from 'async-mutex'
 
 const __dirname = dirname(fileURLToPath(import.meta.url))
 const DATA_DIR = join(__dirname, '..', 'data')
 const TOKENS_FILE = join(DATA_DIR, 'pending-tokens.json')
+const tokenMutex = new Mutex()
 
 // Ensure data directory exists
 mkdirSync(DATA_DIR, { recursive: true })
@@ -27,18 +29,20 @@ function saveTokens(tokens) {
  * @param {number} expiresInHours - Token expiration (default: 48h)
  * @returns {string} The generated token
  */
-export function createToken(type, data, expiresInHours = 48) {
+export async function createToken(type, data, expiresInHours = 48) {
   const token = crypto.randomUUID()
-  const tokens = loadTokens()
-  tokens.push({
-    token,
-    type,
-    data,
-    createdAt: new Date().toISOString(),
-    expiresAt: new Date(Date.now() + expiresInHours * 60 * 60 * 1000).toISOString(),
-    confirmed: false,
+  await tokenMutex.runExclusive(async () => {
+    const tokens = loadTokens()
+    tokens.push({
+      token,
+      type,
+      data,
+      createdAt: new Date().toISOString(),
+      expiresAt: new Date(Date.now() + expiresInHours * 60 * 60 * 1000).toISOString(),
+      confirmed: false,
+    })
+    saveTokens(tokens)
   })
-  saveTokens(tokens)
   return token
 }
 
@@ -46,35 +50,39 @@ export function createToken(type, data, expiresInHours = 48) {
  * Verify and consume a token.
  * @returns {object|null} The stored data if valid, null if expired/invalid
  */
-export function verifyToken(token) {
-  const tokens = loadTokens()
-  const idx = tokens.findIndex(t => t.token === token && !t.confirmed)
-  if (idx === -1) return null
+export async function verifyToken(token) {
+  return await tokenMutex.runExclusive(async () => {
+    const tokens = loadTokens()
+    const idx = tokens.findIndex(t => t.token === token && !t.confirmed)
+    if (idx === -1) return null
 
-  const entry = tokens[idx]
-  if (new Date(entry.expiresAt) < new Date()) {
-    // Expired — remove it
-    tokens.splice(idx, 1)
+    const entry = tokens[idx]
+    if (new Date(entry.expiresAt) < new Date()) {
+      // Expired — remove it
+      tokens.splice(idx, 1)
+      saveTokens(tokens)
+      return null
+    }
+
+    // Mark as confirmed
+    tokens[idx].confirmed = true
     saveTokens(tokens)
-    return null
-  }
-
-  // Mark as confirmed
-  tokens[idx].confirmed = true
-  saveTokens(tokens)
-  return entry
+    return entry
+  })
 }
 
 /**
  * Clean up expired tokens (run periodically).
  */
-export function cleanupExpiredTokens() {
-  const tokens = loadTokens()
-  const now = new Date()
-  const valid = tokens.filter(t => new Date(t.expiresAt) > now || t.confirmed)
-  if (valid.length !== tokens.length) {
-    saveTokens(valid)
-  }
+export async function cleanupExpiredTokens() {
+  await tokenMutex.runExclusive(async () => {
+    const tokens = loadTokens()
+    const now = new Date()
+    const valid = tokens.filter(t => new Date(t.expiresAt) > now || t.confirmed)
+    if (valid.length !== tokens.length) {
+      saveTokens(valid)
+    }
+  })
 }
 
 // Run cleanup every hour