- Reworked the tenant admin login page

- Updated the User model to implement Filament’s tenancy contracts
- Seeded a ready-to-use demo tenant (user, tenant, active package, purchase)
- Introduced a branded, translated 403 error page to replace the generic forbidden message for unauthorised admin hits
- Removed the public “Register” links from the marketing header
- hardened join event logic and improved error handling in the guest pwa.

resources/js/guest/hooks/useEventData.ts

@@ -1,40 +1,90 @@
 import { useState, useEffect } from 'react';
 import { useParams } from 'react-router-dom';
-import { fetchEvent, EventData } from '../services/eventApi';
+import {
+  fetchEvent,
+  EventData,
+  FetchEventError,
+  FetchEventErrorCode,
+} from '../services/eventApi';
 
-export function useEventData() {
+type EventDataStatus = 'loading' | 'ready' | 'error';
+
+interface UseEventDataResult {
+  event: EventData | null;
+  status: EventDataStatus;
+  loading: boolean;
+  error: string | null;
+  errorCode: FetchEventErrorCode | null;
+  token: string | null;
+}
+
+const NO_TOKEN_ERROR_MESSAGE = 'Es wurde kein Einladungscode übergeben.';
+
+export function useEventData(): UseEventDataResult {
   const { token } = useParams<{ token: string }>();
   const [event, setEvent] = useState<EventData | null>(null);
-  const [loading, setLoading] = useState(true);
-  const [error, setError] = useState<string | null>(null);
+  const [status, setStatus] = useState<EventDataStatus>(token ? 'loading' : 'error');
+  const [errorMessage, setErrorMessage] = useState<string | null>(token ? null : NO_TOKEN_ERROR_MESSAGE);
+  const [errorCode, setErrorCode] = useState<FetchEventErrorCode | null>(token ? null : 'invalid_token');
 
   useEffect(() => {
     if (!token) {
-      setError('No event token provided');
-      setLoading(false);
+      setEvent(null);
+      setStatus('error');
+      setErrorCode('invalid_token');
+      setErrorMessage(NO_TOKEN_ERROR_MESSAGE);
       return;
     }
 
+    let cancelled = false;
+
     const loadEvent = async () => {
+      setStatus('loading');
+      setErrorCode(null);
+      setErrorMessage(null);
+
       try {
-        setLoading(true);
-        setError(null);
         const eventData = await fetchEvent(token);
+        if (cancelled) {
+          return;
+        }
+
         setEvent(eventData);
+        setStatus('ready');
       } catch (err) {
-        console.error('Failed to load event:', err);
-        setError(err instanceof Error ? err.message : 'Failed to load event');
-      } finally {
-        setLoading(false);
+        if (cancelled) {
+          return;
+        }
+
+        setEvent(null);
+        setStatus('error');
+
+        if (err instanceof FetchEventError) {
+          setErrorCode(err.code);
+          setErrorMessage(err.message);
+        } else if (err instanceof Error) {
+          setErrorCode('unknown');
+          setErrorMessage(err.message || 'Event konnte nicht geladen werden.');
+        } else {
+          setErrorCode('unknown');
+          setErrorMessage('Event konnte nicht geladen werden.');
+        }
       }
     };
 
     loadEvent();
+
+    return () => {
+      cancelled = true;
+    };
   }, [token]);
 
   return {
     event,
-    loading,
-    error,
+    status,
+    loading: status === 'loading',
+    error: errorMessage,
+    errorCode,
+    token: token ?? null,
   };
 }