Snooze

https://github.com/thomasjohnkane/snooze
Admin
Snooze is a Laravel package for scheduling notifications to be sent at a future time, storing them...
Tokens:36,140
Snippets:305
Trust Score:8.3
License:MIT
Update:3 days ago
Show doc for...
Tokens:
Raw
### Install via Composer

Source: https://github.com/thomasjohnkane/snooze/blob/master/README.md

Install the package using Composer.

```bash
composer require thomasjohnkane/snooze
```

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

### Example usage of notifyAt()

Source: https://github.com/thomasjohnkane/snooze

Shows how to use the trait on a User model and schedule a notification with a future send time and optional meta.

```php
use App\Models\User;
use Illuminate\Notifications\Notifiable;
use Thomasjohnkane\Snooze\Traits\SnoozeNotifiable;
use Carbon\Carbon;

class User extends Model {
    use Notifiable, SnoozeNotifiable;

    // ...
}

$user = User::find(1);
$user->notifyAt(new BirthdayNotification, Carbon::parse($user->birthday), ['foo' => 'bar']);
```

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

### sendNow() usage example

Source: https://github.com/thomasjohnkane/snooze

Sends the notification immediately and reports any exceptions that occur.

```php
try {
    $notification->sendNow();
} catch (NotificationAlreadySentException|NotificationCancelledException $e) {
    report($e);
}
```

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

### send() usage example

Source: https://github.com/thomasjohnkane/snooze

Shows how to call send() on a ScheduledNotification instance and catch the NotificationAlreadySentException. The example uses the fully-qualified exception class name.

```php
$model = ScheduledNotification::find(1);
try {
    $model->send();
} catch (\Thomasjohnkane\Snooze\Exception\NotificationAlreadySentException $e) {
    report($e);
}
```

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

### Example published config for Snooze

Source: https://github.com/thomasjohnkane/snooze

Returns the Snooze configuration array with all options. The `table` and `model` keys have no environment variable backing and must be set directly. Other keys use `env()` with defaults matching the documented environment variables.

```php
return [
    'table' => 'scheduled_notifications',
    'model' => Thomasjohnkane\Snooze\Models\ScheduledNotification::class,
    'sendFrequency' => env('SCHEDULED_NOTIFICATION_SEND_FREQUENCY', 'everyMinute'),
    'sendTolerance' => env('SCHEDULED_NOTIFICATION_SEND_TOLERANCE', 60 * 60 * 24),
    'pruneAge' => env('SCHEDULED_NOTIFICATION_PRUNE_AGE', null),
    'disabled' => env('SCHEDULED_NOTIFICATIONS_DISABLED', false),
    'onOneServer' => env('SCHEDULED_NOTIFICATIONS_ONE_SERVER', false),
    'scheduleCommands' => env('SCHEDULED_NOTIFICATIONS_SCHEDULE_COMMANDS', true),
    'registerMigrations' => env('SCHEDULED_NOTIFICATIONS_REGISTER_MIGRATIONS', true),
    'deleteWhenMissingModels' => env('SCHEDULED_NOTIFICATIONS_DELETE_WHEN_MISSING_MODELS', false),
];
```

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

### String/identity accessor usage example

Source: https://github.com/thomasjohnkane/snooze

Outputs the notification's ID, type, target type, and target ID.

```php
echo $notification->getId();
echo $notification->getType();    // e.g. App\Notifications\WelcomeEmail
echo $notification->getTargetType();
echo $notification->getTargetId();
```

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

### Create scheduled notification example

Source: https://github.com/thomasjohnkane/snooze

Schedule a notification for a user's birthday with meta data.

```php
use Thomasjohnkane\Snooze\ScheduledNotification;
use Carbon\Carbon;

ScheduledNotification::create(
    Auth::user(),
    new BirthdayNotification($user),
    Carbon::parse($user->birthday),
    ['foo' => 'bar']
);
```

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

### Get pending notifications example

Source: https://github.com/thomasjohnkane/snooze

Fetch pending notifications with a 24-hour tolerance and log the count.

```php
$pending = ScheduledNotification::getPendingNotifications(60 * 60 * 24);
\Illuminate\Support\Facades\Log::info($pending->count());
```

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

### getMeta() method signature and example

Source: https://github.com/thomasjohnkane/snooze

Retrieves meta data. With no argument, returns the entire 'meta' column as an array. With a key, returns $meta[$key] ?? [] (empty array when key is missing).

```php
public function getMeta($key = null)
```

```php
$allMeta   = $notification->getMeta();
$foo       = $notification->getMeta('foo'); // [] if missing
```

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

### Schedule notification with ScheduledNotification::create helper

Source: https://github.com/thomasjohnkane/snooze/blob/master/README.md

Uses the create method on ScheduledNotification to schedule a notification for a target user. Requires a target, a notification instance, and a send time. This example schedules for one hour from now.

```php
ScheduledNotification::create(
     Auth::user(), // Target
     new ScheduledNotificationExample($order), // Notification
     Carbon::now()->addHour() // Send At
);
```

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

### refresh() usage example

Source: https://github.com/thomasjohnkane/snooze

Refreshes the notification and then checks its persisted state.

```php
$notification->refresh();
$notification->isSent(); // reflects persisted state
```

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

### Schedule notification with notifyAt

Source: https://github.com/thomasjohnkane/snooze/blob/master/docs/examples/basic-delayed-notification.md

Schedules a notification for a notifiable user using the notifyAt method. Requires the SnoozeNotifiable trait on the model and a notification class created via `php artisan make:notification OneWeekAfterNotice`. The `$sentAt` variable should be a Carbon instance, e.g., `Carbon::now()->addDays(7)`, and Carbon must be imported with `use Carbon\Carbon;`. The notification is saved in the `scheduled_notifications` table and sent on the first `snooze:send` run after the scheduled date.

