> ## Documentation Index
> Fetch the complete documentation index at: https://kawax.biz/llms.txt
> Use this file to discover all available pages before exploring further.

# Notifications

> Wie Sie das Notification-System von Laravel nutzen, um Nachrichten über mehrere Kanäle wie E-Mail, Datenbank oder Slack gleichzeitig zu versenden.

## Was sind Notifications

Das Notification-System von Laravel bietet eine einheitliche API, um Benachrichtigungen über verschiedene Kanäle wie E-Mail, SMS, Slack oder Datenbank zu versenden.

**Unterschied zwischen Mail und Notification**

| Vergleich     | Mail                      | Notification                         |
| ------------- | ------------------------- | ------------------------------------ |
| Hauptzweck    | Reichhaltige HTML-E-Mails | Kurze Informationsbenachrichtigungen |
| Versandkanäle | Nur E-Mail                | E-Mail, DB, Slack, SMS und mehr      |
| Templates     | Vollkommen frei           | Einfaches Nachrichtenformat          |

Wenn Sie ein und dieselbe Benachrichtigung – etwa die Bestätigung einer bezahlten Rechnung – über mehrere Kanäle senden möchten, sind Notifications die bessere Wahl.

## Eine Notification-Klasse erstellen

Erstellen Sie die Klasse mit dem Artisan-Befehl `make:notification`.

```shell theme={null}
php artisan make:notification InvoicePaid
```

Die generierte Klasse liegt im Verzeichnis `app/Notifications/`. Sie enthält die Methode `via()` sowie Methoden zur Nachrichtengenerierung für die einzelnen Kanäle.

## Notifications versenden

### Mit dem `Notifiable`-Trait

`App\Models\User` bindet standardmäßig das Trait `Notifiable` ein. Mit der Methode `notify()` senden Sie eine Benachrichtigung.

```php theme={null}
use App\Notifications\InvoicePaid;

$user->notify(new InvoicePaid($invoice));
```

<Info>
  Das Trait `Notifiable` ist nicht auf das `User`-Modell beschränkt – Sie können es jedem beliebigen Modell hinzufügen.
</Info>

### Mit der Notification-Fassade

Um mehrere Benutzer gleichzeitig zu benachrichtigen, verwenden Sie die Fassade `Notification`.

```php theme={null}
use Illuminate\Support\Facades\Notification;

Notification::send($users, new InvoicePaid($invoice));
```

Um sofort zu senden (und die Queue zu umgehen), verwenden Sie `sendNow()`.

```php theme={null}
Notification::sendNow($developers, new DeploymentCompleted($deployment));
```

## Kanäle festlegen

Die Methode `via()` liefert die zu verwendenden Kanäle als Array zurück.

```mermaid theme={null}
flowchart TD
    A["$user->notify(new InvoicePaid())"] --> B["Kanäle über via()<br>festlegen"]
    B --> C{"Kanalauswahl"}
    C --> D["mail<br>toMail()"]
    C --> E["database<br>toArray()"]
    C --> F["broadcast<br>toBroadcast()"]
    C --> G["vonage<br>toVonage()"]
    C --> H["slack<br>toSlack()"]
```

```php theme={null}
public function via(object $notifiable): array
{
    return ['mail', 'database'];
}
```

Sie können die Kanäle auch abhängig von den Präferenzen des Benutzers wechseln.

```php theme={null}
public function via(object $notifiable): array
{
    return $notifiable->prefers_sms ? ['vonage'] : ['mail', 'database'];
}
```

Die wichtigsten verfügbaren Kanäle:

| Kanal     | Schlüssel   | Beschreibung                               |
| --------- | ----------- | ------------------------------------------ |
| E-Mail    | `mail`      | Benachrichtigung per E-Mail                |
| Datenbank | `database`  | In der DB speichern und in der UI anzeigen |
| Broadcast | `broadcast` | Echtzeit-Benachrichtigung (WebSocket)      |
| SMS       | `vonage`    | SMS-Versand über Vonage (ehem. Nexmo)      |
| Slack     | `slack`     | Nachricht in einem Slack-Kanal posten      |

