Laravel Notification Log

https://github.com/spatie/laravel-notification-log
Admin
Laravel Notification Log is a Laravel package that logs all notifications sent by your app, allowing...
Tokens:9,166
Snippets:72
Trust Score:10
License:MIT
Update:7 months ago
Show doc for...
Tokens:
Raw
### Publish and run migrations

Source: https://github.com/spatie/laravel-notification-log/blob/main/docs/installation-setup.md

Publish the package migrations and run them to create the necessary database tables for logging notifications.

```bash
php artisan vendor:publish --tag="notification-log-migrations"
php artisan migrate
```

--------------------------------

### Publish and configure package settings

Source: https://github.com/spatie/laravel-notification-log/blob/main/docs/installation-setup.md

Publish the configuration file to customize the logging model, pruning duration, and event handling logic.

```bash
php artisan vendor:publish --tag="notification-log-config"
```

```php
return [
    'model' => Spatie\NotificationLog\Models\NotificationLogItem::class,
    'prune_after_days' => 30,
    'log_all_by_default' => config('notification-log.log_all_by_default'),
    'actions' => [
        'convertEventToModel' => Spatie\NotificationLog\Actions\ConvertNotificationSendingEventToLogItemAction::class
    ],
    'event_subscriber' => Spatie\NotificationLog\NotificationEventSubscriber::class,
];
```

--------------------------------

### Install package via Composer

Source: https://github.com/spatie/laravel-notification-log/blob/main/docs/installation-setup.md

Use the Composer package manager to add the notification log package to your Laravel project.

```bash
composer require spatie/laravel-notification-log
```

--------------------------------

### Install Laravel Notification Log Package

Source: https://context7.com/spatie/laravel-notification-log/llms.txt

Installs the spatie/laravel-notification-log package using Composer, publishes migrations, and runs database migrations to create the notification log table.

```bash
composer require spatie/laravel-notification-log
php artisan vendor:publish --tag="notification-log-migrations"
php artisan migrate
```

--------------------------------

### Schedule model pruning

Source: https://github.com/spatie/laravel-notification-log/blob/main/docs/installation-setup.md

Configure the automatic removal of old log entries by scheduling the model:prune command. This implementation varies between Laravel 11+ and Laravel 10.

```php
// Laravel 11+ in routes/console.php
use Illuminate\Support\Facades\Schedule;

Schedule::command('model:prune', [
    '--model' => [
        \Spatie\NotificationLog\Models\NotificationLogItem::class,
    ],
])->daily();
```

```php
// Laravel 10 in app/Console/Kernel.php
class Kernel extends ConsoleKernel
{
    protected function schedule(Schedule $schedule)
    {
         $schedule->command('model:prune', [
                    '--model' => [
                        \Spatie\NotificationLog\Models\NotificationLogItem::class,
                    ],
        ])->daily();
    }
}
```

--------------------------------

### Implement logExtra Method for Notification Logging

Source: https://github.com/spatie/laravel-notification-log/blob/main/docs/basic-usage/adding-extra-info-to-your-notification.md

Add a `logExtra` method to your notification class to return an array of data. This data will be stored in the `extra` JSON column of the `notification_log_items` table when the notification is logged. Ensure the method signature matches the example for correct event handling.

```php
use Illuminate\Notifications\Events\NotificationSending;

// in a notification
public function logExtra(NotificationSending $event): array
{
    return ['extraKey' => 'extraValue'];
}
```

--------------------------------

### Control Which Notifications Get Logged (PHP)

Source: https://context7.com/spatie/laravel-notification-log/llms.txt

Implement the `shouldLog()` method in your notification class to conditionally control whether a notification is logged. This method should return `true` to log the notification or `false` to skip logging. This allows for selective logging based on notification content or recipient.

