# Ramificare condițională

Fluxurile de lucru pot sări la un pas denumit pe baza rezultatului unui pas anterior. Pentru aceasta, se returnează o cheie specială `_next_step` în valoarea returnată de pas.

Dacă doriți în mod special să reveniți la un pas anterior pe baza stării fluxului de lucru, consultați [Repetări](https://queuety.inline0.dev/ro/docs/workflows/repeats). Astfel, revenirea este specificată explicit în definiția fluxului de lucru, nu ascunsă într-o clasă de pas.

## Pași denumiți

Atribuiți un nume pașilor folosind al doilea argument al `->then()`:

```php
use Queuety\Queuety;

Queuety::workflow( 'process_order' )
    ->then( ValidateOrderHandler::class, 'validate' )
    ->then( ChargePaymentHandler::class, 'charge' )
    ->then( FulfillOrderHandler::class, 'fulfill' )
    ->then( SendConfirmationHandler::class, 'confirm' )
    ->then( HandleFailureHandler::class, 'failure' )
    ->dispatch( [ 'order_id' => 123 ] );
```

Fără un nume explicit, pașii sunt denumiți după indexul lor (`'0'`, `'1'`, `'2'` etc.).

## Cheia `_next_step`

Un pas poate returna `_next_step` pentru a sări la un pas denumit, omițând tot ce se află între ele. Pașii de după ținta saltului continuă să ruleze în ordine: fără un salt, fluxul de lucru continuă pur și simplu cu următorul pas din listă; așadar, în exemplul de mai sus, un pas `confirm` reușit trece la `failure`, cu excepția cazului în care returnează o valoare `_next_step` care îl omite sau dacă `HandleFailureHandler` verifică mai întâi existența unei chei `error`:

```php
use Queuety\Step;

class ValidateOrderHandler implements Step {
    public function handle( array $state ): array {
        $order = wc_get_order( $state['order_id'] );

        if ( ! $order || $order->get_status() === 'cancelled' ) {
            return [
                'error'  => 'Order is invalid or cancelled',
                '_next_step'  => 'failure',
            ];
        }

        return [
            'order_total' => $order->get_total(),
            'customer_id' => $order->get_customer_id(),
        ];
    }

    public function config(): array {
        return [];
    }
}
```

Când `ValidateOrderHandler` returnează `_next_step => 'failure'`, fluxul de lucru omite `charge`, `fulfill` și `confirm`, trecând direct la pasul `failure`. Cheia `_next_step` este preluată de motorul fluxului de lucru și nu este păstrată în stare.

## Modele de ramificare

### Omitere condiționată

```php
class CheckInventoryHandler implements Step {
    public function handle( array $state ): array {
        $in_stock = check_inventory( $state['sku'] );

        if ( ! $in_stock ) {
            return [
                'reason' => 'Out of stock',
                '_next_step'  => 'notify_backorder',
            ];
        }

        return [ 'inventory_reserved' => true ];
    }

    public function config(): array {
        return [];
    }
}
```

### Încheiere anticipată

Săriți la pasul final pentru a omite procesarea inutilă:

```php
class CheckCacheHandler implements Step {
    public function handle( array $state ): array {
        $cached = get_transient( "report_{$state['user_id']}" );

        if ( $cached ) {
            return [
                'report_url' => $cached,
                '_next_step'      => 'done',
            ];
        }

        return [ 'cache_miss' => true ];
    }

    public function config(): array {
        return [];
    }
}
```

## Exemplu complet

```php
Queuety::workflow( 'content_pipeline' )
    ->then( CheckCacheHandler::class, 'check_cache' )
    ->then( FetchDataHandler::class, 'fetch' )
    ->then( CallLLMHandler::class, 'generate' )
    ->then( SaveResultHandler::class, 'save' )
    ->then( ReturnCachedHandler::class, 'done' )
    ->dispatch( [ 'user_id' => 42 ] );
```

Dacă verificarea cache-ului găsește o potrivire, fluxul de lucru trece direct de la `check_cache` la `done`, sărind peste `fetch`, `generate` și `save`. Dacă nu găsește o potrivire, pașii se execută în ordine, iar `save` continuă și în `done`, așa că `ReturnCachedHandler` trebuie să gestioneze ambele situații.