```php
Auth::user()->notifyAt(new OneWeekAfterNotice(), $sentAt);
```

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

### cancel() usage example

Source: https://github.com/thomasjohnkane/snooze

Shows how to call cancel() and catch the NotificationAlreadySentException, which is thrown when attempting to cancel a notification that has already been sent.

```php
try {
    $model->cancel();
} catch (\Thomasjohnkane\Snooze\Exception\NotificationAlreadySentException $e) {
    // cannot cancel a sent notification
}
```

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

### scheduleAgainAt() usage example

Source: https://github.com/thomasjohnkane/snooze

Creates a duplicated record with a new send time. The duplicate has sent_at, rescheduled_at, and cancelled_at reset to null.

```php
$new = $notification->scheduleAgainAt(Carbon::now()->addWeek());
```

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

### Boolean status check usage example

Source: https://github.com/thomasjohnkane/snooze

Checks the notification's status using the boolean methods.

```php
if ($n->isSent()) { /* sent */ }
if ($n->isCancelled()) { /* cancelled */ }
if ($n->isRescheduled()) { /* rescheduled */ }
```

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

### reschedule() usage example

Source: https://github.com/thomasjohnkane/snooze

Reschedules a notification to a new time. Passing true as the second argument forces a duplicate of an already-sent notification.

```php
$notification->reschedule(Carbon::now()->addDay());
// or force a duplicate of an already-sent notification
$duplicate = $notification->reschedule(Carbon::now()->addDay(), true);
```

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

### getNotification() method signature and example

Source: https://github.com/thomasjohnkane/snooze

Returns the original notification object, unserialized from the 'notification' column via the Serializer. No parameters.

```php
public function getNotification()
```

```php
$notification = $model->getNotification();
```

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

### Timestamp accessor usage example

Source: https://github.com/thomasjohnkane/snooze

Accesses timestamp values, checking if a notification has been sent.

```php
$n->getSendAt()->toDateTimeString();
if ($n->getSentAt() === null) { /* not yet sent */ }
```

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

### scheduleAgainAt() usage example

Source: https://github.com/thomasjohnkane/snooze

Shows how to create a duplicate scheduled notification 30 days from now using Carbon::now()->addDays(30). This is used to re-queue already-sent or cancelled notifications.

```php
$duplicate = $model->scheduleAgainAt(Carbon::now()->addDays(30));
```

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

### cancel() usage example

Source: https://github.com/thomasjohnkane/snooze

Cancels a notification only if it hasn't been sent, catching the exception when it has.

```php
if (! $notification->isSent()) {
    try {
        $notification->cancel();
    } catch (NotificationAlreadySentException $e) {
        // cannot cancel an already-sent notification
    }
}
```

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

### Catching Snooze exceptions in consumer code

Source: https://github.com/thomasjohnkane/snooze

Shows how to catch Snooze exceptions in consumer code. All exceptions extend LaravelSnoozeException, so a single guard covers the whole API surface. The example catches SchedulingFailedException during scheduling and NotificationAlreadySentException, NotificationCancelledException, and UnserializeFailedException on lifecycle operations. Note that sendNow(), cancel(), and reschedule() on the wrapper delegate to the model and propagate these exceptions unchanged.

```php
use Thomasjohnkane\Snooze\ScheduledNotification;
use Thomasjohnkane\Snooze\Exception\SchedulingFailedException;
use Thomasjohnkane\Snooze\Exception\NotificationAlreadySentException;
use Thomasjohnkane\Snooze\Exception\NotificationCancelledException;
use Thomasjohnkane\Snooze\Exception\UnserializeFailedException;

// During scheduling:
try {
    ScheduledNotification::create($target, $notification, $pastDate);
} catch (SchedulingFailedException $e) {
    // past send_at or target not notifiable
}

// On lifecycle operations (also raised via sendNow()/send()/cancel()/reschedule()):
$model = ScheduledNotification::find($id);
try {
    $model->sendNow();
} catch (NotificationAlreadySentException|NotificationCancelledException $e) {
    // state conflict
} catch (UnserializeFailedException $e) {
    // could not restore serialized payload
}
```

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

### Get all scheduled notifications

Source: https://github.com/thomasjohnkane/snooze

Returns a collection of all scheduled notifications. When both flags are false, only still-active future notifications are returned.

```php
public static function all(bool $includeSent = false, bool $includeCanceled = false): Collection
```

```php
$allScheduled = ScheduledNotification::all(true, true);
```

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

### shouldRescheduleFor() method signature and example

Source: https://github.com/thomasjohnkane/snooze

Returns DateTimeInterface|string|null, delegating to the model. When the notification defines a shouldRescheduleFor($notifiable) method, its return value is forwarded; returns null when absent.

```php
public function shouldRescheduleFor()
```

```php
$rescheduleTo = $notification->shouldRescheduleFor();
```

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

### shouldInterrupt() usage example

Source: https://github.com/thomasjohnkane/snooze

Shows a conditional check using shouldInterrupt() with no arguments, which triggers unserialization of the notification and notifiable objects from the model's columns.

```php
if ($model->shouldInterrupt()) {
    // conditional interrupt against unserialized objects
}
```

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

### shouldInterrupt() method signature and example

Source: https://github.com/thomasjohnkane/snooze

Returns bool, delegating to the model's shouldInterrupt() logic. Checks if the unserialized notification defines a shouldInterrupt($notifiable) method and returns its (cast to bool) result; returns false if absent.

```php
public function shouldInterrupt(): bool
```

```php
if ($notification->shouldInterrupt()) {
    // caller should prevent sending
}
```

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

### Run Migrations

Source: https://github.com/thomasjohnkane/snooze/blob/master/README.md

Run the database migrations for the package.

```bash
php artisan migrate
```

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

### Schedule notifications in UserObserver created method

Source: https://github.com/thomasjohnkane/snooze/blob/master/docs/examples/on-boarding-email-drip.md

