# Beständiga fördröjningar

Arbetsflöden kan pausas under en fast tid mellan steg med byggarmetoden `delay()`. Fördröjningsstegen är beständiga: fördröjningen lagras i databasen och finns därför kvar efter omstarter av arbetare, driftsättningar och omstarter av servern.

## Metoden `->delay()`

Lägg till ett fördröjningssteg var som helst i arbetsflödeskedjan:

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

Arbetsflödet kommer att:

1. Köra `SendWelcomeEmailHandler`
2. Vänta 1 dag
3. Köra `SendFollowUpEmailHandler`
4. Vänta 3 dagar
5. Köra `SendFinalEmailHandler`

## Varaktighetsparametrar

Metoden `delay()` accepterar valfri kombination av namngivna varaktighetsparametrar:

| Parameter | Typ | Beskrivning |
|---|---|---|
| `$seconds` | `int` | Sekunder att vänta |
| `$minutes` | `int` | Minuter att vänta |
| `$hours` | `int` | Timmar att vänta |
| `$days` | `int` | Dagar att vänta |

Alla värden summeras. De här exemplen är likvärdiga:

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

Du kan kombinera dem:

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

## Så fungerar fördröjningssteg

När ett arbetsflöde når ett fördröjningssteg skickar Queuety ett internt jobb av typen `__queuety_delay` med kolumnen `available_at` satt till den aktuella tiden plus fördröjningens varaktighet. Jobbet ligger i databasen och hämtas inte av någon arbetare förrän fördröjningen har löpt ut.

Det innebär att:

- **Ingen polling.** Arbetarna kontrollerar inte fördröjningen upprepade gånger. Jobbet blir helt enkelt tillgängligt när tiden är inne.
- **Ingen minnesanvändning.** Inget körs under väntetiden. Fördröjningen finns bara som en databasrad.
- **Överlever omstarter.** Om arbetaren startas om ligger fördröjningsjobbet fortfarande i kön med rätt tidsstämpel `available_at`.

När fördröjningsjobbet hämtas efter fördröjningen går arbetsflödet automatiskt vidare till nästa steg.

## Exempel: fördröjda aviseringar

Skicka en påminnelse 1 timme efter att en användare registrerat sig, men bara om hen inte har slutfört introduktionen:

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

Steget `CheckOnboardingHandler` kan granska tillståndet och använda [villkorsstyrd förgrening](https://queuety.inline0.dev/sv/docs/workflows/conditional) för att hoppa över påminnelsen om introduktionen redan är slutförd.

## Exempel: återförsök med ökande väntetid

Lägg in avsiktliga fördröjningar mellan steg som liknar återförsök:

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

## Flera fördröjningar

Ett arbetsflöde kan innehålla valfritt antal fördröjningssteg. Varje fördröjning är fristående och spåras med ett sekventiellt namn (`delay_0`, `delay_1` osv.) i arbetsflödets tillstånd.

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