# Vedvarende forsinkelser

Arbejdsgange kan sættes på pause i en fast varighed mellem trin ved hjælp af builder-metoden `delay()`. Forsinkelsestrin er vedvarende: Forsinkelsen gemmes i databasen, så den overlever genstart af workere, udrulninger og genstart af servere.

## Metoden `->delay()`

Tilføj et forsinkelsestrin hvor som helst i arbejdsgangskæden:

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

Arbejdsgangen vil:

1. Køre `SendWelcomeEmailHandler`
2. Vente 1 dag
3. Køre `SendFollowUpEmailHandler`
4. Vente 3 dage
5. Køre `SendFinalEmailHandler`

## Varighedsparametre

Metoden `delay()` accepterer enhver kombination af navngivne varighedsparametre:

| Parameter | Type | Beskrivelse |
|---|---|---|
| `$seconds` | `int` | Sekunder, der ventes |
| `$minutes` | `int` | Minutter, der ventes |
| `$hours` | `int` | Timer, der ventes |
| `$days` | `int` | Dage, der ventes |

Alle værdier lægges sammen. Disse er ækvivalente:

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

Du kan kombinere dem:

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

## Sådan fungerer forsinkelsestrin

Når en arbejdsgang når et forsinkelsestrin, sender Queuety et internt job `__queuety_delay` med kolonnen `available_at` sat til det aktuelle tidspunkt plus forsinkelsens varighed. Jobbet ligger i databasen og tages ikke af nogen worker, før forsinkelsen er gået.

Det betyder:

- **Ingen polling.** Workere kontrollerer ikke forsinkelsen gentagne gange. Jobbet bliver tilgængeligt, når tiden er inde.
- **Intet hukommelsesforbrug.** Intet kører, mens der ventes. Forsinkelsen findes kun som en databasérække.
- **Overlever genstart.** Hvis workeren genstarter, ligger forsinkelsesjobbet stadig i køen med det korrekte tidsstempel `available_at`.

Når forsinkelsesjobbet tages efter forsinkelsen, går arbejdsgangen automatisk videre til næste trin.

## Eksempel: forsinkede notifikationer

Send en påmindelse 1 time efter, at en bruger tilmelder sig, men kun hvis vedkommende ikke har gennemført introduktionen:

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

Trinnet `CheckOnboardingHandler` kan undersøge tilstanden og bruge [betinget forgrening](https://queuety.inline0.dev/da/docs/workflows/conditional) til at springe påmindelsen over, hvis introduktionen allerede er gennemført.

## Eksempel: genforsøg med ventetid

Indsæt bevidste forsinkelser mellem trin, der fungerer som genforsøg:

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

## Flere forsinkelser

En arbejdsgang kan indeholde et vilkårligt antal forsinkelsestrin. Hver forsinkelse er uafhængig og spores med et sekventielt navn (`delay_0`, `delay_1` osv.) i arbejdsgangens tilstand.

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