```php
namespace App\Notifications;

use Illuminate\Notifications\Notification;
use Illuminate\Notifications\Events\NotificationSending;

class ImportantAlertNotification extends Notification
{
    public function __construct(
        public string $severity = 'low'
    ) {}

    // Only log high-severity alerts
    public function shouldLog(NotificationSending $event): bool
    {
        return $this->severity === 'high' || $this->severity === 'critical';
    }

    public function via($notifiable): array
    {
        return ['mail', 'slack'];
    }
}

// Always log this notification
class AuditRequiredNotification extends Notification
{
    public function shouldLog(NotificationSending $event): bool
    {
        return true;
    }
}

// Never log this notification
class TransientNotification extends Notification
{
    public function shouldLog(NotificationSending $event): bool
    {
        return false;
    }
}

// Conditional logging based on notifiable
class UserNotification extends Notification
{
    public function shouldLog(NotificationSending $event): bool
    {
        // Only log for premium users
        return $event->notifiable->is_premium ?? false;
    }
}
```

--------------------------------

### Implement shouldLog method in Laravel Notification

Source: https://github.com/spatie/laravel-notification-log/blob/main/docs/basic-usage/determining-which-notifications-get-logged.md

The shouldLog method allows developers to define custom logic to determine if a specific notification should be logged. It receives a NotificationSending event and must return a boolean value.

```php
use Illuminate\Notifications\Events\NotificationSending;

// in a notification
public function shouldLog(NotificationSending $event): bool
{
	return true;
}
```

--------------------------------

### Get Latest Log Item for a Notifiable (PHP)

Source: https://github.com/spatie/laravel-notification-log/blob/main/docs/basic-usage/querying-the-notification-log.md

Fetches the single most recent logged notification for a given notifiable entity. Returns `null` if no notifications have been sent to the notifiable yet. Supports filtering by notification type, time range, and fingerprint.

```php
use Spatie\NotificationLog\Models\NotificationLogItem;
use App\Notifications\OrderSentNotification;

// Basic usage
$logItem = NotificationLogItem::latestFor($notifiable);

// With optional parameters
$logItem = NotificationLogItem::latestFor(
    $notifiable,
    notificationType: OrderSentNotification::class, // search for a specific notification type
    before: $carbon, // we're looking for a notification before the given carbon instance
    after: $carbon, // we're looking for a notification after the given carbon instance
    fingerprint: 'dummy-fingerprint' // search for a log item with this fingerprint
);
```

--------------------------------

### Generate hashed fingerprints for complex parameters

Source: https://github.com/spatie/laravel-notification-log/blob/main/docs/basic-usage/working-with-fingerprints.md

Shows how to handle complex or multiple constructor parameters by using hashing functions like md5 to create a unique, fixed-length fingerprint string.

```php
public function fingerprint()
{
    return md5("{$this->parameter}-{$this->anotherParameter}-{$this->yetAnotherOne}");
}
```

--------------------------------

### Run Package Tests (Bash)

Source: https://github.com/spatie/laravel-notification-log/blob/main/README.md

Executes the test suite for the spatie/laravel-notification-log package using Composer. This command is typically run in the project's root directory.

```bash
composer test
```

--------------------------------

### Retrieve and query notification logs by fingerprint

Source: https://github.com/spatie/laravel-notification-log/blob/main/docs/basic-usage/working-with-fingerprints.md

Demonstrates how to access the stored fingerprint property from a log item and how to use the latestFor method to query notifications associated with a specific fingerprint.

```php
// returns the fingerprint
Spatie\NotificationLog\Models\NotificationLogItem::first()->fingerprint;

// return the latest logged notification for the first order.
$logItem = NotificationLogItem::latestFor($notifiable, fingerprint: "order-1");
```

--------------------------------

### Extend NotificationLogItem Model in PHP

Source: https://github.com/spatie/laravel-notification-log/blob/main/docs/advanced-usage/using-your-own-notification-log-model.md

