The זה מאפשר למפתחים לנתק את ההיגיון של התהליך העסקי מהמצב של הישות, ולהפוך בדיקות סטטוס מורכבות של "קוד ספגטי" לתוך תרשימים ממוקדים נקיים, חזותיים. symfony/workflow במשך שנים, עם זאת, לרכיב היו מגבלות קפדניות השוררות ביישום של רשתות פטרי: אובייקט היה במקום אחד (מצב), או שהוא לא היה, בעוד שאתה יכול להיות במקומות מרובים בו זמנית (עיבוד מקביל), אתה לא יכול להיות באותו מקום כמה פעמים. Tokens were boolean Symfony 7.4 changes the game with Weighted Transitions. תכונה חדשה זו מציגה כעת ניתן למודל תסריטים שבהם הכמויות חשובות: "אסוף 4 חתימות", "תהליך 5 פריטים במלאי", או "מתין 3 תת-מערכות להתחיל". multiplicity במאמר זה ננסה לבנות מערכת חזקה אנו נחקור כיצד להגדיר מעברים משומשים, ליישם את ההיגיון של הישות, ולאמת את הזרימה באמצעות בדיקות קפדניות – הכל באמצעות Symfony 7.4 ו- PHP 8.3. Multi-Signature Approval System המושג (פטרי נטס נגד מכונות המדינה) לפני כתיבת קוד, חשוב להבין מדוע תכונה זו קיימת. הגבלת מכונת המדינה מכונת מדינה היא ליניארית; מעלית היא גם , או זה לא יכול להיות זה מושלם עבור סטטוסים פשוטים יותר (למשל, ) STOPPED MOVING_UP MOVING_DOWN MOVING_UP Order::STATUS_PAID תנועת העבודה (Petri Net) א אפשרות זו מאפשרת לאובייקט לשבת במקומות מרובים בו זמנית.בתהליך "הכנסת עובד חדש", עובד עשוי להיות בו זמנית: Workflow 
 
 
 מחשב נייד - Laptop יצירת חשבון - Email שניהם חייבים להסתיים לפני שהם עוזבים. . onboarded החלק החסר: המוניטין לפני סימפוניה 7.4, אם הייתם זקוקים ל"שלושה מנהלים כדי לאשר הוצאות", לא הייתם יכולים לעצב את זה רק בתהליך העבודה. 
 
 
 
 יצירת מיקום waiting_for_approval. הוסף שדה מחשב לאנשיות שלך ($approvalCount). השתמש ב- Guard Event Listener כדי לבדוק אם ($subject->getApprovalCount() >= 3) לפני המאפשר את המעבר. עם » The » "עכשיו הוא חלק מהמצב של זרימת העבודה עצמה.מנוע זרימת העבודה מבין באופן מקורי שהנושא נמצא במצב מדינה 3 פעמים. Weighted Transitions counter approved פרוייקט Setup בואו ליצור פרויקט סימפוניה חדש ולהתקין את הרכיבים הדרושים. 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
 לדוגמה זו, נשתמש SQLite עבור הפשטות, אבל ההיגיון חל על MySQL / PostgreSQL בדיוק אותו דבר. # .env
