# Pauses durables

Les flux de travail peuvent être mis en pause pendant une durée fixe entre les étapes à l’aide de la méthode de générateur `delay()`. Les étapes de pause sont durables : la pause est enregistrée dans la base de données et résiste donc aux redémarrages des workers, aux déploiements et aux redémarrages du serveur.

## La méthode `->delay()`

Ajoutez une étape de pause à n’importe quel endroit de la chaîne du flux de travail :

```php
use Queuety\Queuety;

Queuety::workflow( 'drip_campaign' )
    ->then( SendWelcomeEmailHandler::class )
    ->delay( days: 1 )
    ->then( SendFollowUpEmailHandler::class )
    ->delay( days: 3 )
    ->then( SendFinalEmailHandler::class )
    ->dispatch( [ 'user_id' => 42 ] );
```

Le flux de travail va :

1. Exécuter `SendWelcomeEmailHandler`
2. Attendre 1 jour
3. Exécuter `SendFollowUpEmailHandler`
4. Attendre 3 jours
5. Exécuter `SendFinalEmailHandler`

## Paramètres de durée

La méthode `delay()` accepte toute combinaison de paramètres de durée nommés :

| Paramètre | Type | Description |
|---|---|---|
| `$seconds` | `int` | Nombre de secondes d’attente |
| `$minutes` | `int` | Nombre de minutes d’attente |
| `$hours` | `int` | Nombre d’heures d’attente |
| `$days` | `int` | Nombre de jours d’attente |

Toutes les valeurs sont additionnées. Voici des valeurs équivalentes :

```php
->delay( seconds: 3600 )
->delay( minutes: 60 )
->delay( hours: 1 )
```

Vous pouvez les combiner :

```php
->delay( hours: 1, minutes: 30 ) // 90 minutes total
```

## Fonctionnement des étapes de pause

Lorsqu’un flux de travail atteint une étape de pause, Queuety met en file une tâche interne `__queuety_delay` dont la colonne `available_at` est définie sur l’heure actuelle plus la durée de la pause. La tâche reste dans la base de données et aucun worker ne la prend en charge avant la fin de la pause.

Cela signifie que :

- **Aucune interrogation répétée.** Les workers ne vérifient pas la pause en boucle. La tâche devient simplement disponible à l’heure prévue.
- **Aucune utilisation de mémoire.** Rien ne s’exécute pendant l’attente. La pause n’existe que sous forme de ligne dans la base de données.
- **Résiste aux redémarrages.** Si le worker redémarre, la tâche de pause reste dans la file avec l’horodatage `available_at` correct.

Lorsque la tâche de pause est prise en charge après la pause, le flux de travail passe automatiquement à l’étape suivante.

## Exemple : notifications différées

Envoyez un rappel 1 heure après l’inscription d’un utilisateur, mais uniquement s’il n’a pas terminé l’intégration :

```php
Queuety::workflow( 'onboarding_reminder' )
    ->then( CreateAccountHandler::class )
    ->delay( hours: 1 )
    ->then( CheckOnboardingHandler::class )
    ->then( SendReminderHandler::class )
    ->dispatch( [ 'email' => 'user@example.com' ] );
```

L’étape `CheckOnboardingHandler` peut examiner l’état et utiliser le [branchement conditionnel](https://queuety.inline0.dev/fr/docs/workflows/conditional) pour ignorer le rappel si l’intégration est déjà terminée.

## Exemple : nouvelle tentative avec temporisation exponentielle

Insérez des pauses délibérées entre les étapes de nouvelle tentative :

```php
Queuety::workflow( 'poll_external_api' )
    ->then( CheckStatusHandler::class, 'check' )
    ->delay( minutes: 5 )
    ->then( CheckStatusHandler::class, 'recheck' )
    ->delay( minutes: 15 )
    ->then( CheckStatusHandler::class, 'final_check' )
    ->then( ProcessResultHandler::class )
    ->dispatch( [ 'external_id' => 'abc-123' ] );
```

## Pauses multiples

Un flux de travail peut contenir autant d’étapes de pause que nécessaire. Chaque pause est indépendante et suivie par un nom séquentiel (`delay_0`, `delay_1`, etc.) dans l’état du flux.

```php
Queuety::workflow( 'multi_step_drip' )
    ->then( StepA::class )
    ->delay( hours: 2 )
    ->then( StepB::class )
    ->delay( days: 1 )
    ->then( StepC::class )
    ->delay( minutes: 30 )
    ->then( StepD::class )
    ->dispatch( $payload );
```