This snippet demonstrates how to create a custom notification log model by extending the base `NotificationLogItem` class provided by the spatie/laravel-notification-log package. This allows for further customization of notification logging behavior.

```php
use Spatie\NotificationLog\Models\NotificationLogItem;

class CustomLogItem extends NotificationLogItem
{
    
}
```

--------------------------------

### Configure Custom Notification Log Model in PHP

Source: https://github.com/spatie/laravel-notification-log/blob/main/docs/advanced-usage/using-your-own-notification-log-model.md

This snippet shows how to configure the spatie/laravel-notification-log package to use your custom notification log model. By updating the `model` key in the `notification-log` config file, you can specify your custom class to be used for logging notifications.

```php
return [
    /*
     * This model will be used to log all sent notifications
     */
    'model' => CustomLogItem::class,
    
    // ...
];
```

--------------------------------

### Conditionally Send Notification Based on History (PHP)

Source: https://github.com/spatie/laravel-notification-log/blob/main/docs/introduction.md

Demonstrates how to use the `wasSentTo` and `inThePastMinutes` methods from the `HasHistory` trait to prevent sending a notification if it has already been sent to the same notifiable within the last 60 minutes. Requires the `HasHistory` trait to be used within the notification class.

```php
use Spatie\NotificationLog\Models\Concerns\HasHistory;

// in a notification

// set history trait
use HasHistory;

// verifying if the queued notification can be sent based in the history
public function shouldSend($notifiable)
{
      return ! $this
        ->wasSentTo($notifiable)
        ->inThePastMinutes(60);
}
```

--------------------------------

### Configure Laravel Notification Log Settings

Source: https://context7.com/spatie/laravel-notification-log/llms.txt

Configures the behavior of the Laravel Notification Log package, including the model used for logging, the duration for pruning old records, whether to log all notifications by default, and custom action classes.

```php
// config/notification-log.php
return [
    // The model used to log sent notifications
    'model' => Spatie\NotificationLog\Models\NotificationLogItem::class,

    // Log items older than this will be automatically pruned
    'prune_after_days' => 30,

    // Set to false to only log notifications with shouldLog() returning true
    'log_all_by_default' => true,

    // Custom action classes for low-level customization
    'actions' => [
        'convertEventToModel' => Spatie\NotificationLog\Actions\ConvertNotificationSendingEventToLogItemAction::class,
    ],

    // Event subscriber for notification events
    'event_subscriber' => Spatie\NotificationLog\NotificationEventSubscriber::class,
];
```

--------------------------------

### Custom Notification Conversion Action

Source: https://context7.com/spatie/laravel-notification-log/llms.txt

Create a custom action by extending `ConvertNotificationSendingEventToLogItemAction` to gain full control over how notification events are transformed into log entries. This allows for custom notification type generation and fingerprinting logic. Requires configuration in `config/notification-log.php`.

```php
namespace App\Actions;

use Spatie\NotificationLog\Actions\ConvertNotificationSendingEventToLogItemAction;
use Illuminate\Notifications\Events\NotificationSending;

class CustomConversionAction extends ConvertNotificationSendingEventToLogItemAction
{
    // Use short class name instead of FQCN
    protected function getNotificationType(NotificationSending $event): string
    {
        return class_basename($event->notification);
    }

    // Add custom fingerprint generation
    protected function getFingerprint(NotificationSending $event): ?string
    {
        $notification = $event->notification;

        // Custom fingerprint if notification doesn't define one
        if (!method_exists($notification, 'fingerprint')) {
            return md5(serialize($notification));
        }

        return parent::getFingerprint($event);
    }
}

// Register in config/notification-log.php
return [
    'actions' => [
        'convertEventToModel' => \App\Actions\CustomConversionAction::class,
    ],
];
```

--------------------------------

### Add Extra Data to Notification Logs (PHP)

Source: https://context7.com/spatie/laravel-notification-log/llms.txt

