Treci la conținut

Ramificare condițională

Vizualizați ca Markdown Editați pe GitHub Documentație la 2cc7b2b

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. 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.