Den Component har længe været en af rammernes mest kraftfulde, men underudnyttede, perler. Det giver udviklere mulighed for at afkoble forretningsprocessens logik fra entitetstilstanden og omdanne komplekse "spaghetti-kode" statuskontroller til rene, visualiserbare rettede diagrammer. symfony/workflow I årevis havde komponenten imidlertid en streng begrænsning, der var forankret i dens implementering af Petri-net: Et objekt var enten på et sted (tilstand), eller det var det ikke. Mens du kunne være på flere steder samtidig (parallel behandling), kunne du ikke være på samme sted flere gange. Tokens were boolean Symfony 7.4 changes the game with Weighted Transitions. Denne nye model introducerer Du kan nu modellere scenarier, hvor mængder betyder noget: "indsamle 4 signaturer", "proces 5 batch elementer" eller "vente på 3 delsystemer til at initialisere." multiplicity I denne artikel vil vi bygge en stærk Vi vil udforske, hvordan man konfigurerer vægtede overgange, implementerer entitetslogikken og verificerer strømmen med streng testning – alt sammen ved hjælp af Symfony 7.4 og PHP 8.3. Multi-Signature Approval System Konceptet (Petri Nets vs. State Machines) Før du skriver kode, er det vigtigt at forstå, hvorfor denne funktion eksisterer. Den statslige maskine begrænsning En statsmaskine er lineær; en elevator er også , der eller Det kan ikke være Dette er perfekt til enklere statusser (f.eks. ) af STOPPED MOVING_UP MOVING_DOWN MOVING_UP Order::STATUS_PAID Arbejdsprocessen (Petri Net) A er I en "New Employee Onboarding"-proces kan en medarbejder samtidig være i: Workflow 
 
 
 Udstyret - Laptops Oprettelse af e-mail-konto Begge skal være færdige, før de flytter til . onboarded Det manglende stykke: Multiplicitet Før Symfony 7.4, hvis du havde brug for "3 ledere til at godkende en udgift," kunne du ikke model dette rent i arbejdsprocessen. 
 
 
 
 Opret en waiting_for_approval placering. Tilføj et talfelt til din enhed ($approvalCount). Brug en Guard Event-hører til at tjekke, om ($subject->getApprovalCount() >= 3) før du tillader overgangen. med Den » ” er nu en del af selve arbejdsprocessens tilstand. Arbejdsprocesmotoren forstår nativt, at emnet er i Staten 3 gange. Weighted Transitions counter approved Projektopbygning Lad os skabe et nyt Symfony-projekt og installere de nødvendige komponenter. composer create-project symfony/skeleton:"7.4.*" fintech-approval
cd fintech-approval
composer require symfony/workflow symfony/framework-bundle symfony/orm-pack symfony/maker-bundle
 For dette eksempel vil vi bruge SQLite til enkelhed, men logikken gælder for MySQL/PostgreSQL nøjagtigt det samme. # .env
DATABASE_URL="sqlite:///%kernel.project_dir%/var/data.db"
 Den grundlæggende logik (The Core Logic) Vi vil definere en arbejdsproces kaldet expense_approval. The Scenario: 
 
 
 
 
 
 Der udarbejdes en udgiftsrapport (udkast). Det er indsendt (review_required) Vægtet trin: Systemet distribuerer anmodningen til 3 krævede godkendere. Hvert medlem giver individuelt godkendelse. Når 3 godkendelser er indsamlet, flyttes udgiften til ready_for_payment. Opret eller opdater : config/packages/workflow.yaml # config/packages/workflow.yaml