Implement the `logExtra()` method in your notification class to include additional metadata with each log entry. This method should return an array of key-value pairs representing the extra data. This data can be accessed later from the `extra` attribute of the `NotificationLogItem`.

```php
namespace App\Notifications;

use Illuminate\Notifications\Notification;
use Illuminate\Notifications\Events\NotificationSending;

class PurchaseConfirmationNotification extends Notification
{
    public function __construct(
        public Order $order,
        public float $discount = 0
    ) {}

    // Store additional data with the notification log
    public function logExtra(NotificationSending $event): array
    {
        return [
            'order_id' => $this->order->id,
            'order_total' => $this->order->total,
            'discount_applied' => $this->discount,
            'items_count' => $this->order->items->count(),
            'shipping_method' => $this->order->shipping_method,
            'user_locale' => $event->notifiable->locale ?? 'en',
        ];
    }

    public function via($notifiable): array
    {
        return ['mail', 'database'];
    }
}

// Access extra data from log items
use Spatie\NotificationLog\Models\NotificationLogItem;

$logs = NotificationLogItem::query()
    ->where('notification_type', PurchaseConfirmationNotification::class)
    ->get();

foreach ($logs as $log) {
    $extra = $log->extra;
    echo "Order #{$extra['order_id']}: ${$extra['order_total']}";
    echo "Discount: ${$extra['discount_applied']}";
}
```

--------------------------------

### Display Logged Notifications in Blade (Blade)

Source: https://github.com/spatie/laravel-notification-log/blob/main/docs/introduction.md

Iterates through a collection of logged notifications and displays their type and creation timestamp within an unordered list. Assumes `$sentNotifications` is a collection of `NotificationLogItem` models.

```blade
<ul>
@foreach($sentNotifications as $sentNotification)
    <li>{{ $sentNotification->notification_type }} at {{ $sentNotification->created_at->format('Y-m-d H:i:s') }}</li>
@endforeach
</ul>
```

--------------------------------

### Send On-Demand Notification (PHP)

Source: https://github.com/spatie/laravel-notification-log/blob/main/docs/advanced-usage/handling-on-demand-notifications.md

Demonstrates how to send an on-demand notification using Laravel's Notification facade. This method allows sending notifications to arbitrary email addresses or other recipients not directly associated with a user model. The `route` method specifies the recipient, and `notify` sends the notification instance.

```php
Notification::route('mail', 'taylor@example.com')
    ->notify(new InvoicePaidNotification($invoice));
```

--------------------------------

### Retrieve Logged Notifications for a User (PHP)

Source: https://github.com/spatie/laravel-notification-log/blob/main/README.md

Retrieves a collection of `NotificationLogItem` models representing all notifications sent to a user. This method is available on the user model.

```php
$sentNotifications = $user->loggedNotifications();
```

--------------------------------

### Schedule Daily Pruning of Old Notification Logs

Source: https://context7.com/spatie/laravel-notification-log/llms.txt

Configures Laravel's scheduler to automatically prune old notification log entries daily using the 'model:prune' command, targeting the NotificationLogItem model.

```php
// routes/console.php (Laravel 11+)
use Illuminate\Support\Facades\Schedule;

Schedule::command('model:prune', [
    '--model' => [
        \Spatie\NotificationLog\Models\NotificationLogItem::class,
    ],
])->daily();
```

--------------------------------

### Display Logged Notifications in a View (Blade)

Source: https://github.com/spatie/laravel-notification-log/blob/main/README.md

Iterates through a collection of `NotificationLogItem` models and displays the notification type and creation timestamp in an unordered list. Assumes `$sentNotifications` is a collection of logged notification items.

```blade
<ul>
@foreach($sentNotifications as $sentNotification)
    <li>{{ $sentNotification->type }} at {{ $sentNotification->created_at->format('Y-m-d H:i:s') }}</li>
@endforeach
</ul>
```

--------------------------------