In the UserObserver's created method, schedule the three on-boarding notifications using Carbon timestamps. The comment '// use Carbon\Carbon;' indicates the required import.

```php
// use Carbon\Carbon;

public function created(User $user)
{
    $now = Carbon::now();
   
    $user->notifyAt(new SignUpConfirmation($user), $now->addHour());
    $user->notifyAt(new WelcomeToCommunity($user), $now->addDays(3));
    $user->notifyAt(new UpsellSubscription($user), $now->addWeek());
}
```

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

### Publish config in boot()

Source: https://github.com/thomasjohnkane/snooze

Publishes the package configuration file to the Laravel config directory with the 'config' tag.

```php
$this->publishes([self::CONFIG_PATH => config_path('snooze.php')], 'config');
```

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

### Run Tests with composer test

Source: https://github.com/thomasjohnkane/snooze/blob/master/README.md

Use this command to run the package's test suite. It is the standard way to execute tests for this Laravel package.

```bash
composer test
```

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

### Register Facade in config/app.php

Source: https://github.com/thomasjohnkane/snooze/blob/master/docs/register-provider-and-facade.md

Add this line to the 'aliases' section of config/app.php to register the package facade. This step is optional if using Laravel >= 5.5 with package auto discovery.

```php
Thomasjohnkane\ScheduledNotifications\Facades\ScheduledNotification::class,
```

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

### Constructor signature

Source: https://github.com/thomasjohnkane/snooze

Constructor accepts an underlying Eloquent model instance. Not typically called directly; use static helpers instead.

```php
public function __construct(ScheduledNotificationModel $scheduleNotificationModel)
```

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

### Scheduling integration from ServiceProvider::boot()

Source: https://github.com/thomasjohnkane/snooze

Schedules snooze:send and snooze:prune automatically. Respects config options like scheduleCommands, disabled, sendFrequency, onOneServer, and pruneAge.

```php
if (config('snooze.scheduleCommands', true)) {
    $this->app->booted(function () {
        $schedule = $this->app->make(Schedule::class);

        if (! config('snooze.disabled')) {
            $frequency = config('snooze.sendFrequency', 'everyMinute');
            if (config('snooze.onOneServer', false)) {
                $schedule->command('snooze:send')->{$frequency}()->onOneServer();
            } else {
                $schedule->command('snooze:send')->{$frequency}()->withoutOverlapping();
            }
        }

        if (config('snooze.pruneAge') !== null) {
            if (config('snooze.onOneServer', false)) {
                $schedule->command('snooze:prune')->daily()->onOneServer();
            } else {
                $schedule->command('snooze:prune')->daily()->withoutOverlapping();
            }
        }
    });
}
```

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

### create() method signature

Source: https://github.com/thomasjohnkane/snooze

Factory to persist a new scheduled notification. Throws SchedulingFailedException if sendAt is in the past or notifiable lacks notify().

```php
public static function create(
    object $notifiable,
    Notification $notification,
    DateTimeInterface $sendAt,
    array $meta = []
): self
```

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

### Merge config and bind 'snooze' in register()

Source: https://github.com/thomasjohnkane/snooze

Merges the package config under the 'snooze' key and binds a singleton factory returning a new Snooze instance.

```php
$this->mergeConfigFrom(self::CONFIG_PATH, 'snooze');

$this->app->bind('snooze', function () {
    return new Snooze();
});
```

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

### Load migrations conditionally in boot()

Source: https://github.com/thomasjohnkane/snooze

Loads package migrations only when the 'snooze.registerMigrations' config is truthy.

```php
if (config('snooze.registerMigrations', true)) {
    $this->loadMigrationsFrom(__DIR__.'/../migrations');
}
```

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

### Register Service Provider in config/app.php

Source: https://github.com/thomasjohnkane/snooze/blob/master/docs/register-provider-and-facade.md

Add this line to the 'providers' section of config/app.php to register the package's service provider. This step is optional if using Laravel >= 5.5 with package auto discovery.

```php
Thomasjohnkane\ScheduledNotifications\ServiceProvider::class,
```

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

### Register commands in console context

Source: https://github.com/thomasjohnkane/snooze

Registers the package's console commands only when running in the console.

```php
if ($this->app->runningInConsole()) {
    $this->commands($this->commands);
}
```

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

### Import command classes for overrides/binding

Source: https://github.com/thomasjohnkane/snooze

Use these imports to register overrides or bindings for the two artisan commands.

```php
use Thomasjohnkane\Snooze\Console\Commands\SendScheduledNotifications;
use Thomasjohnkane\Snooze\Console\Commands\PruneScheduledNotifications;
```

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

### Store meta information using ScheduledNotification::create

Source: https://github.com/thomasjohnkane/snooze/blob/master/README.md

Stores meta information on a scheduled notification using the ScheduledNotification::create helper. Useful for querying later.

```php
ScheduledNotification::create(
     $target, // Target
     new ScheduledNotificationExample($order), // Notification
     Carbon::now()->addDay(), // Send At,
     ['foo' => 'bar'] // Meta Information
);
```

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

### ServiceProvider class definition with commands

Source: https://github.com/thomasjohnkane/snooze

Defines the package's service provider, setting the config path and registering the send and prune console commands.

```php
class ServiceProvider extends \Illuminate\Support\ServiceProvider
{
    const CONFIG_PATH = __DIR__.'/../config/snooze.php';

    protected $commands = [
        Console\Commands\SendScheduledNotifications::class,
        Console\Commands\PruneScheduledNotifications::class,
    ];
}
```

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

### Query scheduled notifications using findByMeta helper

Source: https://github.com/thomasjohnkane/snooze/blob/master/README.md

Queries the database for scheduled notifications with certain meta information. First parameter is the meta key, second is the value. Note: the index column doesn't currently use a database index.

