Hoppa till innehåll

Villkorsstyrd förgrening

Visa som Markdown Redigera på GitHub Dokumentation på 2cc7b2b

Arbetsflöden kan hoppa till ett namngivet steg baserat på utdata från ett tidigare steg. Det görs genom att returnera en särskild nyckel _next_step i stegets returvärde.

Om du specifikt vill hoppa tillbaka till ett tidigare steg baserat på arbetsflödestillståndet kan du läsa om Upprepningar. Då är bakåtkanten uttrycklig i arbetsflödesdefinitionen i stället för dold i en stegklass.

Namngivna steg

Ge stegen ett namn genom att använda det andra argumentet till ->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 ] );

Utan ett uttryckligt namn får stegen namn efter sitt index ('0', '1', '2' osv.).

Nyckeln _next_step

Ett steg kan returnera _next_step för att hoppa till ett namngivet steg och förbigå allt däremellan. Stegen efter hoppmålet körs fortfarande i ordning: utan ett hopp fortsätter arbetsflödet helt enkelt med nästa steg i listan, så i exemplet ovan går ett slutfört steg confirm vidare till failure, såvida det inte returnerar ett _next_step som hoppar över det eller HandleFailureHandler först kontrollerar om det finns en nyckel 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 [];
    }
}

När ValidateOrderHandler returnerar _next_step => 'failure' hoppar arbetsflödet över charge, fulfill och confirm och går direkt till steget failure. Nyckeln _next_step används av arbetsflödesmotorn och sparas inte i tillståndet.

Förgreningsmönster

Hoppa över vid villkor

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

Avsluta i förtid

Hoppa till det sista steget för att hoppa över onödig bearbetning:

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

Fullständigt exempel

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

Om cachekontrollen hittar en träff går arbetsflödet direkt från check_cache till done och hoppar över fetch, generate och save. Vid en miss körs stegen i ordning och save fortsätter även till done, så ReturnCachedHandler måste hantera båda vägarna.