### Implement fingerprint method in Notification class

Source: https://github.com/spatie/laravel-notification-log/blob/main/docs/basic-usage/working-with-fingerprints.md

Defines a fingerprint method within a Laravel Notification class to return a unique string identifier based on constructor parameters. This identifier is stored in the notification log for tracking purposes.

```php
use Illuminate\Notifications\Notification;

class OrderSentNotification extends Notification
{
    public function __construct(
        public Order $order,
    ) {}
    
    public function fingerprint()
    {
        return "order-{$this->order->id}";
    }
}
```

--------------------------------

### Register Custom Notification Conversion Action (PHP)

Source: https://github.com/spatie/laravel-notification-log/blob/main/docs/advanced-usage/customizing-the-logging-process.md

This PHP code snippet shows how to register a custom notification conversion action in the `notification-log` configuration file. By setting the `actions.convertEventToModel` key to your custom action's class, you instruct the package to use your overridden logic for logging notifications. This is a crucial step after defining your custom action.

```php
return [
    // ...

    'actions' => [
        'convertEventToModel' => CustomConversionAction::class,
    ],
]
```

--------------------------------

### Custom Notification Log Model

Source: https://context7.com/spatie/laravel-notification-log/llms.txt

Extend the base `NotificationLogItem` model to customize its behavior, such as changing the database connection, table name, or implementing custom pruning logic. This allows for tailored storage and management of notification logs. Requires configuration in `config/notification-log.php`.

```php
namespace App\Models;

use Spatie\NotificationLog\Models\NotificationLogItem;
use Illuminate\Database\Eloquent\Builder;

class CustomNotificationLogItem extends NotificationLogItem
{
    // Use a different database connection
    protected $connection = 'logs';

    // Custom table name
    protected $table = 'custom_notification_logs';

    // Custom pruning logic - keep critical notifications longer
    public function prunable(): Builder
    {
        return static::query()
            ->where('created_at', '<=', now()->subDays(90))
            ->where('notification_type', 'not like', '%Critical%');
    }

    // Add custom methods
    public function scopeForChannel(Builder $query, string $channel): Builder
    {
        return $query->where('channel', $channel);
    }

    public function scopeSuccessful(Builder $query): Builder
    {
        return $query->whereNotNull('confirmed_at');
    }

    // Add custom attributes
    public function getWasSuccessfulAttribute(): bool
    {
        return $this->confirmed_at !== null;
    }
}

// Register in config/notification-log.php
return [
    'model' => \App\Models\CustomNotificationLogItem::class,
    // ...
];

// Use custom model
$logs = CustomNotificationLogItem::query()
    ->forChannel('mail')
    ->successful()
    ->get();
```

--------------------------------

### Custom Notification Type for Logging

Source: https://context7.com/spatie/laravel-notification-log/llms.txt

Implement the `logType()` method in your notification class to define a custom, human-readable type for log entries. This helps in organizing and querying logs more effectively. It does not require external dependencies.

```php
namespace App\Notifications;

use Illuminate\Notifications\Notification;

class OrderStatusChangedNotification extends Notification
{
    public function __construct(
        public Order $order,
        public string $newStatus
    ) {}

    // Use a custom type instead of the full class name
    public function logType(): string
    {
        return "order.status.{$this->newStatus}";
    }

    public function via($notifiable): array
    {
        return ['mail'];
    }
}

// Query by custom type
use Spatie\NotificationLog\Models\NotificationLogItem;

$shippedNotifications = NotificationLogItem::query()
    ->where('notification_type', 'order.status.shipped')
    ->get();
```

--------------------------------

### Custom Notification Type Conversion (PHP)

Source: https://github.com/spatie/laravel-notification-log/blob/main/docs/advanced-usage/customizing-the-logging-process.md