framework:
    workflows:
        expense_approval:
            type: workflow # MUST be 'workflow', not 'state_machine'
            audit_trail:
                enabled: true
            marking_store:
                type: method
                property: currentState # This must hold an array
            
            supports:
                - App\Entity\ExpenseReport

            initial_marking: draft

            places:
                - draft
                - review_pool
                - approved_pool
                - ready_for_payment
                - rejected

            transitions:
                submit:
                    from: draft
                    to:
                        - place: review_pool
                          weight: 3 # <--- OUTPUT WEIGHT
                          
                approve:
                    from: review_pool
                    to: approved_pool
                    # Default weight is 1. One 'review_pool' token becomes one 'approved_pool' token.

                reject:
                    from: review_pool
                    to: rejected
                    # If rejected, we might want to clear all tokens, 
                    # but for simplicity, one rejection moves to rejected.

                finalize:
                    from:
                        - place: approved_pool
                          weight: 3 # <--- INPUT WEIGHT
                    to: ready_for_payment
 Destruktion af konfig 
 
 
 
 
 Type: arbejdsproces: Vægtede overgange er afhængige af tokenbuckets. Dette er ikke muligt i en statskasse. submitTransition:- til: {sted: review_pool, vægt: 3 } - Når dette brænder, thereview_poolplace modtager 3 tokens.- Tænk på dette som at skabe3 "billetter", der skal sparkes. approveTransition:-fra: review_pool, til: approved_pool.- Standard 1-til-1 vægt.- Fordi vi har 3 tokens inreview_pool, kan vi skyde denne overgang 3 gange. finalizeTransition:- fra: {sted: godkendt_pool, vægt: 3 }- Denne overgang er blokeret, indtil den godkendte_pool indeholder nøjagtigt (eller mindst) 3 tokens.- Når 3. godkendelse kommer ind, låser denne vej op. Den enhed Vi har brug for en enhed, der understøtter denne "Multi-State" mærkning butik. ejendom skal være en matrix til at holde token tæller (f.eks., ) af currentState [‘review_pool’ => 2, ‘approved_pool’ => 1] 
namespace App\Entity;

use App\Repository\ExpenseReportRepository;
use Doctrine\ORM\Mapping as ORM;

#[ORM\Entity(repositoryClass: ExpenseReportRepository::class)]
class ExpenseReport
{
    #[ORM\Id]
    #[ORM\GeneratedValue]
    #[ORM\Column]
    private ?int $id = null;

    #[ORM\Column(length: 255)]
    private string $description;

    #[ORM\Column]
    private float $amount;

    /**
     * Stores the workflow state.
     * For Weighted Workflows, this stores the places and their quantities.
     * Example DB content: {"review_pool": 2, "approved_pool": 1}
     */
    #[ORM\Column(type: 'json')]
    private array $currentState = [];

    public function __construct(string $description, float $amount)
    {
        $this->description = $description;
        $this->amount = $amount;
        // Initial marking is handled by the workflow component, 
        // but initializing to empty array is good practice.
    }

    public function getId(): ?int
    {
        return $this->id;
    }

    public function getDescription(): string
    {
        return $this->description;
    }

    public function getAmount(): float
    {
        return $this->amount;
    }

    public function getCurrentState(): array
    {
        return $this->currentState;
    }

    public function setCurrentState(array $currentState): self
    {
        $this->currentState = $currentState;
        return $this;
    }
}
 Kør migrationen i gang: php bin/console make:migration
php bin/console doctrine:migrations:migrate
 Tjenesten Layer For at interagere med denne arbejdsproces rent, bør vi oprette en tjeneste. Denne tjeneste vil håndtere logikken om "hvem" er godkendelse, men for denne tutorial vil vi fokusere på arbejdsprocessens mekanik. 
namespace App\Service;

use App\Entity\ExpenseReport;
use Symfony\Component\Workflow\WorkflowInterface;
use Symfony\Component\Workflow\Registry;

readonly class ExpenseManager
{
    public function __construct(
        private Registry $workflowRegistry,
    ) {}

    public function submit(ExpenseReport $expense): void
    {
        $workflow = $this->getWorkflow($expense);
        
        if ($workflow->can($expense, 'submit')) {
            $workflow->apply($expense, 'submit');
        } else {
            throw new \LogicException('Cannot submit this expense report.');
        }
    }

    public function approve(ExpenseReport $expense): void
    {
        $workflow = $this->getWorkflow($expense);

        // In a real app, you would check "Is the current user one of the allowed approvers?" here.
        
        if ($workflow->can($expense, 'approve')) {
            $workflow->apply($expense, 'approve');
            
            // Check if we can auto-finalize (if 3 approvals are met)
            if ($workflow->can($expense, 'finalize')) {
                $workflow->apply($expense, 'finalize');
            }
        } else {
            throw new \LogicException('Approval not needed or not allowed.');
        }
    }
    
    public function getStatus(ExpenseReport $expense): array
    {
        // returns something like ['review_pool' => 2, 'approved_pool' => 1]
        return $expense->getCurrentState();
    }

    private function getWorkflow(ExpenseReport $expense): WorkflowInterface
    {
        return $this->workflowRegistry->get($expense, 'expense_approval');
    }
}
 Logikken i “Auto-Finalize” Bemærk godkendelsesmetoden. Efter at have anvendt godkendelse, tjekker vi straks kan ($udgifter, ‘finalisere’). 
 
 
 
 FirstApproval:-review_pool: 2-approved_pool: 1-finalize behøver 3 approved_pool. kan(‘finalize’) returnerer falsk. SecondApproval:-review_pool: 1-approved_pool: 2-can(‘finalize’) returnerer falsk. ThirdApproval:review_pool: 0approved_pool: 3finalize behov 3. kan(‘finalize’) returnerer true.We applyfinalize.New State:ready_for_payment: 1. Visualisering af arbejdsprocessen Før testning er det utroligt nyttigt at visualisere grafen, især med vægte involveret. php bin/console workflow:dump expense_approval | dot -Tpng -o workflow.png
 Du har brug for graphviz installeret på din maskine for at bruge dot. Hvis du ikke har det, kan du indsætte tekstudgangen i en online Graphviz viewer. Udgangen vil visuelt repræsentere pilene med mærker som vægt: 3, hvilket gør det klart, at den indsendte overgang giver anledning til flere tokens. Verifikation af enheden (Unit Testing) Vi håber ikke bare, at det virker; vi beviser det. at indlæse den faktiske arbejdsproceskonfiguration og teste overgangene. KernelTestCase //tests/Workflow/ExpenseApprovalWorkflowTest.php