```php
  ScheduledNotification::findByMeta('foo', 'bar'); //key and value
```

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

### Manual facade alias registration

Source: https://github.com/thomasjohnkane/snooze

Registers the facade alias in config/app.php when discovery is disabled.

```php
Thomasjohnkane\Snooze\Facades\Snooze::class,
```

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

### notifyAt($notification, $sendAt, $meta)

Source: https://github.com/thomasjohnkane/snooze/blob/master/README.md

Schedules a notification to be sent at a specific time, with optional meta information.

```APIDOC
## notifyAt($notification, $sendAt, $meta)

### Description
Schedules a notification to be sent at a specific time, with optional meta information.

### Method
notifyAt

### Endpoint
$user->notifyAt($notification, $sendAt, $meta)

### Parameters
#### Request Body
- **$notification** (Notification) - Required - The notification instance.
- **$sendAt** (Carbon) - Required - The date to send the notification.
- **$meta** (array) - Optional - Meta information to store with the notification.

### Response
No return value specified.

### Request Example
```php
  $user->notifyAt(new BirthdayNotification, Carbon::parse($user->birthday), ['foo' => 'bar']);
```
```

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

### Manual service provider registration

Source: https://github.com/thomasjohnkane/snooze

Registers the service provider manually when package discovery is disabled.

```php
Thomasjohnkane\Snooze\ServiceProvider::class,
```

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

### Publish Snooze config file via artisan vendor:publish

Source: https://github.com/thomasjohnkane/snooze

Publishes the package's config/snooze.php file when package discovery is disabled. Run this command to make the configuration available for customization.

```bash
php artisan vendor:publish --provider="Thomasjohnkane\Snooze\ServiceProvider" --tag="config"
```

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

### Import SnoozeNotifiable trait

Source: https://github.com/thomasjohnkane/snooze

Imports the SnoozeNotifiable trait for use in an Eloquent model.

```php
use Thomasjohnkane\Snooze\Traits\SnoozeNotifiable;
```

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

### Enable onOneServer for snooze commands

Source: https://github.com/thomasjohnkane/snooze/blob/master/README.md

Sets an environment variable to enable Laravel Scheduler's onOneServer functionality for snooze commands.

```bash

SCHEDULED_NOTIFICATIONS_ONE_SERVER = true

```

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

### Create with AnonymousNotifiable and error handling

Source: https://github.com/thomasjohnkane/snooze

Schedule for an anonymous notifiable with try-catch for SchedulingFailedException.

```php
use Thomasjohnkane\Snooze\ScheduledNotification;
use Thomasjohnkane\Snooze\Exception\SchedulingFailedException;
use Illuminate\Notifications\AnonymousNotifiable;
use Carbon\Carbon;

$target = (new AnonymousNotifiable)
    ->route('mail', 'hello@example.com')
    ->route('sms', '56546456566');

try {
    ScheduledNotification::create($target, new WelcomeEmail(), Carbon::now()->addDay());
} catch (SchedulingFailedException $e) {
    // send_at in the past, or target has no notify() method
    report($e);
}
```

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

### ScheduledNotification::create($target, $notification, $sendAt, $meta)

Source: https://github.com/thomasjohnkane/snooze/blob/master/README.md

Creates a scheduled notification with optional meta information.

```APIDOC
## ScheduledNotification::create($target, $notification, $sendAt, $meta)

### Description
Creates a scheduled notification with optional meta information.

### Method
create

### Endpoint
ScheduledNotification::create($target, $notification, $sendAt, $meta)

### Parameters
#### Request Body
- **$target** (mixed) - Required - The target of the notification.
- **$notification** (Notification) - Required - The notification instance.
- **$sendAt** (Carbon) - Required - The date to send the notification.
- **$meta** (array) - Optional - Meta information to store with the notification.

### Response
No return value specified.

### Request Example
```php
ScheduledNotification::create(
     $target, // Target
     new ScheduledNotificationExample($order), // Notification
     Carbon::now()->addDay(), // Send At,
     ['foo' => 'bar'] // Meta Information
);
```
```

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

### getMeta($key)

Source: https://github.com/thomasjohnkane/snooze/blob/master/README.md

Retrieves meta information from a scheduled notification. If no key is passed, returns the entire meta column as an array. If a string key is passed, returns the value for that key.

```APIDOC
## getMeta($key)

### Description
Retrieves meta information from a scheduled notification. If no key is passed, returns the entire meta column as an array. If a string key is passed, returns the value for that key.

### Method
getMeta

### Endpoint
$notification->getMeta($key)

### Parameters
#### Query Parameters
- **$key** (string) - Optional - The specific meta key to retrieve.

### Response
Returns the entire meta column as an array if no key is provided, or the value for the given key.

### Request Example
```php
$notification->getMeta(); // returns entire meta array
$notification->getMeta('foo'); // returns value for 'foo'
```
```

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

### Store meta information using notifyAt trait

Source: https://github.com/thomasjohnkane/snooze/blob/master/README.md

Stores meta information on a scheduled notification using the notifyAt trait.

```php
  $user->notifyAt(new BirthdayNotification, Carbon::parse($user->birthday), ['foo' => 'bar']);
```

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

### Import Serializer class

Source: https://github.com/thomasjohnkane/snooze

Import the Serializer class for use in your PHP code.

```php
use Thomasjohnkane\Snooze\Serializer;
```

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

### snooze:send signature source

Source: https://github.com/thomasjohnkane/snooze

Defines the command signature and description for snooze:send. The handle() method sends pending notifications.

```php
protected $signature = 'snooze:send';
protected $description = 'Send scheduled notifications that are ready to be sent.';

public function handle(): void
```

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

### Models\ScheduledNotification::send()

Source: https://github.com/thomasjohnkane/snooze

Instance method that runs the send pipeline: guard states, unserialize, check shouldInterrupt, check shouldRescheduleFor, notify, and mark sent. Events fire along the way.