This PHP code snippet demonstrates how to create a custom action to log notification types using their base class name instead of the fully qualified class name (FQCN). It extends the default `ConvertNotificationSendingEventToLogItemAction` and overrides the `getNotificationType` method. This customization is useful for simplifying notification type identification in logs.

```php
use Spatie\NotificationLog\Actions\ConvertNotificationSendingEventToLogItemAction;
use Illuminate\Notifications\Events\NotificationSending;

class CustomConversionAction extends ConvertNotificationSendingEventToLogItemAction
{
    protected function getNotificationType(NotificationSending $event): string
    {
        $notification = $event->notification;

        return class_basename($notification);
    }
}
```

--------------------------------

### Query All Logged Notifications (PHP)

Source: https://github.com/spatie/laravel-notification-log/blob/main/docs/basic-usage/querying-the-notification-log.md

Retrieves all logged notifications from the `notification_log_items` table, ordered by their ID in descending order. This provides a complete history of sent notifications.

```php
use SpatieNotificationLogModels\NotificationLogItem;

// returns all logged notifications
NotificationLogItem::query()->orderByDesc('id')->get();
```

--------------------------------

### Prevent Duplicate Notifications with HasHistory Trait (PHP)

Source: https://context7.com/spatie/laravel-notification-log/llms.txt

Enables rate limiting and duplicate prevention for notifications by adding the HasHistory trait to notification classes. Provides methods like `wasSentTo()` and `wasNotSentTo()` to check notification history with optional time limits, fingerprint matching, and channel filtering.

```php
namespace App\Notifications;

use Illuminate\Notifications\Notification;
use Illuminate\Notifications\Messages\MailMessage;
use Spatie\NotificationLog\Models\Concerns\HasHistory;

class DailyReportNotification extends Notification
{
    use HasHistory;

    // Prevent sending if this notification was sent in the last 60 minutes
    public function shouldSend($notifiable): bool
    {
        return $this
            ->wasNotSentTo($notifiable)
            ->inThePastMinutes(60);
    }

    public function via($notifiable): array
    {
        return ['mail'];
    }

    public function toMail($notifiable): MailMessage
    {
        return (new MailMessage)
            ->subject('Your Daily Report')
            ->line('Here is your daily summary.');
    }
}

// With fingerprint matching - only prevent duplicates with same content
class OrderUpdateNotification extends Notification
{
    use HasHistory;

    public function __construct(public Order $order) {}

    public function shouldSend($notifiable): bool
    {
        // Only block if same notification with same fingerprint was sent
        return $this
            ->wasNotSentTo($notifiable, withSameFingerprint: true)
            ->inThePastMinutes(30);
    }

    public function fingerprint(): string
    {
        return "order-{$this->order->id}-status-{$this->order->status}";
    }

    public function via($notifiable): array
    {
        return ['mail'];
    }
}

// Check if notification WAS sent (inverse logic)
class ReminderNotification extends Notification
{
    use HasHistory;

    public function shouldSend($notifiable): bool
    {
        // Only send reminder if original notification was sent
        $wasSent = $this
            ->wasSentTo($notifiable)
            ->inThePastMinutes(60);

        return $wasSent;
    }
}

// Check specific channel
class MultiChannelNotification extends Notification
{
    use HasHistory;

    public function shouldSend($notifiable): bool
    {
        return $this
            ->wasNotSentTo($notifiable)
            ->onChannel('mail')
            ->inThePastMinutes(120);
    }
}

// Check if ever sent (no time limit)
class WelcomeNotification extends Notification
{
    use HasHistory;

    public function shouldSend($notifiable): bool
    {
        return $this
            ->wasNotSentTo($notifiable)
            ->inThePast();  // No time limit - check entire history
    }
}
```

--------------------------------

### Retrieve and Display Notification History

Source: https://context7.com/spatie/laravel-notification-log/llms.txt

This snippet demonstrates fetching the last 50 notifications for a user in a Laravel controller and rendering them in a Blade template. It handles display logic for notification types, delivery channels, timestamps, and delivery status.

