# Întârzieri durabile

Fluxurile de lucru pot face o pauză de durată fixă între pași, folosind metoda constructorului `delay()`. Pașii de întârziere sunt durabili: întârzierea este stocată în baza de date, deci supraviețuiește repornirilor worker-elor, implementărilor și repornirilor serverului.

## Metoda `->delay()`

Adăugați un pas de întârziere oriunde în lanțul fluxului de lucru:

```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 ] );
```

Fluxul de lucru va:

1. Rula `SendWelcomeEmailHandler`
2. Aștepta 1 zi
3. Rula `SendFollowUpEmailHandler`
4. Aștepta 3 zile
5. Rula `SendFinalEmailHandler`

## Parametrii duratei

Metoda `delay()` acceptă orice combinație de parametri de durată cu nume:

| Parametru | Tip | Descriere |
|---|---|---|
| `$seconds` | `int` | Secunde de așteptare |
| `$minutes` | `int` | Minute de așteptare |
| `$hours` | `int` | Ore de așteptare |
| `$days` | `int` | Zile de așteptare |

Toate valorile se adună. Aceste exemple sunt echivalente:

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

Le puteți combina:

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

## Cum funcționează pașii de întârziere

Când un flux de lucru ajunge la un pas de întârziere, Queuety trimite un job intern `__queuety_delay`, cu coloana `available_at` setată la ora curentă plus durata întârzierii. Jobul rămâne în baza de date și niciun worker nu îl preia până la expirarea întârzierii.

Aceasta înseamnă că:

- **Fără verificări repetate.** Worker-ele nu verifică întârzierea în mod repetat. Jobul devine pur și simplu disponibil la momentul potrivit.
- **Fără consum de memorie.** Nimic nu rulează în timpul așteptării. Întârzierea există doar ca rând în baza de date.
- **Supraviețuiește repornirilor.** Dacă worker-ul repornește, jobul cu întârziere rămâne în coadă cu marcajul temporal `available_at` corect.

Când jobul cu întârziere este preluat după expirarea acesteia, fluxul de lucru avansează automat la pasul următor.

## Exemplu: notificări întârziate

Trimiteți un memento la 1 oră după înregistrarea unui utilizator, dar numai dacă acesta nu a finalizat onboarding-ul:

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

Pasul `CheckOnboardingHandler` poate inspecta starea și folosi [ramificarea condițională](https://queuety.inline0.dev/ro/docs/workflows/conditional) pentru a omite mementoul dacă onboarding-ul este deja finalizat.

## Exemplu: reîncercare cu interval progresiv

Introduceți întârzieri deliberate între pașii de reîncercare:

```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' ] );
```

## Întârzieri multiple

Un flux de lucru poate conține oricâți pași de întârziere. Fiecare întârziere este independentă și este urmărită în starea fluxului de lucru cu un nume secvențial (`delay_0`, `delay_1` etc.).

```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 );
```