## Benachrichtigungen per E-Mail-Kanal

In der Methode `toMail()` geben Sie eine `MailMessage`-Instanz zurück.

```php theme={null}
use Illuminate\Notifications\Messages\MailMessage;

public function toMail(object $notifiable): MailMessage
{
    $url = url('/invoice/'.$this->invoice->id);

    return (new MailMessage)
        ->greeting('Hallo!')
        ->line('Wir haben den Zahlungseingang für Ihre Rechnung bestätigt.')
        ->action('Rechnung ansehen', $url)
        ->line('Vielen Dank für Ihre Nutzung.');
}
```

Die wichtigsten Methoden von `MailMessage`:

| Methode      | Beschreibung           |
| ------------ | ---------------------- |
| `greeting()` | Begrüßung am Anfang    |
| `line()`     | Eine Zeile Fließtext   |
| `action()`   | Button-Link            |
| `subject()`  | Betreff                |
| `from()`     | Absenderadresse        |
| `mailer()`   | Zu verwendender Mailer |

Wenn Sie über einen Fehler informieren, färbt die Methode `error()` den Button rot.

```php theme={null}
return (new MailMessage)
    ->error()
    ->subject('Die Zahlung ist fehlgeschlagen')
    ->line('Die Verarbeitung Ihrer Rechnungszahlung ist fehlgeschlagen.');
```

### Markdown-Benachrichtigungs-E-Mails

Sie können auch reichhaltige E-Mails im Markdown-Format nutzen. Erzeugen Sie die Klasse mit der Option `--markdown`.

```shell theme={null}
php artisan make:notification InvoicePaid --markdown=mail.invoice.paid
```

Statt `toMail()` verwenden Sie `toMarkdownMail()` – bzw. `markdown()` in der Message.

```php theme={null}
use Illuminate\Notifications\Messages\MailMessage;

public function toMail(object $notifiable): MailMessage
{
    return (new MailMessage)
        ->markdown('mail.invoice.paid', [
            'url' => url('/invoice/'.$this->invoice->id),
            'invoice' => $this->invoice,
        ]);
}
```

## Benachrichtigungen per Datenbank-Kanal

Über den Datenbank-Kanal speichern Sie Benachrichtigungen in der DB und können sie in der UI Ihrer Anwendung anzeigen.

### Tabelle vorbereiten

Legen Sie zunächst die Tabelle `notifications` an.

```shell theme={null}
php artisan make:notifications-table

php artisan migrate
```

### Methode `toArray` definieren

In der Methode `toArray()` geben Sie die zu speichernden Daten als Array zurück.

```php theme={null}
public function toArray(object $notifiable): array
{
    return [
        'invoice_id' => $this->invoice->id,
        'amount' => $this->invoice->amount,
        'message' => 'Wir haben den Zahlungseingang für Ihre Rechnung bestätigt.',
    ];
}
```

Diese Daten werden in der Spalte `data` der Tabelle `notifications` im JSON-Format abgelegt.

### Benachrichtigungen abrufen

Über die vom `Notifiable`-Trait bereitgestellte Beziehung `notifications` rufen Sie die Benachrichtigungen ab.

```php theme={null}
$user = App\Models\User::find(1);

foreach ($user->notifications as $notification) {
    echo $notification->type;
    echo $notification->data['message'];
}
```

Nur ungelesene Benachrichtigungen erhalten Sie über `unreadNotifications`.

```php theme={null}
foreach ($user->unreadNotifications as $notification) {
    echo $notification->data['message'];
}
```

### Als gelesen markieren

Mit `markAsRead()` markieren Sie eine Benachrichtigung als gelesen.

```php theme={null}
// Einzeln als gelesen markieren
foreach ($user->unreadNotifications as $notification) {
    $notification->markAsRead();
}

// Alle auf einmal als gelesen markieren
$user->unreadNotifications->markAsRead();

// Per Query gesammelt aktualisieren
$user->unreadNotifications()->update(['read_at' => now()]);
```