```php
namespace App\Http\Controllers;

use Illuminate\Http\Request;

class NotificationHistoryController extends Controller
{
    public function index(Request $request)
    {
        $notifications = $request->user()
            ->notificationLogItems()
            ->limit(50)
            ->get();

        return view('notifications.history', compact('notifications'));
    }
}
```

```blade
<div class="notification-history">
    <h2>Your Notification History</h2>

    @forelse($notifications as $notification)
        <div class="notification-item">
            <div class="notification-type">
                {{ class_basename($notification->notification_type) }}
            </div>
            <div class="notification-channel">
                via {{ $notification->channel }}
            </div>
            <div class="notification-date">
                {{ $notification->created_at->format('M j, Y g:i A') }}
            </div>
            @if($notification->confirmed_at)
                <span class="badge badge-success">Delivered</span>
            @else
                <span class="badge badge-warning">Pending</span>
            @endif

            @if($notification->extra)
                <div class="notification-extra">
                    @foreach($notification->extra as $key => $value)
                        <span>{{ $key }}: {{ $value }}</span>
                    @endforeach
                </div>
            @endif
        </div>
    @empty
        <p>No notifications have been sent yet.</p>
    @endforelse
</div>
```

--------------------------------

### Access Notifications via Notifiable Model (PHP)

Source: https://github.com/spatie/laravel-notification-log/blob/main/docs/basic-usage/querying-the-notification-log.md

Demonstrates how to retrieve logged notifications associated with a notifiable model using the `notificationLogItems` relationship and the `latestLoggedNotification` method provided by the `HasNotifiableHistory` trait. Supports fetching all, a limited number, or the latest specific notification.

```php
use App\Notifications\OrderSentNotification;

// return all logged notifications, the most recent are first
$loggedNotifications = $user->notificationLogItems;

// return the five most recent logged notifications
$loggedNotifications = $user->notificationLogItems()->limit(5)->get();

// Get the latest logged notification
$logItem = $user->latestLoggedNotification();

// Get the latest with filters
$logItem = $user->latestLoggedNotification(
    notificationType: OrderSentNotification::class, // search for a specific notification type
    before: $carbon, // we're looking for a notification before the given carbon instance
    after: $carbon, // we're looking for a notification after the given carbon instance
    fingerprint: 'dummy-fingerprint' // search for a log item with this fingerprint
);
```

--------------------------------

### Implement Notification Sending Logic with History (PHP)

Source: https://github.com/spatie/laravel-notification-log/blob/main/docs/basic-usage/querying-the-notification-log.md

Utilizes the `HasHistory` trait within a Laravel notification class to control sending logic based on past notifications. It provides methods like `wasNotSentTo` and `wasSentTo` to check if a similar notification has been sent recently, optionally considering the notification's fingerprint.

```php
namespace App\Notifications;

use Illuminate\Notifications\Notification;
use Spatie\NotificationLog\Models\Concerns\HasHistory;

class YourNotification extends Notification
{
    use HasHistory;

    public function shouldSend($notifiable)
    {
        // Check if not sent to this notifiable in the last 30 minutes
        return $this
           ->wasNotSentTo($notifiable)
           ->inThePastMinutes(30);
    }

    public function shouldSendWithFingerprint($notifiable)
    {
        // Check if not sent with the same fingerprint in the last 30 minutes
        $this
           ->wasNotSentTo($notifiable, withSameFingerprint: true)
           ->inThePastMinutes(30);
    }
}
```

--------------------------------

### Sending On-Demand Notifications

Source: https://context7.com/spatie/laravel-notification-log/llms.txt

Send notifications to recipients that are not associated with a user model by using `Notification::route()`. The details of these on-demand notifications are stored in the `anonymous_notifiable_properties` column. This feature allows for flexible notification delivery without requiring user accounts.