namespace App\Tests\Workflow;

use App\Entity\ExpenseReport;
use Symfony\Bundle\FrameworkBundle\Test\KernelTestCase;
use Symfony\Component\Workflow\WorkflowInterface;

class ExpenseApprovalWorkflowTest extends KernelTestCase
{
    private WorkflowInterface $workflow;

    protected function setUp(): void
    {
        self::bootKernel();
        $container = static::getContainer();
        $registry = $container->get('workflow.registry');
        
        // We create a dummy subject to get the workflow
        // In a real app, passing the class name to the registry is preferred if supported,
        // or fetching by name directly if you have a custom service alias.
        $subject = new ExpenseReport('Test', 100.0);
        $this->workflow = $registry->get($subject, 'expense_approval');
    }

    public function testWeightedApprovalFlow(): void
    {
        $expense = new ExpenseReport('MacBook Pro', 3000.00);

        // 1. Initial State
        $this->assertTrue($this->workflow->can($expense, 'submit'));
        $this->workflow->apply($expense, 'submit');

        // Verify tokens: Should be in review_pool 3 times
        $marking = $expense->getCurrentState();
        $this->assertArrayHasKey('review_pool', $marking);
        $this->assertEquals(3, $marking['review_pool'], 'Should have 3 pending reviews');

        // 2. First Approval
        $this->assertTrue($this->workflow->can($expense, 'approve'));
        $this->workflow->apply($expense, 'approve');
        
        $marking = $expense->getCurrentState();
        $this->assertEquals(2, $marking['review_pool']);
        $this->assertEquals(1, $marking['approved_pool']);

        // Check that we CANNOT finalize yet (need 3 approvals)
        $this->assertFalse($this->workflow->can($expense, 'finalize'), 'Should not finalize with only 1 approval');

        // 3. Second Approval
        $this->workflow->apply($expense, 'approve');
        $marking = $expense->getCurrentState();
        $this->assertEquals(1, $marking['review_pool']);
        $this->assertEquals(2, $marking['approved_pool']);

        // 4. Third Approval
        $this->workflow->apply($expense, 'approve');
        $marking = $expense->getCurrentState();
        
        // At this specific moment, review_pool is 0, approved_pool is 3
        $this->assertEquals(0, $marking['review_pool'] ?? 0);
        $this->assertEquals(3, $marking['approved_pool']);

        // 5. Finalize
        $this->assertTrue($this->workflow->can($expense, 'finalize'), 'Should be able to finalize now');
        $this->workflow->apply($expense, 'finalize');

        // 6. Verify End State
        $marking = $expense->getCurrentState();
        $this->assertArrayHasKey('ready_for_payment', $marking);
        $this->assertEquals(1, $marking['ready_for_payment']);
        // Previous tokens should be consumed
        $this->assertArrayNotHasKey('approved_pool', $marking);
    }
}
 Løb med testen: php bin/phpunit tests/Workflow/ExpenseApprovalWorkflowTest.php
 Avanceret brug og bedste praksis Brug af enumer til steder (Ny i 7.4) Symfony 7.4 tilføjer også understøttelse af Backed Enums i arbejdsprocesser. ”Du skal definere en enhed. review_pool namespace App\Enum;

