v1.0.3: PDF footer fix, arrow alignment, email verification workflow, account deletion

package.json

@@ -1,6 +1,6 @@
 {
   "name": "lageplan",
-  "version": "1.0.2",
+  "version": "1.0.3",
   "description": "Feuerwehr Lageplan - Krokier-App für Einsatzdokumentation",
   "private": true,
   "scripts": {

src/app/api/auth/delete-account/route.ts

@@ -0,0 +1,65 @@
+import { NextRequest, NextResponse } from 'next/server'
+import { prisma } from '@/lib/db'
+import { getSession } from '@/lib/auth'
+import bcrypt from 'bcryptjs'
+import { cookies } from 'next/headers'
+
+// POST: User deletes their own account
+export async function POST(req: NextRequest) {
+  try {
+    const session = await getSession()
+    if (!session) return NextResponse.json({ error: 'Nicht autorisiert' }, { status: 401 })
+
+    const { password } = await req.json()
+    if (!password) {
+      return NextResponse.json({ error: 'Passwort erforderlich' }, { status: 400 })
+    }
+
+    // Verify password
+    const user = await (prisma as any).user.findUnique({
+      where: { id: session.id },
+      select: { id: true, password: true, role: true },
+    })
+    if (!user) return NextResponse.json({ error: 'Benutzer nicht gefunden' }, { status: 404 })
+
+    const validPw = await bcrypt.compare(password, user.password)
+    if (!validPw) {
+      return NextResponse.json({ error: 'Falsches Passwort' }, { status: 403 })
+    }
+
+    // If user is the only TENANT_ADMIN, they must delete the org first or transfer ownership
+    if (session.tenantId && session.role === 'TENANT_ADMIN') {
+      const adminCount = await (prisma as any).tenantMembership.count({
+        where: { tenantId: session.tenantId, role: 'TENANT_ADMIN' },
+      })
+      if (adminCount <= 1) {
+        return NextResponse.json({
+          error: 'Sie sind der einzige Administrator. Bitte löschen Sie die Organisation unter Einstellungen oder übertragen Sie die Admin-Rolle.',
+        }, { status: 400 })
+      }
+    }
+
+    console.log(`[Account Delete] User ${session.id} (${session.email}) deleting own account`)
+
+    // Clean up user data
+    try { await (prisma as any).upgradeRequest.deleteMany({ where: { requestedById: session.id } }) } catch {}
+    try { await (prisma as any).iconAsset.updateMany({ where: { ownerId: session.id }, data: { ownerId: null } }) } catch {}
+    try { await (prisma as any).project.updateMany({ where: { ownerId: session.id }, data: { ownerId: null } }) } catch {}
+
+    // Remove memberships
+    await (prisma as any).tenantMembership.deleteMany({ where: { userId: session.id } })
+
+    // Delete user
+    await (prisma as any).user.delete({ where: { id: session.id } })
+
+    // Clear auth cookie
+    ;(await cookies()).delete('auth-token')
+
+    console.log(`[Account Delete] User ${session.email} deleted successfully`)
+
+    return NextResponse.json({ success: true, message: 'Konto wurde gelöscht' })
+  } catch (error: any) {
+    console.error('[Account Delete] Error:', error?.message || error)
+    return NextResponse.json({ error: 'Löschung fehlgeschlagen' }, { status: 500 })
+  }
+}

src/app/api/auth/resend-verification/route.ts

@@ -0,0 +1,70 @@
+import { NextRequest, NextResponse } from 'next/server'
+import { prisma } from '@/lib/db'
+import { sendEmail } from '@/lib/email'
+import { randomBytes } from 'crypto'
+
+export async function POST(req: NextRequest) {
+  try {
+    const { email } = await req.json()
+
+    if (!email) {
+      return NextResponse.json({ error: 'E-Mail-Adresse erforderlich.' }, { status: 400 })
+    }
+
+    const user = await (prisma as any).user.findUnique({
+      where: { email },
+      include: { memberships: { include: { tenant: true } } },
+    })
+
+    if (!user) {
+      // Don't reveal whether user exists
+      return NextResponse.json({ success: true, message: 'Falls ein Konto mit dieser E-Mail existiert, wurde eine neue Bestätigungsmail gesendet.' })
+    }
+
+    if (user.emailVerified) {
+      return NextResponse.json({ success: true, message: 'Ihre E-Mail-Adresse ist bereits bestätigt. Sie können sich anmelden.' })
+    }
+
+    // Generate new verification token
+    const verificationToken = randomBytes(32).toString('hex')
+    await (prisma as any).user.update({
+      where: { id: user.id },
+      data: { emailVerificationToken: verificationToken },
+    })
+
+    // Build verification URL
+    let baseUrl = process.env.NEXTAUTH_URL || req.headers.get('origin') || `${req.headers.get('x-forwarded-proto') || 'https'}://${req.headers.get('host')}` || 'http://localhost:3000'
+    if (baseUrl && !baseUrl.startsWith('http://') && !baseUrl.startsWith('https://')) {
+      baseUrl = `https://${baseUrl}`
+    }
+    const verifyUrl = `${baseUrl}/api/auth/verify-email?token=${verificationToken}`
+
+    const orgName = user.memberships?.[0]?.tenant?.name || 'Lageplan'
+
+    await sendEmail(
+      user.email,
+      'E-Mail-Adresse bestätigen — Lageplan',
+      `<div style="font-family:sans-serif;max-width:600px;margin:0 auto;">
+        <div style="background:#dc2626;color:white;padding:20px 24px;border-radius:12px 12px 0 0;">
+          <h1 style="margin:0;font-size:22px;">E-Mail bestätigen</h1>
+        </div>
+        <div style="border:1px solid #e5e7eb;border-top:none;padding:24px;border-radius:0 0 12px 12px;">
+          <p>Hallo <strong>${user.name}</strong>,</p>
+          <p>Bitte bestätigen Sie Ihre E-Mail-Adresse, um Ihr Konto für <strong>${orgName}</strong> zu aktivieren.</p>
+          <div style="text-align:center;margin:24px 0;">
+            <a href="${verifyUrl}" style="background:#dc2626;color:white;padding:12px 32px;text-decoration:none;border-radius:8px;font-weight:600;display:inline-block;">
+              E-Mail bestätigen
+            </a>
+          </div>
+          <p style="color:#666;font-size:13px;">Falls der Button nicht funktioniert, kopieren Sie diesen Link:<br/>
+          <a href="${verifyUrl}" style="word-break:break-all;">${verifyUrl}</a></p>
+        </div>
+      </div>`
+    )
+
+    return NextResponse.json({ success: true, message: 'Bestätigungsmail wurde erneut gesendet. Bitte prüfen Sie Ihren Posteingang.' })
+  } catch (error) {
+    console.error('Resend verification error:', error)
+    return NextResponse.json({ error: 'Fehler beim Senden der Bestätigungsmail.' }, { status: 500 })
+  }
+}

src/app/app/page.tsx

@@ -19,7 +19,7 @@ import { Button } from '@/components/ui/button'
 import { Dialog, DialogContent, DialogHeader, DialogTitle } from '@/components/ui/dialog'
 import { JournalView } from '@/components/journal/journal-view'
 import { jsPDF } from 'jspdf'
-import { Lock, Unlock, Eye } from 'lucide-react'
+import { Lock, Unlock, Eye, AlertTriangle } from 'lucide-react'
 import { getSocket } from '@/lib/socket'
 import { CustomDragLayer } from '@/components/map/custom-drag-layer'
 
@@ -102,88 +102,217 @@ export default function AppPage() {
     sessionIdRef.current = `${Date.now()}-${Math.random().toString(36).slice(2, 10)}`
   }
 
-  // Capture map screenshot when switching to journal tab (including HTML symbol markers)
+  // Capture map screenshot when switching to journal tab (coordinate-based rendering)
   const handleTabChange = useCallback(async (tab: 'map' | 'journal') => {
     if (tab === 'journal' && mapRef.current) {
       try {
-        const mapCanvas = mapRef.current.getCanvas()
+        const mapInstance = mapRef.current
-        if (mapCanvas) {
+        const mapCanvas = mapInstance.getCanvas() as HTMLCanvasElement
+        if (mapCanvas && mapCanvas.width > 0) {
           const offscreen = document.createElement('canvas')
           offscreen.width = mapCanvas.width
           offscreen.height = mapCanvas.height
           const ctx = offscreen.getContext('2d')
           if (ctx) {
             ctx.drawImage(mapCanvas, 0, 0)
-            const dpr = window.devicePixelRatio || 1
-            const mapContainer = mapRef.current.getContainer()
-            const mapRect = mapContainer.getBoundingClientRect()
 
-            // Collect all symbol images and preload them (async for URL-based images)
+            const container = mapInstance.getContainer()
-            const symbolEntries: { img: HTMLImageElement; x: number; y: number; w: number; h: number; rotation: number }[] = []
+            const dpr = mapCanvas.width / container.offsetWidth
-            const loadPromises: Promise<void>[] = []
+            const currentZoom = mapInstance.getZoom()
+            const currentFeatures = featuresRef.current
 
-            document.querySelectorAll<HTMLElement>('.symbol-marker-wrapper').forEach(wrapper => {
+            // Helper: haversine distance
-              const rect = wrapper.getBoundingClientRect()
+            const haversine = (a: number[], b: number[]): number => {
-              const inner = wrapper.querySelector<HTMLElement>('.symbol-marker')
+              const R = 6371000, toRad = Math.PI / 180
-              if (!inner) return
+              const dLat = (b[1] - a[1]) * toRad, dLng = (b[0] - a[0]) * toRad
-              const bgImage = inner.style.backgroundImage
+              const x = Math.sin(dLat / 2) ** 2 + Math.cos(a[1] * toRad) * Math.cos(b[1] * toRad) * Math.sin(dLng / 2) ** 2
-              const urlMatch = bgImage.match(/url\("?(.+?)"?\)/)
+              return R * 2 * Math.atan2(Math.sqrt(x), Math.sqrt(1 - x))
-              if (!urlMatch) return
-              const imgSrc = urlMatch[1]
-              const img = new Image()
-              img.crossOrigin = 'anonymous'
-              img.src = imgSrc
-              const entry = {
-                img,
-                x: (rect.left - mapRect.left) * dpr,
-                y: (rect.top - mapRect.top) * dpr,
-                w: rect.width * dpr,
-                h: rect.height * dpr,
-                rotation: parseFloat(inner.style.transform?.match(/rotate\((.+?)deg\)/)?.[1] || '0'),
-              }
-              symbolEntries.push(entry)
-              if (!img.complete) {
-                loadPromises.push(new Promise<void>((resolve) => {
-                  img.onload = () => resolve()
-                  img.onerror = () => resolve()
-                }))
-              }
-            })
-
-            // Wait for all symbol images to load (max 3s timeout)
-            if (loadPromises.length > 0) {
-              await Promise.race([
-                Promise.all(loadPromises),
-                new Promise(r => setTimeout(r, 3000)),
-              ])
             }
 
-            // Draw all symbol markers
+            // Helper: load image as promise
-            symbolEntries.forEach(({ img, x, y, w, h, rotation }) => {
+            const loadImage = (src: string): Promise<HTMLImageElement> => new Promise((resolve, reject) => {
-              if (img.complete && img.naturalWidth > 0) {
+              const img = new Image()
-                ctx.save()
+              img.crossOrigin = 'anonymous'
-                ctx.translate(x + w / 2, y + h / 2)
+              img.onload = () => resolve(img)
-                if (rotation) ctx.rotate((rotation * Math.PI) / 180)
+              img.onerror = reject
-                ctx.drawImage(img, -w / 2, -h / 2, w, h)
+              img.src = src
-                ctx.restore()
-              }
             })
 
-            // Draw text markers
+            // 1. Draw symbol features (coordinate-based)
-            document.querySelectorAll<HTMLElement>('.text-marker').forEach(el => {
+            for (const f of currentFeatures.filter(f => f.type === 'symbol')) {
-              const rect = el.getBoundingClientRect()
+              if (f.geometry.type !== 'Point') continue
-              const x = (rect.left - mapRect.left) * dpr
+              const coords = f.geometry.coordinates as [number, number]
-              const y = (rect.top - mapRect.top) * dpr
+              const pixel = mapInstance.project(coords)
-              const text = el.textContent || ''
+              const px = pixel.x * dpr
-              const fontSize = parseFloat(el.style.fontSize || '14') * dpr
+              const py = pixel.y * dpr
-              const color = el.style.color || '#000'
+              const scale = (f.properties.scale as number) || 1
+              const rotation = (f.properties.rotation as number) || 0
+              const baseSize = 32
+              const placementZoom = (f.properties.placementZoom as number) || 17
+              const zoomFactor = Math.pow(2, currentZoom - placementZoom)
+              const size = Math.max(8, Math.min(400, baseSize * scale * zoomFactor)) * dpr
+
+              const iconId = f.properties.iconId as string
+              const imageUrl = f.properties.imageUrl as string
+              let imgSrc = imageUrl || ''
+              if (!imgSrc && iconId) {
+                const { getSymbolById, getSymbolDataUri } = await import('@/lib/fw-symbols')
+                const sym = getSymbolById(iconId)
+                if (sym) imgSrc = getSymbolDataUri(sym)
+              }
+              if (imgSrc) {
+                try {
+                  const img = await loadImage(imgSrc)
+                  const imgAspect = img.naturalWidth / img.naturalHeight
+                  let drawW = size, drawH = size
+                  if (imgAspect > 1) drawH = size / imgAspect
+                  else drawW = size * imgAspect
+                  ctx.save()
+                  ctx.translate(px, py)
+                  ctx.rotate((rotation * Math.PI) / 180)
+                  ctx.drawImage(img, -drawW / 2, -drawH / 2, drawW, drawH)
+                  ctx.restore()
+                } catch {}
+              }
+            }
+
+            // 2. Draw arrowheads for arrow features
+            for (const f of currentFeatures.filter(f => f.type === 'arrow')) {
+              if (f.geometry.type !== 'LineString') continue
+              const lineCoords = f.geometry.coordinates as number[][]
+              if (lineCoords.length < 2) continue
+              const p1 = lineCoords[lineCoords.length - 2]
+              const p2 = lineCoords[lineCoords.length - 1]
+              const px1 = mapInstance.project(p1 as [number, number])
+              const px2 = mapInstance.project(p2 as [number, number])
+              const angle = Math.atan2(px2.y - px1.y, px2.x - px1.x)
+              const color = (f.properties.color as string) || '#000000'
+              const arrowSize = 14 * dpr
+
               ctx.save()
-              ctx.font = `bold ${fontSize}px sans-serif`
+              ctx.translate(px2.x * dpr, px2.y * dpr)
+              ctx.rotate(angle + Math.PI / 2)
+              ctx.beginPath()
+              ctx.moveTo(0, -arrowSize)
+              ctx.lineTo(-arrowSize * 0.7, arrowSize * 0.3)
+              ctx.lineTo(arrowSize * 0.7, arrowSize * 0.3)
+              ctx.closePath()
               ctx.fillStyle = color
-              ctx.textBaseline = 'top'
+              ctx.fill()
-              ctx.fillText(text, x, y)
               ctx.restore()
-            })
+            }
+
+            // 3. Draw line/polygon labels at midpoints
+            for (const f of currentFeatures.filter(f => f.properties.label && (f.geometry.type === 'LineString' || f.geometry.type === 'Polygon'))) {
+              const label = f.properties.label as string
+              let midpoint: [number, number]
+
+              if (f.geometry.type === 'LineString') {
+                const coords = f.geometry.coordinates as number[][]
+                const midIdx = Math.floor(coords.length / 2)
+                if (coords.length === 2) {
+                  midpoint = [(coords[0][0] + coords[1][0]) / 2, (coords[0][1] + coords[1][1]) / 2]
+                } else {
+                  midpoint = coords[midIdx] as [number, number]
+                }
+              } else {
+                const ring = (f.geometry.coordinates as number[][][])[0]
+                const len = ring.length - 1
+                let cx = 0, cy = 0
+                for (let i = 0; i < len; i++) { cx += ring[i][0]; cy += ring[i][1] }
+                midpoint = [cx / len, cy / len]
+              }
+
+              const pixel = mapInstance.project(midpoint)
+              const px = pixel.x * dpr
+              const py = pixel.y * dpr
+              const isDanger = f.type === 'dangerzone'
+              const bgColor = isDanger ? 'rgba(220,38,38,0.85)' : 'rgba(0,0,0,0.75)'
+              const borderColor = isDanger ? '#dc2626' : 'rgba(255,255,255,0.5)'
+
+              // Build label text with line info
+              let displayText = label
+              let infoText = ''
+              if (f.geometry.type === 'LineString') {
+                const lineCoords = f.geometry.coordinates as number[][]
+                let totalLen = 0
+                for (let i = 1; i < lineCoords.length; i++) {
+                  totalLen += haversine(lineCoords[i - 1], lineCoords[i])
+                }
+                const hoseCount = Math.ceil(totalLen / 20)
+                const lenText = totalLen < 1000 ? `${Math.round(totalLen)}m` : `${(totalLen / 1000).toFixed(2)}km`
+                infoText = `${lenText} / ${hoseCount} Schl.`
+              }
+
+              const fontSize1 = 11 * dpr
+              const fontSize2 = 8 * dpr
+              const padX = 6 * dpr
+              const padY = 3 * dpr
+
+              ctx.save()
+              ctx.font = `bold ${fontSize1}px system-ui, sans-serif`
+              const w1 = ctx.measureText(displayText).width
+              let w2 = 0
+              if (infoText) {
+                ctx.font = `${fontSize2}px system-ui, sans-serif`
+                w2 = ctx.measureText(infoText).width
+              }
+              const boxW = Math.max(w1, w2) + padX * 2
+              const boxH = fontSize1 + (infoText ? fontSize2 + 2 * dpr : 0) + padY * 2
+              const radius = 3 * dpr
+
+              // Background
+              ctx.fillStyle = bgColor
+              ctx.beginPath()
+              ctx.roundRect(px - boxW / 2, py - boxH / 2, boxW, boxH, radius)
+              ctx.fill()
+              // Border
+              ctx.strokeStyle = borderColor
+              ctx.lineWidth = 1 * dpr
+              ctx.beginPath()
+              ctx.roundRect(px - boxW / 2, py - boxH / 2, boxW, boxH, radius)
+              ctx.stroke()
+              // Label text
+              ctx.fillStyle = '#ffffff'
+              ctx.font = `bold ${fontSize1}px system-ui, sans-serif`
+              ctx.textAlign = 'center'
+              ctx.textBaseline = 'middle'
+              const textY = infoText ? py - fontSize2 / 2 : py
+              ctx.fillText(displayText, px, textY)
+              // Info text
+              if (infoText) {
+                ctx.font = `${fontSize2}px system-ui, sans-serif`
+                ctx.globalAlpha = 0.8
+                ctx.fillText(infoText, px, py + fontSize1 / 2 + 1 * dpr)
+                ctx.globalAlpha = 1
+              }
+              ctx.restore()
+            }
+
+            // 4. Draw text features
+            for (const f of currentFeatures.filter(f => f.type === 'text')) {
+              if (f.geometry.type !== 'Point') continue
+              const coords = f.geometry.coordinates as [number, number]
+              const pixel = mapInstance.project(coords)
+              const px = pixel.x * dpr
+              const py = pixel.y * dpr
+              const text = (f.properties.text as string) || ''
+              const fontSize = ((f.properties.fontSize as number) || 14) * dpr
+              const color = (f.properties.color as string) || '#000000'
+
+              ctx.save()
+              ctx.font = `bold ${fontSize}px system-ui, sans-serif`
+              ctx.textAlign = 'center'
+              ctx.textBaseline = 'middle'
+              ctx.strokeStyle = '#ffffff'
+              ctx.lineWidth = 3 * dpr
+              ctx.lineJoin = 'round'
+              ctx.strokeText(text, px, py)
+              ctx.fillStyle = color
+              ctx.fillText(text, px, py)
+              ctx.restore()
+            }
+
             setLastMapScreenshot(offscreen.toDataURL('image/png'))
           } else {
             setLastMapScreenshot(mapCanvas.toDataURL('image/png'))
@@ -1001,6 +1130,32 @@ export default function AppPage() {
         }
       }
 
+      // Draw arrowheads for arrow features
+      for (const f of currentFeatures.filter(f => f.type === 'arrow')) {
+        if (f.geometry.type !== 'LineString') continue
+        const lineCoords = f.geometry.coordinates as number[][]
+        if (lineCoords.length < 2) continue
+        const p1 = lineCoords[lineCoords.length - 2]
+        const p2 = lineCoords[lineCoords.length - 1]
+        const px1 = mapInstance.project(p1 as [number, number])
+        const px2 = mapInstance.project(p2 as [number, number])
+        const angle = Math.atan2(px2.y - px1.y, px2.x - px1.x)
+        const color = (f.properties.color as string) || '#000000'
+        const arrowSize = 14 * dpr
+
+        ctx.save()
+        ctx.translate(px2.x * dpr, px2.y * dpr)
+        ctx.rotate(angle + Math.PI / 2)
+        ctx.beginPath()
+        ctx.moveTo(0, -arrowSize)
+        ctx.lineTo(-arrowSize * 0.7, arrowSize * 0.3)
+        ctx.lineTo(arrowSize * 0.7, arrowSize * 0.3)
+        ctx.closePath()
+        ctx.fillStyle = color
+        ctx.fill()
+        ctx.restore()
+      }
+
       // Draw line/polygon label markers at midpoints
       for (const f of currentFeatures.filter(f => f.properties.label && (f.geometry.type === 'LineString' || f.geometry.type === 'Polygon'))) {
         const label = f.properties.label as string
@@ -1234,6 +1389,29 @@ export default function AppPage() {
           onLogout={logout}
         />
 
+        {/* Email verification banner */}
+        {user && user.emailVerified === false && (
+          <div className="flex items-center justify-center gap-3 px-4 py-2 bg-amber-50 dark:bg-amber-950/40 border-b border-amber-200 dark:border-amber-800 text-sm text-amber-800 dark:text-amber-300">
+            <AlertTriangle className="w-4 h-4 shrink-0" />
+            <span>Ihre E-Mail-Adresse wurde noch nicht bestätigt. Bitte prüfen Sie Ihren Posteingang.</span>
+            <button
+              onClick={async () => {
+                try {
+                  const res = await fetch('/api/auth/resend-verification', {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify({ email: user.email }),
+                  })
+                  if (res.ok) toast({ title: 'Bestätigungsmail gesendet', description: 'Bitte prüfen Sie Ihren Posteingang.' })
+                  else toast({ title: 'Fehler', description: 'Konnte Bestätigungsmail nicht senden.', variant: 'destructive' })
+                } catch { toast({ title: 'Fehler', description: 'Verbindungsfehler.', variant: 'destructive' }) }
+              }}
+              className="shrink-0 text-xs font-semibold underline hover:no-underline text-amber-700 dark:text-amber-400"
+            >
+              Erneut senden
+            </button>
+          </div>
+        )}
 
         {/* Live editing banner */}
         {currentProject && (

src/app/login/page.tsx

@@ -23,6 +23,8 @@ function LoginForm() {
   const [email, setEmail] = useState('')
   const [password, setPassword] = useState('')
   const [isLoading, setIsLoading] = useState(false)
+  const [resendLoading, setResendLoading] = useState(false)
+  const [resendSuccess, setResendSuccess] = useState(false)
   const [tenantLogo, setTenantLogo] = useState<string | null>(null)
   const [tenantName, setTenantName] = useState<string | null>(null)
   const { login } = useAuth()
@@ -110,7 +112,32 @@ function LoginForm() {
           )}
           {errorParam === 'invalid-token' && (
             <div className="bg-red-50 dark:bg-red-950/30 border border-red-200 dark:border-red-800 rounded-lg p-3 mb-4 text-sm text-red-700 dark:text-red-400 text-center">
-              Ungültiger oder abgelaufener Bestätigungslink.
+              <p>Ungültiger oder abgelaufener Bestätigungslink.</p>
+              <p className="mt-1 text-xs">Geben Sie Ihre E-Mail ein und klicken Sie unten, um einen neuen Link zu erhalten.</p>
+              {resendSuccess ? (
+                <p className="mt-2 text-green-600 dark:text-green-400 font-medium">Neue Bestätigungsmail gesendet!</p>
+              ) : (
+                <button
+                  type="button"
+                  disabled={resendLoading || !email}
+                  onClick={async () => {
+                    setResendLoading(true)
+                    try {
+                      const res = await fetch('/api/auth/resend-verification', {
+                        method: 'POST',
+                        headers: { 'Content-Type': 'application/json' },
+                        body: JSON.stringify({ email }),
+                      })
+                      if (res.ok) setResendSuccess(true)
+                      else toast({ title: 'Fehler', description: 'Konnte Bestätigungsmail nicht senden.', variant: 'destructive' })
+                    } catch { toast({ title: 'Fehler', description: 'Verbindungsfehler.', variant: 'destructive' }) }
+                    setResendLoading(false)
+                  }}
+                  className="mt-2 text-xs font-medium text-red-600 dark:text-red-400 underline hover:no-underline disabled:opacity-50"
+                >
+                  {resendLoading ? 'Wird gesendet...' : 'Bestätigungsmail erneut senden'}
+                </button>
+              )}
             </div>
           )}
 

src/components/journal/journal-view.tsx

@@ -1030,8 +1030,8 @@ export function JournalView({ projectId, projectTitle, projectLocation, einsatzl
                         if (mapRef?.current) {
                           const canvas = mapRef.current.getCanvas()
                           if (canvas) {
-                            // Resize to max 1600px wide and convert to JPEG
+                            // Resize to max 2400px wide and convert to JPEG
-                            const maxW = 1600
+                            const maxW = 2400
                             const ratio = Math.min(1, maxW / canvas.width)
                             const offscreen = document.createElement('canvas')
                             offscreen.width = Math.round(canvas.width * ratio)
@@ -1039,18 +1039,18 @@ export function JournalView({ projectId, projectTitle, projectLocation, einsatzl
                             const ctx = offscreen.getContext('2d')
                             if (ctx) {
                               ctx.drawImage(canvas, 0, 0, offscreen.width, offscreen.height)
-                              mapScreenshot = offscreen.toDataURL('image/jpeg', 0.75)
+                              mapScreenshot = offscreen.toDataURL('image/jpeg', 0.85)
                             }
                           }
                         }
                       } catch (e) { console.warn('Map screenshot failed:', e) }
-                    } else if (rawScreenshot.length > 500000) {
+                    } else if (rawScreenshot.length > 800000) {
                       // Compress pre-captured screenshot if too large
                       try {
                         const img = new Image()
                         img.src = rawScreenshot
                         await new Promise(r => { img.onload = r; img.onerror = r })
-                        const maxW = 1600
+                        const maxW = 2400
                         const ratio = Math.min(1, maxW / img.naturalWidth)
                         const offscreen = document.createElement('canvas')
                         offscreen.width = Math.round(img.naturalWidth * ratio)
@@ -1058,7 +1058,7 @@ export function JournalView({ projectId, projectTitle, projectLocation, einsatzl
                         const ctx = offscreen.getContext('2d')
                         if (ctx) {
                           ctx.drawImage(img, 0, 0, offscreen.width, offscreen.height)
-                          mapScreenshot = offscreen.toDataURL('image/jpeg', 0.75)
+                          mapScreenshot = offscreen.toDataURL('image/jpeg', 0.85)
                         }
                       } catch { mapScreenshot = rawScreenshot }
                     } else {

src/components/layout/topbar.tsx

@@ -91,6 +91,10 @@ export function Topbar({
   const [isLoadDialogOpen, setIsLoadDialogOpen] = useState(false)
   const [isHoseSettingsOpen, setIsHoseSettingsOpen] = useState(false)
   const [showPasswordDialog, setShowPasswordDialog] = useState(false)
+  const [showDeleteAccountDialog, setShowDeleteAccountDialog] = useState(false)
+  const [deleteAccountPw, setDeleteAccountPw] = useState('')
+  const [deleteAccountLoading, setDeleteAccountLoading] = useState(false)
+  const [deleteAccountError, setDeleteAccountError] = useState('')
   const [pwOld, setPwOld] = useState('')
   const [pwNew, setPwNew] = useState('')
   const [pwConfirm, setPwConfirm] = useState('')
@@ -290,6 +294,13 @@ export function Topbar({
                     Administration
                   </DropdownMenuItem>
                 )}
+                <DropdownMenuItem
+                  onClick={() => { setShowDeleteAccountDialog(true); setDeleteAccountPw(''); setDeleteAccountError('') }}
+                  className="text-destructive focus:text-destructive"
+                >
+                  <Trash2 className="w-4 h-4 mr-2" />
+                  Konto löschen
+                </DropdownMenuItem>
                 <DropdownMenuItem onClick={onLogout} className="text-destructive focus:text-destructive">
                   <LogOut className="w-4 h-4 mr-2" />
                   Abmelden
@@ -539,6 +550,81 @@ export function Topbar({
           </div>
         </DialogContent>
       </Dialog>
+
+      {/* Delete Account Dialog */}
+      <Dialog open={showDeleteAccountDialog} onOpenChange={setShowDeleteAccountDialog}>
+        <DialogContent className="max-w-sm">
+          <DialogHeader>
+            <DialogTitle className="flex items-center gap-2 text-destructive">
+              <AlertTriangle className="w-5 h-5" />
+              Konto löschen
+            </DialogTitle>
+          </DialogHeader>
+          <div className="space-y-4">
+            <p className="text-sm text-muted-foreground">
+              Ihr Konto wird unwiderruflich gelöscht. Ihre Projekte und Daten bleiben der Organisation erhalten,
+              aber Ihr persönlicher Zugang wird entfernt.
+            </p>
+            {userRole === 'TENANT_ADMIN' && (
+              <div className="bg-amber-50 dark:bg-amber-950/30 rounded-lg p-3 text-xs text-amber-800 dark:text-amber-300 border border-amber-200 dark:border-amber-800">
+                <strong>Hinweis:</strong> Als einziger Administrator müssen Sie zuerst die Organisation unter Einstellungen löschen oder die Admin-Rolle übertragen.
+              </div>
+            )}
+            <div className="space-y-1.5">
+              <label className="text-sm font-medium">Passwort zur Bestätigung</label>
+              <input
+                type="password"
+                value={deleteAccountPw}
+                onChange={(e) => { setDeleteAccountPw(e.target.value); setDeleteAccountError('') }}
+                placeholder="Ihr Passwort"
+                className="w-full rounded-md border border-input bg-background px-3 py-2 text-sm"
+                autoComplete="current-password"
+              />
+            </div>
+            {deleteAccountError && (
+              <p className="text-sm text-destructive">{deleteAccountError}</p>
+            )}
+            <div className="flex gap-2 justify-end">
+              <Button
+                variant="outline"
+                size="sm"
+                onClick={() => setShowDeleteAccountDialog(false)}
+                disabled={deleteAccountLoading}
+              >
+                Abbrechen
+              </Button>
+              <Button
+                variant="destructive"
+                size="sm"
+                disabled={deleteAccountLoading || !deleteAccountPw}
+                onClick={async () => {
+                  setDeleteAccountLoading(true)
+                  setDeleteAccountError('')
+                  try {
+                    const res = await fetch('/api/auth/delete-account', {
+                      method: 'POST',
+                      headers: { 'Content-Type': 'application/json' },
+                      body: JSON.stringify({ password: deleteAccountPw }),
+                    })
+                    const data = await res.json()
+                    if (res.ok) {
+                      window.location.href = '/'
+                    } else {
+                      setDeleteAccountError(data.error || 'Löschung fehlgeschlagen')
+                    }
+                  } catch {
+                    setDeleteAccountError('Verbindungsfehler')
+                  } finally {
+                    setDeleteAccountLoading(false)
+                  }
+                }}
+              >
+                {deleteAccountLoading ? 'Wird gelöscht...' : 'Konto endgültig löschen'}
+              </Button>
+            </div>
+          </div>
+        </DialogContent>
+      </Dialog>
     </header>
   )
 }

src/components/map/map-view.tsx

@@ -1377,12 +1377,12 @@ export function MapView({
           const lineCoords = f.geometry.coordinates as number[][]
           if (lineCoords.length < 2) return
 
-          // Get last two points to calculate arrow direction
+          // Get last two points to calculate arrow direction using screen-projected coords
           const p1 = lineCoords[lineCoords.length - 2]
           const p2 = lineCoords[lineCoords.length - 1]
-          const angle = Math.atan2(p2[1] - p1[1], p2[0] - p1[0]) * (180 / Math.PI)
+          const px1 = map.current.project(p1 as [number, number])
-          // MapLibre uses screen coords where Y is inverted, so negate the angle
+          const px2 = map.current.project(p2 as [number, number])
-          const screenAngle = -angle + 90
+          const screenAngle = Math.atan2(px2.y - px1.y, px2.x - px1.x) * (180 / Math.PI) + 90
 
           const color = (f.properties.color as string) || '#000000'
           const arrowEl = document.createElement('div')

src/components/providers/auth-provider.tsx

@@ -9,6 +9,7 @@ export interface User {
   role: 'SERVER_ADMIN' | 'TENANT_ADMIN' | 'OPERATOR' | 'VIEWER'
   tenantId?: string
   tenantSlug?: string
+  emailVerified?: boolean
 }
 
 export interface TenantInfo {

src/lib/auth.ts

@@ -18,6 +18,7 @@ export interface UserPayload {
   role: 'SERVER_ADMIN' | 'TENANT_ADMIN' | 'OPERATOR' | 'VIEWER'
   tenantId?: string
   tenantSlug?: string
+  emailVerified?: boolean
 }
 
 export async function createToken(user: UserPayload): Promise<string> {
@@ -71,10 +72,8 @@ export async function login(
     return { success: false, error: 'Ungültiges Passwort' }
   }
 
-  // Check email verification (skip for SERVER_ADMIN and users created before verification was added)
+  // Track email verification status (allow login regardless)
-  if ((user as any).emailVerified === false && (user.role as string) !== 'SERVER_ADMIN') {
+  const emailVerified = (user as any).emailVerified !== false
-    return { success: false, error: 'Bitte bestätigen Sie zuerst Ihre E-Mail-Adresse. Prüfen Sie Ihren Posteingang.' }
-  }
 
   // Get first tenant membership for non-server-admins
   let tenantId: string | undefined
@@ -102,6 +101,7 @@ export async function login(
     role: (user.role === 'ADMIN' ? 'SERVER_ADMIN' : user.role) as UserPayload['role'],
     tenantId,
     tenantSlug,
+    emailVerified,
   }
 
   return { success: true, user: userPayload }

src/lib/rapport-pdf.tsx

@@ -4,7 +4,7 @@ import { Document, Page, Text, View, StyleSheet, Font, Image } from '@react-pdf/
 // Register default font (Helvetica is built-in)
 const styles = StyleSheet.create({
   page: {
-    padding: '12mm 15mm 15mm',
+    padding: '12mm 15mm 32mm',
     fontFamily: 'Helvetica',
     fontSize: 10,
     lineHeight: 1.4,