```php
use Illuminate\Support\Facades\Notification;
use App\Notifications\SystemAlertNotification;

// Send to an email address without a User model
Notification::route('mail', 'admin@example.com')
    ->route('slack', '#alerts')
    ->notify(new SystemAlertNotification('Server CPU high'));

// The log entry will have:
// - notifiable_id: null
// - notifiable_type: null
// - anonymous_notifiable_properties: ['mail' => 'admin@example.com', 'slack' => '#alerts']

// Query on-demand notifications
use Spatie\NotificationLog\Models\NotificationLogItem;

$anonymousLogs = NotificationLogItem::query()
    ->whereNull('notifiable_id')
    ->whereNotNull('anonymous_notifiable_properties')
    ->get();

foreach ($anonymousLogs as $log) {
    $routes = $log->anonymous_notifiable_properties;
    echo "Sent to: " . ($routes['mail'] ?? 'N/A');
}
```

--------------------------------

### Check if Notification Was Sent Recently (PHP)

Source: https://github.com/spatie/laravel-notification-log/blob/main/README.md

Implements a `shouldSend` method within a notification class to prevent sending duplicate notifications within a specified time frame. It uses the `wasSentTo` and `inThePastMinutes` methods provided by the package.

```php
// in a notification

public function shouldSend($notifiable)
{
      return ! $this
        ->wasSentTo($notifiable)
        ->inThePastMinutes(60);
}
```

--------------------------------

### Add HasNotifiableHistory Trait to User Model

Source: https://context7.com/spatie/laravel-notification-log/llms.txt

Adds the `HasNotifiableHistory` trait to a User model, enabling convenient methods for querying notification history directly from the model instance.

```php
namespace App\Models;

use Illuminate\Database\Eloquent\Model;
use Illuminate\Notifications\Notifiable;
use Spatie\NotificationLog\Models\Concerns\HasNotifiableHistory;

class User extends Model
{
    use Notifiable;
    use HasNotifiableHistory;
}

// Usage examples:

// Get all logged notifications for a user (most recent first)
$allNotifications = $user->notificationLogItems;

// Get the 5 most recent notifications
$recentNotifications = $user->notificationLogItems()->limit(5)->get();

// Get the single most recent notification
$latestNotification = $user->latestLoggedNotification();

// Get latest notification with filters
$latestOrderNotification = $user->latestLoggedNotification(
    notificationTypes: \App\Notifications\OrderShippedNotification::class,
    fingerprint: 'order-123',
    after: now()->subDays(7),
    channel: 'mail'
);
```

--------------------------------

### Add Notification History to Notifiable Model (PHP)

Source: https://github.com/spatie/laravel-notification-log/blob/main/docs/basic-usage/querying-the-notification-log.md

Integrates notification logging history into a Laravel Eloquent model by using the `HasNotifiableHistory` trait. This trait adds methods to easily access and query notifications associated with the model.

```php
use Illuminate\Database\Eloquent\Model;
use Spatie\NotificationLog\Models\Concerns\HasNotifiableHistory;

class User extends Model
{
    use Notifiable; // Assuming Notifiable trait is also used
    use HasNotifiableHistory;
}
```

--------------------------------

### Implement logType Method for Custom Notification Type Logging (PHP)

Source: https://github.com/spatie/laravel-notification-log/blob/main/docs/advanced-usage/customizing-notification-types.md

This snippet demonstrates how to add a `logType` method to a Laravel notification class. This method should return a string that will be used as the custom notification type in the `notification_log_items` table. This allows for more flexible categorization of logged notifications.

```php
<?php

namespace App\Notifications;

use Illuminate\Notifications\Notification;

class MyCustomNotification extends Notification
{
    // ... other notification methods ...

    /**
     * Get the custom type for the notification log.
     *
     * @return string
     */
    public function logType(): string
    {
        return 'my_custom_notification_type';
    }
}

```
Tokens:
Raw