DATABASE_URL="sqlite:///%kernel.project_dir%/var/data.db"
 הבסיס לוגי (The Core Logic) זהו המקום שבו הקסם מתרחש.אנו נקבע זרימת עבודה בשם expense_approval. The Scenario: 
 
 
 
 
 
 נוצר דוח על הוצאות (פרויקט). הוא נשלח (review_required) שלב משקל: המערכת מעבירה את הבקשה לשלוש אישורים נדרשים. כל אדם מקבל אישור בנפרד. לאחר שנאספו 3 אישורים, העלות עוברת ל- ready_for_payment. ליצור או לעדכן : 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
 להוריד את Config 
 
 
 
 
 סוג: זרימת עבודה: מעברים משומשים מסתמכים על קופסאות טוקן. submitTransition:- to: {place: review_pool, weight: 3 } - כאשר זה נשרף, thereview_poolplace מקבל 3 תוויות.- תחשבו על זה כמו יצירת3 "טיפים" שצריך להכות. approveTransition:-from: review_pool, to: approved_pool.- סטנדרטי 1-to-1 משקל.- כי יש לנו 3 תוויות inreview_pool, אנחנו יכולים לירות את המעבר הזה 3 פעמים. finalizeTransition:- מ: {מקום: approved_pool, משקל: 3 }- מעבר זה נסגר עד theapproved_poolהוא מכיל בדיוק (או לפחות) 3 תוויות.- ברגע שהאישור השלישי מגיע, נפתח נתיב זה. הישות אנחנו צריכים ישות שתומכת בחנות המותג הזה "מדינות רבות". רכוש חייב להיות מספר כדי להחזיק את חשבונות הטוקן (למשל, ) 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;
    }
}
 עקבו אחרי Migration Migration: php bin/console make:migration
