# Feltételes elágazás

A munkafolyamatok egy korábbi lépés kimenete alapján átugorhatnak egy elnevezett lépésre. Ehhez a lépés visszatérési értékében egy speciális `_next_step` kulcsot kell visszaadni.

Ha kifejezetten vissza szeretne ugrani egy korábbi lépéshez a munkafolyamat állapota alapján, lásd az [Ismétlések](https://queuety.inline0.dev/hu/docs/workflows/repeats) című részt. Így a visszafelé mutató kapcsolat egyértelmű marad a munkafolyamat definíciójában, ahelyett, hogy egy lépésosztályba lenne rejtve.

## Elnevezett lépések

A `->then()` második argumentumával adhat nevet a lépéseknek:

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

Ha nem ad meg nevet, a lépések az indexük alapján kapnak nevet (`'0'`, `'1'`, `'2'` stb.).

## A `_next_step` kulcs

Egy lépés a `_next_step` visszaadásával ugorhat egy elnevezett lépésre, átugorva az összes köztes lépést. Az ugrás célpontja utáni lépések továbbra is sorrendben futnak: ugrás nélkül a munkafolyamat egyszerűen a lista következő lépésével folytatódik, ezért a fenti példában a sikeres `confirm` lépést a `failure` követi, hacsak nem ad vissza olyan `_next_step` értéket, amely átugorja, vagy a `HandleFailureHandler` előbb meg nem vizsgál egy `error` kulcsot:

```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 [];
    }
}
```

Amikor a `ValidateOrderHandler` a `_next_step => 'failure'` értéket adja vissza, a munkafolyamat átugorja a `charge`, `fulfill` és `confirm` lépést, majd közvetlenül a `failure` lépésre ugrik. A munkafolyamat-motor felhasználja a `_next_step` kulcsot, ezért az nem kerül az állapotba.

## Elágazási minták

### Átugrás feltétel esetén

```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 [];
    }
}
```

### Korai befejezés

Ugorjon az utolsó lépésre a szükségtelen feldolgozás átugrásához:

```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 [];
    }
}
```

## Teljes példa

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

Ha a gyorsítótár-ellenőrzés találatot jelez, a munkafolyamat a `check_cache` lépésről közvetlenül a `done` lépésre ugrik, átugorva a `fetch`, `generate` és `save` lépést. Találat hiányában a lépések sorrendben futnak, és a `save` lépés a `done` lépésre esik át, ezért a `ReturnCachedHandler` lépésnek mindkét útvonalat kezelnie kell.