## Notifications über Queues verarbeiten

Wenn der Versand länger dauert, implementieren Sie das Interface `ShouldQueue` und das Trait `Queueable`, um die Verarbeitung in eine Queue auszulagern. Bei mit `make:notification` erzeugten Klassen sind sie bereits importiert.

```php theme={null}
<?php

namespace App\Notifications;

use Illuminate\Bus\Queueable;
use Illuminate\Contracts\Queue\ShouldQueue;
use Illuminate\Notifications\Notification;

class InvoicePaid extends Notification implements ShouldQueue
{
    use Queueable;

    // ...
}
```

Sobald `ShouldQueue` implementiert ist, wandert die Benachrichtigung schon beim Aufruf von `notify()` automatisch in die Queue.

```php theme={null}
$user->notify(new InvoicePaid($invoice));
```

Auch ein verzögerter Versand ist möglich.

```php theme={null}
$user->notify(
    (new InvoicePaid($invoice))->delay(now()->plus(minutes: 10))
);
```

## Gleichzeitiger Versand über mehrere Kanäle

Wenn `via()` mehrere Kanäle zurückgibt und Sie die jeweiligen Methoden definieren, wird dieselbe Benachrichtigung gleichzeitig über alle angegebenen Kanäle versendet.

```php theme={null}
<?php

namespace App\Notifications;

use Illuminate\Bus\Queueable;
use Illuminate\Contracts\Queue\ShouldQueue;
use Illuminate\Notifications\Messages\MailMessage;
use Illuminate\Notifications\Notification;

class InvoicePaid extends Notification implements ShouldQueue
{
    use Queueable;

    public function __construct(
        private readonly Invoice $invoice,
    ) {}

    public function via(object $notifiable): array
    {
        // Über E-Mail und Datenbank versenden
        return ['mail', 'database'];
    }

    public function toMail(object $notifiable): MailMessage
    {
        return (new MailMessage)
            ->subject('Zahlungseingang zu Ihrer Rechnung bestätigt')
            ->line('Wir haben den Zahlungseingang für Rechnung #'.$this->invoice->id.' bestätigt.')
            ->action('Rechnung ansehen', url('/invoice/'.$this->invoice->id));
    }

    public function toArray(object $notifiable): array
    {
        return [
            'invoice_id' => $this->invoice->id,
            'amount' => $this->invoice->amount,
        ];
    }
}
```

## On-Demand-Benachrichtigungen

Um Benutzer zu benachrichtigen, die kein Konto in Ihrer Anwendung haben, verwenden Sie `Notification::route()`.

```php theme={null}
use Illuminate\Support\Facades\Notification;

Notification::route('mail', 'guest@example.com')
    ->route('vonage', '5555551212')
    ->notify(new InvoicePaid($invoice));
```

## Zusammenfassung

| Ziel                             | Vorgehen                                               |
| -------------------------------- | ------------------------------------------------------ |
| Notification anlegen             | `php artisan make:notification ClassName`              |
| Einen Benutzer benachrichtigen   | `$user->notify(new MyNotification())`                  |
| Mehrere Benutzer benachrichtigen | `Notification::send($users, new MyNotification())`     |
| Per E-Mail versenden             | `via()` gibt `mail` zurück, `toMail()` definieren      |
| In der DB speichern              | `via()` gibt `database` zurück, `toArray()` definieren |
| Asynchron über Queue senden      | `ShouldQueue` implementieren                           |
| Über mehrere Kanäle senden       | Mehrere Schlüssel in `via()` zurückgeben               |


## Related topics

- [Notification-Kanal - Laravel Bluesky](/de/packages/laravel-bluesky/notification.md)
- [Laravel Notification für Discord (Webhook)](/de/packages/laravel-notification-discord-webhook.md)
- [Notification-Channel - LINE SDK für Laravel](/de/packages/laravel-line-sdk/notification.md)
- [Tutorial - Laravel Console Starter](/de/packages/laravel-console-starter/tutorial.md)
- [Laravel Telescope](/de/telescope.md)