php bin/console doctrine:migrations:migrate
 Layer שירות כדי לקיים אינטראקציה עם זרימת העבודה זו בצורה נקיה, עלינו ליצור שירות.השירות הזה יטפל בהיגיון של "מי" מאשר, אם כי עבור הדרכה זו, נתרכז במכניקת זרימת העבודה. 
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');
    }
}
 ההיגיון של "אוטו-סוף" לאחר יישום אישור, אנו בודקים מיד יכול ($expense, ‘finalize’). 
 
 
 
 FirstApproval:-review_pool: 2-approved_pool: 1-finalize needs 3 approved_pool. can(‘finalize’) חוזר לא נכון. SecondApproval:-review_pool: 1-approved_pool: 2-can(‘finalize’) מחזיר שקר. ThirdApproval:review_pool: 0approved_pool: 3finalize needs 3. can(‘finalize’) מחזיר true.We applyfinalize.New State:ready_for_payment: 1. ויזואליזציה של זרימת העבודה לפני הבדיקה, זה מאוד שימושי כדי לדמיין את הגרף, במיוחד עם משקלים מעורבים. php bin/console workflow:dump expense_approval | dot -Tpng -o workflow.png
 אתה צריך graphviz מותקן על המחשב שלך כדי להשתמש בנקודה.אם אין לך את זה, אתה יכול להדביק את היציאה טקסט לתוך צופה מקוון Graphviz. היציאה תייצג באופן חזותי את החצים עם תוויות כמו משקל: 3, מה שהופך ברור כי ההעברה של המשלוח מייצרת טוקינים מרובים. בדיקת יחידות (Unit Testing) אנחנו לא רק מקווים שזה יעבוד, אנחנו מוכיחים את זה. כדי להוריד את הגדרת זרימת העבודה בפועל ולבדוק את המעברים. 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);
    }
}
 בצעו את המבחן: php bin/phpunit tests/Workflow/ExpenseApprovalWorkflowTest.php
 שימושים מתקדמים ושיטות טובות שימוש ב- Enums עבור מקומות (חדש ב- 7.4) Symfony 7.4 גם מוסיף תמיכה עבור Enums Backed בתהליכים עבודה. "אני חושב שצריך להגדיר את האנימציה. 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';
}
 לאחר מכן תוכל לעדכן את workflow.yaml שלך (אם כי YAML עדיין משתמש בשורות, הקוד PHP שלך יכול להשתמש ) ExpenseState::REVIEW_POOL->value אירועים עם משקולות אולי תרצו למנוע את אותו הדבר. שלוש פעמים, המהפכה מאפשרת את התהליך כדי להיקרא 3 פעמים, אבל מנוע זרימת העבודה אינו יודע באופן טבעי מי התקשר אליו. person approve כדי לפתור את הבעיה, השתמש בקורא שומר. #[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.');
    }
}
 ניקוי טוקן (Token Cleanup) אחד האתגרים עם טוקינים משומשים הוא ניקוי.אם יש לנו 2 אישורים והאדם השלישי קורא מה קורה עם שני המשתתפים שנמצאים ? reject approved_pool בתהליך עבודה רגיל, לעבור ל יכולות לעזוב את אלה טוקי סתום (יצירת מצב זומבי שבו הדו"ח הוא גם נדחה וחלק מאושר). rejected approved_pool The האידיאלי הוא לצרוך עם זאת, צריכת דינמית אינה נתמכת אך ורק ב- YAML (אתה לא יכול לומר "צרך את כולם"). reject all שימוש בתוכנת Event Subscriber , באפשרותך להגדיר מחדש את חנות הסימנים באופן ידני. workflow.entered.rejected public function onRejected(Event $event): void
{
    $expense = $event->getSubject();
    // Force reset state to ONLY rejected
    $expense->setCurrentState(['rejected' => 1]);
}
 מסקנה סימפוניה 7.4 על ידי האפשרות להתקיים בו זמנית כמה דוגמאות של מדינה (טוקינים), אנו יכולים כעת מודל מערכות הצבעה, לייצור קווי איסוף, ו לוגיקה עיבוד המלאה ישירות בתצורה, להפחית באופן דרמטי את כמות הקלדת PHP מותאמת אישית הנדרשת. Weighted Workflow Transitions Key Takeaways: 
 
 
 
 
 מגוון: מקומות יכולים להחזיק טוקינים מרובים, המאפשרים הצטברות מקבילה של מדינה. הגדרת: השתמשו במשקל בהגדרות שלך to (output) ו-from (input) כדי לשלוט על זרימת הטוקן. אחסון: ודא שהאחריות של חנות הסימנים שלך היא מסדרה (לדוגמה, עמודה JSON) כדי לעקוב אחר מספרים של טוקינים לפי מקום. אימות: תמיד להשתמש בפקודה workflow:dump ולכתוב KernelTestCase בדיקות כדי להוכיח את ההיגיון של הגרף שלך לפני הפצה. תכונה זו מחזקת את רכיב Workflow של Symfony כפתרון PHP המוביל לניהול המצב, ומאפשרת לך למחוק מאפיינים עייפים של "מכירה" ולהסתמך על ארכיטקטורה מתמטית מוצלחת. בואו נהיה במגע אימוץ דפוסים מתקדמים אלה יכול לפשט באופן משמעותי את ההיגיון של התחום שלך, אבל המעבר אינו תמיד ברור.אם אתה מחפש מודרניזציה של הסימפוניה שלך, צריך זוג שני של עיניים על האדריכלות שלך, או רק רוצה להסתכל על יישומים האחרונים של רשת Petri, אני רוצה לשמוע ממך. בואו להיות בקשר - צור איתי קשר ב-LinkedIn ( להמשך השיחה על ארכיטקטורה PHP מודרנית. https://www.linkedin.com/in/matthew-mochalkin/ https://www.linkedin.com/in/matthew-mochalkin/

Read My Stories

האודיו הזה מופק בשפת המקור של הסיפור!

הנה איך אתה יכול לבנות מערכת אישור FinTech עם Symfony 7.4

About Author

הערות

תלו תגים

מאמר זה הוצג ב

Related Stories

Synthetic Audio is Now Available for 70,000+ HackerNoon Stories

The TechBeat: Everything You Need to Know to Implement Generative AI for Your Enterprise (3/12/2024)

The TechBeat: Python's Testing Playbook: Building Bulletproof Code (1/16/2024)

The TechBeat: 5 Low-Cost Cybersecurity Measures SMBs Can’t Afford to Not Implement (3/4/2024)

Synthetic Audio is Now Available for 70,000+ HackerNoon Stories

The TechBeat: Everything You Need to Know to Implement Generative AI for Your Enterprise (3/12/2024)

The TechBeat: Python's Testing Playbook: Building Bulletproof Code (1/16/2024)

The TechBeat: 5 Low-Cost Cybersecurity Measures SMBs Can’t Afford to Not Implement (3/4/2024)

Light-Mode

Classic

Newspaper

Minty

Dark-Mode

Neon Noir

Minty

HN StartUps