```APIDOC
## Models\ScheduledNotification::send()

### Description
Instance method that runs the send pipeline: guard states, unserialize, check shouldInterrupt, check shouldRescheduleFor, notify, and mark sent. Events fire along the way.

### Method
Instance method

### Endpoint
`$scheduledNotification->send()`

### Parameters
None documented.

### Response
No documented return value.
```

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

### Constructor signature

Source: https://github.com/thomasjohnkane/snooze

Constructor accepts an optional array of Eloquent attributes. Initializes the table name from config('snooze.table') and the serializer from app(Serializer::class).

```php
public function __construct(array $attributes = [])
```

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

### Snooze placeholder class

Source: https://github.com/thomasjohnkane/snooze

Empty placeholder class bound in the container as 'snooze' and exposed via the facade; currently has no members.

```php
namespace Thomasjohnkane\Snooze;

class Snooze
{
}
```

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

### snooze:prune signature source

Source: https://github.com/thomasjohnkane/snooze

Defines the command signature and description for snooze:prune. The handle() method prunes sent or cancelled notifications older than pruneAge.

```php
protected $signature = 'snooze:prune';
protected $description = 'Prune scheduled notifications that have been sent or cancelled';

public function handle(): void
```

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

### getPendingNotifications() method signature

Source: https://github.com/thomasjohnkane/snooze

Query notifications ready to send within tolerance. Returns Eloquent models, not wrapper instances.

```php
public static function getPendingNotifications(?int $tolerance = null): \Illuminate\Database\Eloquent\Collection
```

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

### sendNow() method signature

Source: https://github.com/thomasjohnkane/snooze

Signature for sending a notification immediately, overwriting the scheduled time.

```php
public function sendNow(): void
```

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

### Import ScheduledNotification class

Source: https://github.com/thomasjohnkane/snooze

Import the wrapper class for scheduling and managing Laravel notifications.

```php
use Thomasjohnkane\Snooze\ScheduledNotification;
```

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

### Run snooze:send manually

Source: https://github.com/thomasjohnkane/snooze

Executes the snooze:send command manually. It reads sendTolerance, sends pending notifications, and reports failures without aborting the batch.

```bash
php artisan snooze:send
```

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

### ScheduledNotification::create()

Source: https://github.com/thomasjohnkane/snooze

Static factory method to create a new scheduled notification. It serializes the target and notification, resolves the configured model class, and persists a row with send_at and meta.

```APIDOC
## ScheduledNotification::create()

### Description
Static factory method to create a new scheduled notification. It serializes the target and notification, resolves the configured model class, and persists a row with send_at and meta.

### Method
Static method

### Endpoint
`ScheduledNotification::create()`

### Parameters
- **target** (mixed) - Required - The notifiable target.
- **notification** (mixed) - Required - The notification to send.
- **sendAt** (DateTimeInterface) - Required - The time to send the notification.
- **meta** (array) - Optional - Additional metadata.

### Response
Returns an instance of the configured model class (e.g., `Models\ScheduledNotification`).
```

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

### all()

Source: https://github.com/thomasjohnkane/snooze

Retrieves all scheduled notifications, optionally including sent and canceled records.

```APIDOC
## all()

### Description
Retrieves all scheduled notifications, optionally including sent and canceled records.

### Method
all

### Parameters
#### Path Parameters
- **$includeSent** (bool) - Optional - Include already-sent records
- **$includeCanceled** (bool) - Optional - Include already-cancelled records

### Response
#### Success Response
- **Illuminate\Support\Collection** - of wrappers. When both flags are `false`, only still-active future notifications are returned.

### Request Example
```php
$allScheduled = ScheduledNotification::all(true, true);
```
```

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

### Add SnoozeNotifiable trait to User model

Source: https://github.com/thomasjohnkane/snooze/blob/master/docs/examples/on-boarding-email-drip.md

Add the SnoozeNotifiable trait to your user model to enable scheduling notifications with Snooze.

```php
use Thomasjohnkane\Snooze\Traits\SnoozeNotifiable;

class User {
    use SnoozeNotifiable;
}
```

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

### scheduleAgainAt() method signature

Source: https://github.com/thomasjohnkane/snooze

Declares the public scheduleAgainAt() method that accepts a sendAt value and returns a new replicated record with send_at set and sent_at/rescheduled_at/cancelled_at cleared to null.

```php
public function scheduleAgainAt($sendAt): self
```

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

### ScheduledNotification::findByMeta($key, $value)

Source: https://github.com/thomasjohnkane/snooze/blob/master/README.md

Queries the database for scheduled notifications with specific meta information.

```APIDOC
## ScheduledNotification::findByMeta($key, $value)

### Description
Queries the database for scheduled notifications with specific meta information.

### Method
findByMeta

### Endpoint
ScheduledNotification::findByMeta($key, $value)

### Parameters
#### Query Parameters
- **$key** (string) - Required - The meta key to search for.
- **$value** (mixed) - Required - The value to look for.

### Response
Returns a collection of scheduled notifications matching the meta criteria.

### Request Example
```php
  ScheduledNotification::findByMeta('foo', 'bar'); //key and value
```
```

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

### String/identity accessor method signatures

Source: https://github.com/thomasjohnkane/snooze

Signatures for accessing the notification's ID, type, target type, and target ID.

```php
public function getId()
public function getType()
public function getTargetType()
public function getTargetId()
```

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

### Error handling for notifyAt()

Source: https://github.com/thomasjohnkane/snooze

Catches SchedulingFailedException when the send time is in the past.

```php
use Thomasjohnkane\Snooze\Exception\SchedulingFailedException;

try {
    $user->notifyAt(new WelcomeMail, Carbon::now()->subHour());
} catch (SchedulingFailedException $e) {
    // send time was in the past
    report($e);
}
```

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

### find()

Source: https://github.com/thomasjohnkane/snooze