enum ExpenseState: string
{
    case DRAFT = 'draft';
    case REVIEW_POOL = 'review_pool';
    case APPROVED_POOL = 'approved_pool';
    case READY = 'ready_for_payment';
    case REJECTED = 'rejected';
}
 Du kan derefter opdatere din workflow.yaml (selvom YAML stadig bruger strenge, kan din PHP-kode bruge ) af ExpenseState::REVIEW_POOL->value Håndværker med vægte Måske vil du forhindre det samme fra godkendelse 3 gange. Vægtede overgange tillader overgangen at blive kaldt 3 gange, men arbejdsprocesmotoren ved iboende ikke, hvem der kaldte det. person approve For at løse dette skal du bruge en Guard Listener. #[AsEventListener('workflow.expense_approval.guard.approve')]
public function preventDoubleApproval(GuardEvent $event): void
{
    /** @var ExpenseReport $expense */
    $expense = $event->getSubject();
    $user = $this->security->getUser();

    // Imagine the entity has a list of who already approved
    if ($expense->hasApproved($user)) {
        $event->setBlocked(true, 'You have already approved this expense.');
    }
}
 Afvisning af håndtering (Token Cleanup) En udfordring med vægtede tokens er rengøring. Hvis vi har 2 godkendelser og den 3. person ringer , hvad sker der med de 2 tokens, der sidder i ? reject approved_pool I en standard arbejdsproces, flytte til Kan forlade disse tokens straggling (oprettelse af en zombie tilstand, hvor rapporten er både afvist og delvist godkendt). rejected approved_pool Den Ideelt set skal forbruget Men dynamisk forbrug understøttes ikke udelukkende i YAML (du kan ikke sige "forbruge ALLE"). reject all Brug af en Event Subscriber , kan du manuelt nulstille markeringsbutikken. workflow.entered.rejected public function onRejected(Event $event): void
{
    $expense = $event->getSubject();
    // Force reset state to ONLY rejected
    $expense->setCurrentState(['rejected' => 1]);
}
 Konklusionen Symfoniens 7.4 Ved at tillade flere instanser af en stat (tokens) at eksistere samtidig, kan vi nu model stemme systemer, fremstilling monteringslinjer, og batch behandling logik direkte i konfigurationen, drastisk reducere mængden af brugerdefineret PHP boilerplate krævet. Weighted Workflow Transitions Key Takeaways: 
 
 
 
 
 Multiplicitet: Steder kan indeholde flere tokens, hvilket muliggør parallel akkumulering af tilstand. Konfiguration: Brug vægt i din til (udgang) og fra (indgang) definitioner til at styre token flow. Opbevaring: Sørg for, at din Marking Store-egenskab er en matrix (f.eks. en JSON-kolonne) for at spore tokental pr. placering. Verifikation: Brug altid kommandoen workflow:dump og skriv KernelTestCase-tests for at bevise din graflogik før implementering. Denne funktion styrker Symfony's Workflow-komponent som den førende PHP-løsning til state management, så du kan slette skrøbelige "counter" egenskaber og stole på en matematisk sund arkitektur. Lad os være i berøring Vedtagelse af disse avancerede mønstre kan forenkle din domæne logik betydeligt, men overgangen er ikke altid indlysende.Hvis du ønsker at modernisere din Symfony stack, har brug for et andet par øjne på din arkitektur, eller bare ønsker at geek ud over de nyeste Petri net implementeringer, vil jeg elske at høre fra dig. Kontakt mig på LinkedIn ( ) for at fortsætte samtalen om moderne PHP arkitektur. https://www.linkedin.com/in/matthew-mochalkin/ https://www.linkedin.com/in/matthew-mochalkin/

Read My Stories

Denne lyd er produceret på historiens originalsprog!

Sådan opbygger du et FinTech-godkendelsessystem med Symfony 7.4

About Author

KOMMENTARER

HÆNG TAGS

DENNE ARTIKEL BLEV PRÆsenterET I

Related Stories

Meet MinIO: The HackerNoon Company of the Week

Meet Octopus Network: HackerNoon Company of the Week

Meet HubSpot: HackerNoon Company of the Week

Meet Hubstaff: HackerNoon Company of the Week

Meet MinIO: The HackerNoon Company of the Week

Meet Octopus Network: HackerNoon Company of the Week

Meet HubSpot: HackerNoon Company of the Week

Meet Hubstaff: HackerNoon Company of the Week

Light-Mode

Classic

Newspaper

Minty

Dark-Mode

Neon Noir

Minty

HN StartUps