Finds a scheduled notification by its primary key. Returns a ScheduledNotification wrapper or null if not found.

```APIDOC
## find()

### Description
Finds a scheduled notification by its primary key. Returns a ScheduledNotification wrapper or null if not found.

### Method
find

### Parameters
#### Path Parameters
- **$scheduledNotificationId** (int) - Required - The auto-increment primary key of the scheduled-notification row

### Response
#### Success Response
- **?ScheduledNotification** - wrapper for the record, or null when not found.

### Request Example
```php
$notification = ScheduledNotification::find($id);

if (null === $notification) {
    // 404-style handling
    abort(404);
} else {
    $notification->cancel();
}
```
```

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

### Find scheduled notifications by meta key-value

Source: https://github.com/thomasjohnkane/snooze

Returns a collection of wrappers matching a JSON meta key-value pair. Uses a where("meta->{$key}", $value) query; note the meta column is not indexed.

```php
public static function findByMeta($key, $value): Collection
```

```php
ScheduledNotification::findByMeta('order_id', 12345)
    ->each(fn (ScheduledNotification $n) => $n->cancel());
```

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

### Snooze facade class

Source: https://github.com/thomasjohnkane/snooze

Laravel facade that resolves the container binding 'snooze'.

```php
namespace Thomasjohnkane\Snooze\Facades;

use Illuminate\Support\Facades\Facade;

class Snooze extends Facade
{
    protected static function getFacadeAccessor()
    {
        return 'snooze';
    }
}
```

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

### ScheduledNotification::create()

Source: https://github.com/thomasjohnkane/snooze

Factory method to persist a new scheduled notification. It accepts a notifiable target, a notification instance, a send time, and optional metadata, returning a new ScheduledNotification wrapper.

```APIDOC
## [POST] ScheduledNotification::create()

### Description
Factory method to persist a new scheduled notification. It accepts a notifiable target, a notification instance, a send time, and optional metadata, returning a new ScheduledNotification wrapper.

### Method
POST

### Endpoint
ScheduledNotification::create()

### Parameters
#### Request Body
- **$notifiable** (object) - Required - Destination for the notification. Any notifiable (model with `Notifiable`, or an `AnonymousNotifiable`). Must expose a `notify()` method.
- **$notification** (Illuminate\Notifications\Notification) - Required - The notification to deliver when due
- **$sendAt** (DateTimeInterface) - Required - The scheduled send time. Exceptions: `Carbon`, `CarbonImmutable`, any `DateTimeInterface`
- **$meta** (array) - Optional - Arbitrary serialized key/value meta stored with the record, queryable via `findByMeta`

### Response
#### Success Response (200)
- **self** - A new `ScheduledNotification` wrapper.

### Request Example
```php
use Thomasjohnkane\Snooze\ScheduledNotification;
use Carbon\Carbon;

ScheduledNotification::create(
    Auth::user(),
    new BirthdayNotification($user),
    Carbon::parse($user->birthday),
    ['foo' => 'bar']
);
```

Anonymous notifiable, with error handling:

```php
use Thomasjohnkane\Snooze\ScheduledNotification;
use Thomasjohnkane\Snooze\Exception\SchedulingFailedException;
use Illuminate\Notifications\AnonymousNotifiable;
use Carbon\Carbon;

$target = (new AnonymousNotifiable)
    ->route('mail', 'hello@example.com')
    ->route('sms', '56546456566');

try {
    ScheduledNotification::create($target, new WelcomeEmail(), Carbon::now()->addDay());
} catch (SchedulingFailedException $e) {
    // send_at in the past, or target has no notify() method
    report($e);
}
```
```

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

### refresh() method signature

Source: https://github.com/thomasjohnkane/snooze

Signature for reloading the underlying model from the database.

```php
public function refresh(): void
```

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

### Find scheduled notifications by target

Source: https://github.com/thomasjohnkane/snooze

Returns a collection of wrappers for a given notifiable, or null if the notifiable is not an Eloquent Model. Searches by target_id and target_type.

```php
public static function findByTarget(object $notifiable): ?Collection
```

```php
ScheduledNotification::findByTarget($user)?->each(fn ($n) => $n->sendNow());
```

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

### Import ScheduledNotification model

Source: https://github.com/thomasjohnkane/snooze

Import the ScheduledNotification Eloquent model class for use in your PHP code.

```php
use Thomasjohnkane\Snooze\Models\ScheduledNotification;
```

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

### String/identity accessors: getId(), getType(), getTargetType(), getTargetId()

Source: https://github.com/thomasjohnkane/snooze

Retrieve the notification's primary key, type, target type, and target ID.

```APIDOC
## getId(), getType(), getTargetType(), getTargetId()

### Description
Retrieve the notification's primary key, type, target type, and target ID.

### Method
Instance methods

### Signatures
`public function getId()`
`public function getType()`
`public function getTargetType()`
`public function getTargetId()`

### Parameters
None

### Returns
- `getId()`: the row primary key (`id`)
- `getType()`: the `notification_type` string
- `getTargetType()`: the `target_type` string
- `getTargetId()`: the `target_id` value (nullable for anonymous notifiables)

### Request Example
```php
echo $notification->getId();
echo $notification->getType();    // e.g. App\Notifications\WelcomeEmail
echo $notification->getTargetType();
echo $notification->getTargetId();
```
```

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

### refresh()

Source: https://github.com/thomasjohnkane/snooze

Reloads the underlying model from the database. No return value.

```APIDOC
## refresh()

### Description
Reloads the underlying model from the database. No return value.

### Method
Instance method

### Signature
`public function refresh(): void`

### Parameters
None

### Request Example
```php
$notification->refresh();
$notification->isSent(); // reflects persisted state
```
```

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

### scheduleAgainAt($newDate)

Source: https://github.com/thomasjohnkane/snooze/blob/master/README.md

Duplicates a scheduled notification to be sent again at a new date. Returns the new duplicated notification.

```APIDOC
## scheduleAgainAt($newDate)

### Description
Duplicates a scheduled notification to be sent again at a new date. Returns the new duplicated notification.

### Method
scheduleAgainAt

### Endpoint
$notification->scheduleAgainAt($newDate)

### Parameters
#### Request Body
- **$newDate** (Carbon) - Required - The new date to send the duplicated notification.

### Response
Returns the new (duplicated) $notification.

### Request Example
```php
$notification->scheduleAgainAt($newDate); // Returns the new (duplicated) $notification
```
```

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

### Models\ScheduledNotification::scheduleAgainAt()

Source: https://github.com/thomasjohnkane/snooze

Instance method to schedule the notification again at a given time.

```APIDOC
## Models\ScheduledNotification::scheduleAgainAt()

### Description
Instance method to schedule the notification again at a given time.

### Method
Instance method

### Endpoint
`$scheduledNotification->scheduleAgainAt()`

### Parameters
- **sendAt** (DateTimeInterface) - Required - The new time to send the notification.

### Response
No documented return value.
```

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

### send() method signature

Source: https://github.com/thomasjohnkane/snooze

Declares the public send() method that delivers the notification in-place. It throws NotificationCancelledException if cancelled_at is set, NotificationAlreadySentException if sent_at is set, and UnserializeFailedException on unserialize errors.

```php
public function send(): void
```

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

### Import all four Snooze events

Source: https://github.com/thomasjohnkane/snooze

Import any of the four events: NotificationSent, NotificationInterrupted, NotificationRescheduled, and NotificationDeleted.

```php
use Thomasjohnkane\Snooze\Events\NotificationSent;
use Thomasjohnkane\Snooze\Events\NotificationInterrupted;
use Thomasjohnkane\Snooze\Events\NotificationRescheduled;
use Thomasjohnkane\Snooze\Events\NotificationDeleted;
```

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

### Listening to NotificationSent event

Source: https://github.com/thomasjohnkane/snooze

Listen via Laravel's event system. The event object exposes the scheduledNotification property. For queued listeners, dispatch the event object directly, but in normal use events are fired automatically by send().

```php
use Thomasjohnkane\Snooze\Events\NotificationSent;
use Illuminate\Support\Facades\Event;

Event::listen(NotificationSent::class, function (NotificationSent $event) {
    $notification = $event->scheduledNotification;
    \Illuminate\Support\Facades\Log::info("Notification {$notification->id} sent");
});
```

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

### Catch base LaravelSnoozeException

Source: https://github.com/thomasjohnkane/snooze

Catch any Snooze-specific failure by catching the base class LaravelSnoozeException. Use this to handle all Snooze exceptions uniformly.

```php
use Thomasjohnkane\Snooze\Exception\LaravelSnoozeException;

try {
    // snooze operation
} catch (LaravelSnoozeException $e) {
    report($e);
}
```

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

### Duplicate a scheduled notification to be sent again

Source: https://github.com/thomasjohnkane/snooze/blob/master/README.md

Duplicates a scheduled notification to be sent again at a new date. Returns the new duplicated notification.

```php
$notification->scheduleAgainAt($newDate); // Returns the new (duplicated) $notification
```

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

### findByMeta()

Source: https://github.com/thomasjohnkane/snooze

Finds scheduled notifications by a JSON meta key-value pair. Returns a collection of wrappers.

```APIDOC
## findByMeta()

### Description
Finds scheduled notifications by a JSON meta key-value pair. Returns a collection of wrappers.

### Method
findByMeta

### Parameters
#### Path Parameters
- **$key** (mixed) - Required - JSON meta key
- **$value** (mixed) - Required - Value to match

### Response
#### Success Response
- **Illuminate\Support\Collection** - of wrappers. Uses a `where("meta->{$key}", $value)` JSON query against the `meta` column. Source note: the meta column does not currently use a database index.

### Request Example
```php
ScheduledNotification::findByMeta('order_id', 12345)
    ->each(fn (ScheduledNotification $n) => $n->cancel());
```
```

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

### Timestamp accessor method signatures

Source: https://github.com/thomasjohnkane/snooze

Signatures for accessing timestamp attributes. getSentAt, getCancelledAt, and getRescheduledAt return null when not set; the others always return a date.

```php
public function getSentAt(): Carbon|CarbonImmutable|null
public function getCancelledAt(): Carbon|CarbonImmutable|null
public function getRescheduledAt(): Carbon|CarbonImmutable|null
public function getSendAt(): Carbon|CarbonImmutable
public function getCreatedAt(): Carbon|CarbonImmutable
public function getUpdatedAt(): Carbon|CarbonImmutable
```

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

### Eloquent model properties and casts

Source: https://github.com/thomasjohnkane/snooze

Defines table, serializer, guarded, default attributes, and casts. All attributes are mass-assignable. Meta is cast to array; date columns are cast to CarbonImmutable.

```php
/** @var string */
protected $table;
/** @var Serializer */
protected $serializer;

protected $guarded = [];

protected $attributes = [
    'sent_at' => null,
    'rescheduled_at' => null,
    'cancelled_at' => null,
];

protected $casts = [
    'meta' => 'array',
    'send_at' => 'immutable_datetime',
    'sent_at' => 'immutable_datetime',
    'rescheduled_at' => 'immutable_datetime',
    'cancelled_at' => 'immutable_datetime',
];
```

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

### Console command: snooze:send

Source: https://github.com/thomasjohnkane/snooze

Artisan command that sends due scheduled notifications. It is typically scheduled to run every minute.

```APIDOC
## Console command: snooze:send

### Description
Artisan command that sends due scheduled notifications. It is typically scheduled to run every minute.

### Method
Artisan command

### Endpoint
`php artisan snooze:send`

### Parameters
None documented.

### Response
No documented return value.
```

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

### Boolean status check method signatures

Source: https://github.com/thomasjohnkane/snooze

Signatures for checking whether the notification is sent, cancelled, or rescheduled based on timestamp columns.

```php
public function isSent(): bool
public function isCancelled(): bool
public function isRescheduled(): bool
```

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

### reschedule() method signature

Source: https://github.com/thomasjohnkane/snooze

Declares the public reschedule() method that accepts a sendAt value and an optional force flag. It returns $this and throws NotificationAlreadySentException or NotificationCancelledException when force is falsy and the record is already sent or cancelled.

```php
public function reschedule($sendAt, $force = false): self
```

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

### isSent()

Source: https://github.com/thomasjohnkane/snooze/blob/master/README.md

Checks if a scheduled notification is already sent. Returns a boolean.

```APIDOC
## isSent()

### Description
Checks if a scheduled notification is already sent. Returns a boolean.

### Method
isSent

### Endpoint
$notification->isSent()

### Parameters
None

### Response
Returns a bool.

### Request Example
```php
$result = $notification->isSent(); // returns a bool
```
```

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

### Run snooze:prune manually

Source: https://github.com/thomasjohnkane/snooze

Executes the snooze:prune command manually. It deletes notifications with sent_at or cancelled_at older than pruneAge days in batches of 1000.

```bash
php artisan snooze:prune
```

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

### send()

Source: https://github.com/thomasjohnkane/snooze

Delivers the notification in-place, handling cancellation, already-sent checks, unserialization, interruption, rescheduling, and sending. Throws exceptions for invalid states.

```APIDOC
## send()

### Description
Delivers the notification in-place. The full pipeline: checks cancellation and already-sent, unserializes notifiable and notification, handles interruption and rescheduling, then sends and marks as sent.

### Method
`send()`

### Signature
```php
public function send(): void
```

### Parameters
None.

### Throws
- `NotificationCancelledException` if `cancelled_at !== null`
- `NotificationAlreadySentException` if `sent_at !== null`
- `UnserializeFailedException` on unserialization failure
- `ModelNotFoundException` (unless config dismisses it)

### Example
```php
$model = ScheduledNotification::find(1);
try {
    $model->send();
} catch (\Thomasjohnkane\Snooze\Exception\NotificationAlreadySentException $e) {
    report($e);
}
```
```

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

### sendNow()

Source: https://github.com/thomasjohnkane/snooze

Sends the notification immediately, overwriting the scheduled time. Throws exceptions if the notification is cancelled, already sent, or unserialization fails.

```APIDOC
## sendNow()

### Description
Sends the notification immediately, overwriting the scheduled time. Throws exceptions if the notification is cancelled, already sent, or unserialization fails.

### Method
Instance method

### Signature
`public function sendNow(): void`

### Parameters
None

### Throws
- `NotificationCancelledException`
- `NotificationAlreadySentException`
- `UnserializeFailedException`

### Request Example
```php
try {
    $notification->sendNow();
} catch (NotificationAlreadySentException|NotificationCancelledException $e) {
    report($e);
}
```
```

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

### Schedule anonymous notification with ScheduledNotification::create

Source: https://github.com/thomasjohnkane/snooze/blob/master/README.md

Schedules a notification for an anonymous notifiable that routes directly to mail and SMS channels. Useful when the target is not a model. Schedules for one day from now.

```php
$target = (new AnonymousNotifiable)
    ->route('mail', 'hello@example.com')
    ->route('sms', '56546456566');

ScheduledNotification::create(
     $target, // Target
     new ScheduledNotificationExample($order), // Notification
     Carbon::now()->addDay() // Send At
);
```

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

### scheduleAgainAt()

Source: https://github.com/thomasjohnkane/snooze

Duplicates a scheduled notification and schedules the duplicate at a new send time. Returns a new wrapper around the duplicated record.

```APIDOC
## scheduleAgainAt()

### Description
Duplicates a scheduled notification and schedules the duplicate at a new send time. Returns a new wrapper around the duplicated record.

### Method
Instance method

### Signature
`public function scheduleAgainAt($sendAt): self`

### Parameters
- `$sendAt` (DateTimeInterface|string) - Required - Send time for the duplicated record

### Returns
`self` - a new wrapper around a **duplicated** record (replicated model with `sent_at`, `rescheduled_at`, `cancelled_at` reset to `null` and the new `send_at`).

### Request Example
```php
$new = $notification->scheduleAgainAt(Carbon::now()->addWeek());
```
```

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

### Use SnoozeNotifiable trait and notifyAt method

Source: https://github.com/thomasjohnkane/snooze/blob/master/README.md

Adds the SnoozeNotifiable trait to a model to enable scheduling notifications via notifyAt(). Requires the standard Notifiable trait. Shows scheduling for a birthday, a week from now, and New Year's Eve.

```php
use Thomasjohnkane\Snooze\Traits\SnoozeNotifiable;
use Illuminate\Notifications\Notifiable;

class User extends Model {
    use Notifiable, SnoozeNotifiable;

    // ...
}

// Schedule a birthday notification
$user->notifyAt(new BirthdayNotification, Carbon::parse($user->birthday));

// Schedule for a week from now
$user->notifyAt(new NextWeekNotification, Carbon::now()->addDays(7));

// Schedule for new years eve
$user->notifyAt(new NewYearNotification, Carbon::parse('last day of this year'));
```

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

### Serialize a notifiable object

Source: https://github.com/thomasjohnkane/snooze

Serialize an object (e.g., a user model) using the Serializer. On PostgreSQL, the result is base64-encoded if it contains NUL bytes to avoid corruption in text columns.

```php
$serialized = app(Serializer::class)->serialize($user);

ScheduledNotification::create($target, $notification, Carbon::now()->addDay())
    // -> stores via serialize internally
;
```
Tokens:
Raw