Symfony FormFlow Demo

https://github.com/yceruto/formflow-demo
Admin
A comprehensive demonstration of Symfony FormFlow featuring multiple form wizard implementations...
Tokens:8,383
Snippets:40
Trust Score:9.6
License:MIT
Update:10 months ago
Show doc for...
Tokens:
Raw
### Generate Dynamic Form Content Based on Previous Step Data in PHP

Source: https://context7.com/yceruto/formflow-demo/llms.txt

Creates a form step that dynamically generates its fields and options based on data submitted in a previous step. It accesses the parent form's data using `$builder->getData()` and uses it to populate choices for a `ChoiceType` field. This example includes a helper method to adjust color brightness for gradient options.

```php
<?php
// src/Demo/ColorPicker/Form/Type/Step/Step2Type.php
namespace App\Demo\ColorPicker\Form\Type\Step;

use App\Demo\ColorPicker\Form\Data\ColorPickerDto;
use Symfony\Component\Form\AbstractType;
use Symfony\Component\Form\Extension\Core\Type\ChoiceType;
use Symfony\Component\Form\FormBuilderInterface;

class Step2Type extends AbstractType
{
    public function buildForm(FormBuilderInterface $builder, array $options): void
    {
        /** @var ColorPickerDto $colorPicker */
        $colorPicker = $builder->getData();

        assert(is_string($colorPicker->mainColor), 'Main color must be a string');

        // Generate dynamic choices based on previous step
        $gradients = [
            'Lighter' => $this->adjustBrightness($colorPicker->mainColor, 40),
            'Original' => $colorPicker->mainColor,
            'Darker' => $this->adjustBrightness($colorPicker->mainColor, -40),
        ];

        $builder->add('gradientColor', ChoiceType::class, [
            'label' => 'Gradient Color',
            'choices' => $gradients,
            'choice_label' => function ($choice, $value) {
                return $value . ' (' . $choice . ')';
            },
        ]);
    }

    private function adjustBrightness(string $hexColor, int $amount): string
    {
        $hex = ltrim($hexColor, '#');
        $r = max(0, min(255, hexdec(substr($hex, 0, 2)) + $amount));
        $g = max(0, min(255, hexdec(substr($hex, 2, 2)) + $amount));
        $b = max(0, min(255, hexdec(substr($hex, 4, 2)) + $amount));
        return sprintf("#%02X%02X%02X", $r, $g, $b);
    }
}

```

--------------------------------

### Custom Form Navigator with Conditional Buttons (PHP)

Source: https://context7.com/yceruto/formflow-demo/llms.txt

This PHP class extends Symfony's `AbstractType` to create a custom form navigator for multi-step forms. It defines various navigation buttons like 'Start Over', 'Back', 'Continue', 'Upload Documents', and 'Submit KYC'. The 'Continue' button's visibility is conditionally controlled based on the current form step and the ability to move to the next step.

```php
<?php
// src/Demo/Kyc/Form/Type/KycNavigatorType.php
namespace App\Demo\Kyc\Form\Type;

use Symfony\Component\Form\AbstractType;
use Symfony\Component\Form\Flow\FormFlowCursor;
use Symfony\Component\Form\Flow\Type\FinishFlowType;
use Symfony\Component\Form\Flow\Type\NextFlowType;
use Symfony\Component\Form\Flow\Type\PreviousFlowType;
use Symfony\Component\Form\Flow\Type\ResetFlowType;
use Symfony\Component\Form\FormBuilderInterface;
use Symfony\Component\OptionsResolver\OptionsResolver;

class KycNavigatorType extends AbstractType
{
    public function buildForm(FormBuilderInterface $builder, array $options): void
    {
        $builder
            ->add('reset', ResetFlowType::class, [
                'label' => 'Start Over',
            ])
            ->add('back', PreviousFlowType::class, [
                'label' => 'Back',
            ])
            ->add('next', NextFlowType::class, [
                'label' => 'Continue',
                // Conditionally show based on current step and ability to move
                'include_if' => fn (FormFlowCursor $cursor): bool =>
                    $cursor->getCurrentStep() !== 'documents' && $cursor->canMoveNext(),
            ])
            ->add('upload', UploadFlowType::class, [
                'label' => 'Upload Documents',
            ])
            ->add('finish', FinishFlowType::class, [
                'label' => 'Submit KYC',
            ]);
    }

    public function configureOptions(OptionsResolver $resolver): void
    {
        $resolver->setDefaults([
            'label' => false,
            'mapped' => false,
            'priority' => -100,
        ]);
    }
}

```

--------------------------------

### Basic Form Flow Controller Implementation

Source: https://context7.com/yceruto/formflow-demo/llms.txt

This PHP code demonstrates how to implement a basic FormFlow controller in Symfony. It creates a form flow, handles requests, checks for submission and validity, and renders the current step's form. It requires the FormFlowInterface and relevant form types.

```php
<?php
// src/Demo/Basic/Controller/BasicController.php
namespace App\Demo\Basic\Controller;

use App\Demo\Basic\Form\Data\BasicDto;
use App\Demo\Basic\Form\Type\BasicType;
use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
use Symfony\Component\Form\Flow\FormFlowInterface;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\HttpFoundation\Response;
use Symfony\Component\Routing\Attribute\Route;

class BasicController extends AbstractController
{
    #[Route('/demo/basic', name: 'app_demo_basic')]
    public function __invoke(Request $request): Response
    {
        /** @var FormFlowInterface $flow */
        $flow = $this->createForm(BasicType::class, new BasicDto())
            ->handleRequest($request);

        if ($flow->isSubmitted() && $flow->isValid() && $flow->isFinished()) {
            // Process completed flow data
            $data = $flow->getData();

            $this->addFlash('success', 'Your form flow was successfully finished!');
            return $this->redirectToRoute('app_demo_basic');
        }

        return $this->render('demo/basic.html.twig', [
            'form' => $flow->getStepForm(),
        ]);
    }
}

```

--------------------------------

### Generating and Using Custom Self-Signed TLS Certificates with mkcert

Source: https://github.com/yceruto/formflow-demo/blob/main/docs/tls.md

Steps to generate self-signed TLS certificates using mkcert and configure Caddy to use them. This involves creating a certificates directory, generating the certs, updating the compose override file with environment and volume configurations, and restarting the service.

```bash
mkdir -p frankenphp/certs
mkcert -cert-file frankenphp/certs/tls.pem -key-file frankenphp/certs/tls.key "server-name.localhost"
```

```diff
php:
  environment:
+    CADDY_SERVER_EXTRA_DIRECTIVES: "tls /etc/caddy/certs/tls.pem /etc/caddy/certs/tls.key"
    # ...
  volumes:
+    - ./frankenphp/certs:/etc/caddy/certs:ro
    # ...

```

--------------------------------

### Custom Step Rendering in Twig

Source: https://context7.com/yceruto/formflow-demo/llms.txt

This Twig template demonstrates how to create a custom layout for a multi-step form. It includes logic to render specific blocks for different form steps, such as handling file uploads for a 'documents' step and displaying previously uploaded file paths. It also manages navigation buttons dynamically based on their presence.

```twig
{# templates/demo/kyc/flow.html.twig #}
{% extends 'base.html.twig' %}

{% block body %}
    <div class="w-75 mx-auto">
        <div class="card shadow-lg">
            {{ form_start(form, {attr: {enctype: 'multipart/form-data'}})
            }}
            <div class="row g-0">
                <div class="col-4 bg-light rounded-start p-4">
                    {{ include('demo/kyc/_progress.html.twig') }}
                </div>
                <div class="col-8">
                    {% set current_step = form.vars.cursor.currentStep %}
                    {% set current_step_block_name = 'kyc_' ~ current_step ~ '_step' %}

                    <div class="card-body p-4 px-5 d-flex flex-column h-100">
                        <div class="flex-grow-1">
                            <h5 class="card-title">{{ field_label(form[current_step]) }}</h5>
                            <p class="card-text text-muted mb-4">{{ field_help(form[current_step]) }}</p>
                            <hr class="border-secondary-subtle">

                            {# Render custom block or default #}
                            {% if block(current_step_block_name) is defined %}
                                {{ block(current_step_block_name) }}
                            {% else %}
                                {{ block('kyc_default_step') }}
                            {% endif %}
                        </div>
                        <div>
                            {{ block('kyc_navigator') }}
                        </div>
                    </div>
                </div>
            </div>
            {{ form_end(form) }}
        </div>
    </div>
{% endblock %}

{% block kyc_default_step %}
    {{ form_widget(form[current_step]) }}
{% endblock %}

{% block kyc_documents_step %}
    {% set data = form.vars.data %}

    <div class="mb-3">
        {{ form_row(form.documents.idDocumentFile) }}

        {# Show previously uploaded files #}
        {% if data.documents.idDocumentPath|default(false) %}
            <div class="alert alert-success">
                <strong>ID Document:</strong> {{ data.documents.idDocumentPath }} (uploaded)
            </div>
        {% endif %}
    </div>

    <div class="mb-3">
        {{ form_row(form.documents.proofOfAddressFile) }}

        {% if data.documents.proofOfAddressPath|default(false) %}
            <div class="alert alert-success">
                <strong>Proof of Address:</strong> {{ data.documents.proofOfAddressPath }} (uploaded)
            </div>
        {% endif %}
    </div>
{% endblock %}

{% block kyc_navigator %}
    <div class="d-flex justify-content-between border-top pt-3 mt-3">
        <div class="d-flex gap-3">
            {% if form.navigator.back is defined %}
                {{ form_widget(form.navigator.back, {attr: {class: 'btn-outline-dark'}})
                }}
            {% endif %}
        </div>
        <div class="d-flex gap-3">
            {% if form.navigator.upload is defined %}
                {{ form_widget(form.navigator.upload, {attr: {class: 'btn-dark'}})
                }}
            {% endif %}
            {% if form.navigator.next is defined %}
                {{ form_widget(form.navigator.next, {attr: {class: 'btn-dark'}})
                }}
            {% endif %}
            {% if form.navigator.finish is defined %}
                {{ form_widget(form.navigator.finish, {attr: {class: 'btn-dark'}})
                }}
            {% endif %}
        </div>
    </div>
{% endblock %}
```

--------------------------------

### Disabling HTTPS for Local Development

Source: https://github.com/yceruto/formflow-demo/blob/main/docs/tls.md

Instructions to disable HTTPS and enable HTTP for local development by setting specific environment variables and running the Docker Compose command. This ensures the application is accessible via HTTP.

```bash
SERVER_NAME=http://localhost \
MERCURE_PUBLIC_URL=http://localhost/.well-known/mercure \
docker compose up --wait
```

--------------------------------

### Implement Conditional Steps with Skip Logic in PHP

Source: https://context7.com/yceruto/formflow-demo/llms.txt

Builds a multi-step form flow with conditional steps using `AbstractFlowType`. It utilizes skip logic defined as closures to determine whether a step should be displayed based on the form data. This enables dynamic form flows tailored to user selections, such as choosing between individual or organization accounts.

```php
<?php
// src/Demo/SignUp/Form/Type/SignUpType.php
namespace App\Demo\SignUp\Form\Type;

use App\Demo\SignUp\Form\Data\SignUpDto;
use Symfony\Component\Form\Flow\AbstractFlowType;
use Symfony\Component\Form\Flow\FormFlowBuilderInterface;

class SignUpType extends AbstractFlowType
{
    public function buildFormFlow(FormFlowBuilderInterface $builder, array $options): void
    {
        $builder->addStep('type', AccountTypeSelectionType::class);

        // Conditional step: only shown for individual accounts
        $builder->addStep('individual', IndividualType::class,
            skip: fn (SignUpDto $data) => $data->type !== 'individual'
        );

        // Conditional step: only shown for organization accounts
        $builder->addStep('organization', OrganizationType::class,
            skip: fn (SignUpDto $data) => $data->type !== 'organization'
        );

        $builder->addStep('credentials', CredentialsType::class);
        $builder->addStep('confirmation', ConfirmationType::class);

        $builder->add('navigator', SignUpNavigatorType::class);
    }
}

```

--------------------------------

### PHP Controller for Query Parameter Step Selection

Source: https://context7.com/yceruto/formflow-demo/llms.txt

This PHP controller manages a multi-step form using Symfony's FormFlow. It handles form submissions, validates data, saves the account information, and allows step selection through a query parameter ('tab'). It depends on AccountRepositoryInterface and SettingsType.

```php
<?php
// src/Demo/Settings/Controller/SettingsController.php
namespace App\Demo\Settings\Controller;

use App\Demo\Settings\Form\Type\SettingsType;
use App\Demo\Settings\Repository\AccountRepositoryInterface;
use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
use Symfony\Component\Form\Flow\FormFlowInterface;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\HttpFoundation\Response;
use Symfony\Component\HttpKernel\Attribute\MapQueryParameter;
use Symfony\Component\Routing\Attribute\Route;

class SettingsController extends AbstractController
{
    public function __construct(
        private readonly AccountRepositoryInterface $repository,
    ) {
    }

    #[Route('/demo/settings', name: 'app_demo_settings')]
    public function __invoke(Request $request, #[MapQueryParameter] string $tab = 'details'): Response
    {
        $account = $this->repository->current();

        /** @var FormFlowInterface $form */
        $form = $this->createForm(SettingsType::class, $account, ['tab' => $tab])
            ->handleRequest($request);

        if ($form->isSubmitted() && $form->isValid() && null === $form->getClickedButton()) {
            $this->repository->save($account);
            $this->addFlash('success', 'Your information has been updated!');
            return $this->redirectToRoute('app_demo_settings', ['tab' => $tab]);
        }

        return $this->render('demo/settings/form.html.twig', [
            'form' => $form->getStepForm(),
        ]);
    }
}

```

--------------------------------

### Non-Linear Navigation with Null Data Storage in PHP

Source: https://context7.com/yceruto/formflow-demo/llms.txt

Configures a form flow that supports non-linear navigation by disabling session data storage using NullDataStorage. It defines multiple steps for settings and uses a custom step accessor for navigation. Requires Symfony Form components.

```php
<?php
// src/Demo/Settings/Form/Type/SettingsType.php
namespace App\Demo\Settings\Form\Type;

use App\Demo\Settings\Form\StepAccessor\FixedStepAccessor;
use App\Demo\Settings\Model\Account;
use Symfony\Component\Form\Flow\AbstractFlowType;
use Symfony\Component\Form\Flow\DataStorage\NullDataStorage;
use Symfony\Component\Form\Flow\FormFlowBuilderInterface;
use Symfony\Component\OptionsResolver\Options;
use Symfony\Component\OptionsResolver\OptionsResolver;

class SettingsType extends AbstractFlowType
{
    public function buildFormFlow(FormFlowBuilderInterface $builder, array $options): void
    {
        $builder->addStep('details', DetailsType::class);
        $builder->addStep('profile', ProfileType::class);
        $builder->addStep('team', TeamType::class);
        $builder->addStep('notification', NotificationType::class);
    }

    public function configureOptions(OptionsResolver $resolver): void
    {
        $resolver->define('tab')->required()->allowedTypes('string');

        $resolver->setDefaults([
            'data_class' => Account::class,
            'data_storage' => new NullDataStorage(), // No session storage
            'step_accessor' => fn (Options $options) => new FixedStepAccessor($options['tab']),
        ]);
    }
}

```

--------------------------------

### Handle File Uploads in Multi-Step Forms (PHP)

Source: https://context7.com/yceruto/formflow-demo/llms.txt

This PHP class handles file uploads for multi-step forms, including ID documents and proof of address. It saves uploaded files to a specified directory, generates unique filenames, and removes old files when new ones are uploaded. It depends on Symfony's Filesystem and Slugger components.

```php
<?php
// src/Demo/Kyc/Service/DocumentUploadHandler.php
namespace App\Demo\Kyc\Service;

use App\Demo\Kyc\Form\Data\Step\DocumentUploadDto;
use Symfony\Component\DependencyInjection\Attribute\Autowire;
use Symfony\Component\Filesystem\Filesystem;
use Symfony\Component\HttpFoundation\File\UploadedFile;
use Symfony\Component\String\Slugger\SluggerInterface;

final readonly class DocumentUploadHandler
{
    public function __construct(
        #[Autowire('%kernel.project_dir%/private/uploads')]
        private string $uploadDirectory,
        private SluggerInterface $slugger,
        private Filesystem $filesystem,
    ) {
    }

    public function handleUpload(DocumentUploadDto $dto): void
    {
        // Handle ID document upload
        if ($dto->idDocumentFile instanceof UploadedFile) {
            if ($dto->idDocumentPath) {
                $this->removeFile($dto->idDocumentPath);
            }
            $dto->idDocumentPath = $this->saveFile($dto->idDocumentFile);
            $dto->idDocumentFile = null; // Clear to avoid session serialization issues
        }

        // Handle proof of address upload
        if ($dto->proofOfAddressFile instanceof UploadedFile) {
            if ($dto->proofOfAddressPath) {
                $this->removeFile($dto->proofOfAddressPath);
            }
            $dto->proofOfAddressPath = $this->saveFile($dto->proofOfAddressFile);
            $dto->proofOfAddressFile = null;
        }
    }

    private function saveFile(UploadedFile $file): string
    {
        $originalFilename = pathinfo($file->getClientOriginalName(), PATHINFO_FILENAME);
        $safeFilename = $this->slugger->slug($originalFilename);
        $fileName = $safeFilename.'-'.uniqid().'.'.$file->guessExtension();
        $file->move($this->uploadDirectory, $fileName);
        return $fileName;
    }

    private function removeFile(string $filePath): void
    {
        $this->filesystem->remove($this->uploadDirectory.DIRECTORY_SEPARATOR.$filePath);
    }
}

```

--------------------------------

### Twig Template for Rendering Flow Forms

Source: https://context7.com/yceruto/formflow-demo/llms.txt

This Twig template renders a multi-step form generated by Symfony's FormFlow component. It extends a base template and displays the form fields. It also shows how to access and display the current step and total number of steps in the form flow.

```twig
{# templates/demo/basic.html.twig #}
{% extends 'base.html.twig' %}

{% block body %}
    <h2 class="fw-bold">Basic</h2>
    <div class="w-50">
        {{ form(form) }}

        {# Access flow cursor information #}
        Step {{ form.vars.cursor.stepIndex + 1 }} of {{ form.vars.cursor.totalSteps }}
    </div>
{% endblock %}

```

--------------------------------

### Defining a Multi-Step Form Flow Type

Source: https://context7.com/yceruto/formflow-demo/llms.txt

This PHP code defines a multi-step form flow using Symfony's AbstractFlowType. It sets up sequential steps, specifies the data class for the flow, and includes a navigator component. Dependencies include FormFlowBuilderInterface and various step form types.

```php
<?php
// src/Demo/Basic/Form/Type/BasicType.php
namespace App\Demo\Basic\Form\Type;

use App\Demo\Basic\Form\Data\BasicDto;
use App\Demo\Basic\Form\Type\Step\Step1Type;
use App\Demo\Basic\Form\Type\Step\Step2Type;
use App\Demo\Basic\Form\Type\Step\Step3Type;
use Symfony\Component\Form\Flow\AbstractFlowType;
use Symfony\Component\Form\Flow\FormFlowBuilderInterface;
use Symfony\Component\Form\Flow\Type\NavigatorFlowType;
use Symfony\Component\OptionsResolver\OptionsResolver;

class BasicType extends AbstractFlowType
{
    public function buildFormFlow(FormFlowBuilderInterface $builder, array $options): void
    {
        // Add sequential steps
        $builder->addStep('step1', Step1Type::class);
        $builder->addStep('step2', Step2Type::class);
        $builder->addStep('step3', Step3Type::class);

        // Add navigation buttons
        $builder->add('navigator', NavigatorFlowType::class);
    }

    public function configureOptions(OptionsResolver $resolver): void
    {
        $resolver->setDefaults([
            'data_class' => BasicDto::class,
            'step_property_path' => 'currentStep', // Tracks current step in DTO
        ]);
    }
}

```

--------------------------------

### Custom Step Accessor for Fixed Step in PHP

Source: https://context7.com/yceruto/formflow-demo/llms.txt

Provides a custom implementation of StepAccessorInterface to enforce a fixed step in a form flow, preventing step changes from being persisted. This is useful for specific navigation control scenarios. Requires Symfony Form components.

```php
<?php
// src/Demo/Settings/Form/StepAccessor/FixedStepAccessor.php
namespace App\Demo\Settings\Form\StepAccessor;

use Symfony\Component\Form\Flow\StepAccessor\StepAccessorInterface;

final readonly class FixedStepAccessor implements StepAccessorInterface
{
    public function __construct(
        private string $step,
    ) {
    }

    public function getStep(object|array $data, ?string $default = null): ?string
    {
        return $this->step; // Always return fixed step
    }

    public function setStep(object|array &$data, string $step): void
    {
        // No-op: don't store step changes
    }
}

```

--------------------------------

### Trusting Caddy's Local Certificate Authority on Host Machines

Source: https://github.com/yceruto/formflow-demo/blob/main/docs/tls.md

Commands to add the Caddy local Certificate Authority (CA) root certificate to the host's trust store for different operating systems. This is necessary because certificates signed by the Caddy CA are not trusted by default.

```shell
# Mac
$ docker cp $(docker compose ps -q php):/data/caddy/pki/authorities/local/root.crt /tmp/root.crt && sudo security add-trusted-cert -d -r trustRoot -k /Library/Keychains/System.keychain /tmp/root.crt
# Linux
$ docker cp $(docker compose ps -q php):/data/caddy/pki/authorities/local/root.crt /usr/local/share/ca-certificates/root.crt && sudo update-ca-certificates
# Windows
$ docker compose cp php:/data/caddy/pki/authorities/local/root.crt %TEMP%/root.crt && certutil -addstore -f "ROOT" %TEMP%/root.crt
```

--------------------------------

### Pass Data to Dynamic Steps in PHP

Source: https://context7.com/yceruto/formflow-demo/llms.txt

Illustrates how to pass data to a subsequent step within a Symfony Form Flow. When `inherit_data` is enabled in a child form, you can explicitly set the `data` option for a step in the `buildFormFlow` method. This ensures that the child step has access to the data from the parent or previous steps, as demonstrated with `Step2Type`.

```php
<?php
// src/Demo/ColorPicker/Form/Type/ColorPickerType.php
namespace App\Demo\ColorPicker\Form\Type;

use Symfony\Component\Form\Flow\AbstractFlowType;
use Symfony\Component\Form\Flow\FormFlowBuilderInterface;

class ColorPickerType extends AbstractFlowType
{
    public function buildFormFlow(FormFlowBuilderInterface $builder, array $options): void
    {
        $builder->addStep('step1', Step1Type::class);

        // Pass data to step when inherit_data is true
        $builder->addStep('step2', Step2Type::class, [
            'data' => $builder->getData(), // Required for accessing data in Step2Type
        ]);

        $builder->add('navigator', NavigatorFlowType::class);
    }
}

```

--------------------------------

### Create Step-Specific Form Types in PHP

Source: https://context7.com/yceruto/formflow-demo/llms.txt

Defines a specific form type for a step in a multi-step form. It extends `AbstractType` and configures default options, including the data class and enabling data inheritance from the parent form. This is useful for organizing complex forms into manageable, step-by-step components.

```php
<?php
// src/Demo/Basic/Form/Type/Step/Step1Type.php
namespace App\Demo\Basic\Form\Type\Step;

use App\Demo\Basic\Form\Data\BasicDto;
use Symfony\Component\Form\AbstractType;
use Symfony\Component\Form\Extension\Core\Type\TextareaType;
use Symfony\Component\Form\FormBuilderInterface;
use Symfony\Component\OptionsResolver\OptionsResolver;

class Step1Type extends AbstractType
{
    public function buildForm(FormBuilderInterface $builder, array $options): void
    {
        $builder
            ->add('field11')
            ->add('field12', TextareaType::class);
    }

    public function configureOptions(OptionsResolver $resolver): void
    {
        $resolver->setDefaults([
            'data_class' => BasicDto::class,
            'inherit_data' => true, // Share data with parent form
        ]);
    }
}

```

--------------------------------

### Custom Button Flow Type with Handler in PHP

Source: https://context7.com/yceruto/formflow-demo/llms.txt

Implements a custom flow type that intercepts button clicks to execute custom logic before proceeding to the next step. It uses a DocumentUploadHandler to process file uploads. Dependencies include Symfony Form components.

```php
<?php
// src/Demo/Kyc/Form/Type/UploadFlowType.php
namespace App\Demo\Kyc\Form\Type;

use App\Demo\Kyc\Form\Data\KycDto;
use App\Demo\Kyc\Service\DocumentUploadHandler;
use Symfony\Component\Form\Flow\AbstractButtonFlowType;
use Symfony\Component\Form\Flow\ButtonFlowInterface;
use Symfony\Component\Form\Flow\FormFlowCursor;
use Symfony\Component\Form\Flow\FormFlowInterface;
use Symfony\Component\Form\Flow\Type\NextFlowType;
use Symfony\Component\OptionsResolver\OptionsResolver;

class UploadFlowType extends AbstractButtonFlowType
{
    public function __construct(
        private readonly DocumentUploadHandler $uploadHandler,
    ) {
    }

    public function configureOptions(OptionsResolver $resolver): void
    {
        $resolver->setDefaults([
            'handler' => function (mixed $data, ButtonFlowInterface $button, FormFlowInterface $flow): void {
                /** @var KycDto $data */
                $data = $flow->getData();

                // Custom logic: handle file uploads before moving
                $this->uploadHandler->handleUpload($data->documents);

                // Move to next step
                $flow->moveNext();
            },
            'include_if' => fn (FormFlowCursor $cursor): bool =>
                $cursor->getCurrentStep() === 'documents' && $cursor->canMoveNext(),
        ]);
    }

    public function getParent(): string
    {
        return NextFlowType::class;
    }
}

```

--------------------------------

### Nested DTOs for Complex Form Structures in PHP

Source: https://context7.com/yceruto/formflow-demo/llms.txt

This PHP code defines a Data Transfer Object (DTO) for a sign-up process, illustrating the use of nested DTOs to represent complex, hierarchical form data. It utilizes Symfony's validator constraints to define validation rules for different sections of the form and for specific validation groups, allowing for conditional validation based on the form step.

```php
<?php
// src/Demo/SignUp/Form/Data/SignUpDto.php
namespace App\Demo\SignUp\Form\Data;

use App\Demo\SignUp\Form\Data\Step\CredentialsDto;
use App\Demo\SignUp\Form\Data\Step\IndividualDto;
use App\Demo\SignUp\Form\Data\Step\OrganizationDto;
use Symfony\Component\Validator\Constraints as Assert;

class SignUpDto
{
    // Step 1: Type selection
    #[Assert\NotBlank(groups: ['type'])]
    public ?string $type = null;

    // Step 2a: Individual information (conditionally validated)
    #[Assert\Valid(groups: ['individual'])]
    public ?IndividualDto $individual = null;

    // Step 2b: Organization information (conditionally validated)
    #[Assert\Valid(groups: ['organization'])]
    public ?OrganizationDto $organization = null;

    // Step 3: Account credentials
    #[Assert\Valid(groups: ['credentials'])]
    public ?CredentialsDto $credentials = null;

    // Step 4: Confirmation
    #[Assert\NotBlank(groups: ['confirmation'])]
    #[Assert\EqualTo(true, groups: ['confirmation'])]
    public bool $agreeTerms = false;

    // Current step tracking
    public string $currentStep = 'type';
}

```

--------------------------------

### File Upload DTO Design with Separate File and Path (PHP)

Source: https://context7.com/yceruto/formflow-demo/llms.txt

This PHP Data Transfer Object (DTO) is designed for handling file uploads in forms. It includes separate properties for the temporary uploaded file (`UploadedFile`) and the persisted file path (`string`). This separation helps manage session data and file persistence effectively. It utilizes Symfony's validation constraints.

```php
<?php
// src/Demo/Kyc/Form/Data/Step/DocumentUploadDto.php
namespace App\Demo\Kyc\Form\Data\Step;

use Symfony\Component\HttpFoundation\File\UploadedFile;
use Symfony\Component\Validator\Constraints as Assert;

class DocumentUploadDto
{
    // Temporary file (not persisted in session)
    #[Assert\NotBlank(message: 'Please upload your ID document', groups: ['documents'])]
    #[Assert\File(
        maxSize: '5M',
        mimeTypes: ['image/jpeg', 'image/png', 'application/pdf'],
        mimeTypesMessage: 'Please upload a valid document (JPEG, PNG or PDF)',
        groups: ['documents']
    )]
    public ?UploadedFile $idDocumentFile = null;

    #[Assert\NotBlank(message: 'Please upload your proof of address', groups: ['documents'])]
    #[Assert\File(
        maxSize: '5M',
        mimeTypes: ['image/jpeg', 'image/png', 'application/pdf'],
        groups: ['documents']
    )]
    public ?UploadedFile $proofOfAddressFile = null;

    // Stored file paths (persisted in session)
    public ?string $idDocumentPath = null;
    public ?string $proofOfAddressPath = null;
}

```

--------------------------------

### Form Data Transfer Object with Validation Groups

Source: https://context7.com/yceruto/formflow-demo/llms.txt

This PHP code defines a Data Transfer Object (DTO) for a Symfony form flow, including validation constraints with specific groups for each step. It utilizes Symfony's Validator component and Assert constraints. This DTO manages data across multiple form steps.

```php
<?php
// src/Demo/Basic/Form/Data/BasicDto.php
namespace App\Demo\Basic\Form\Data;

use Symfony\Component\Validator\Constraints as Assert;

class BasicDto
{
    // Step 1 fields
    #[Assert\NotBlank(groups: ['step1'])]
    public ?string $field11 = null;

    #[Assert\NotBlank(groups: ['step1'])]
    #[Assert\Length(min: 3, groups: ['step1'])]
    public ?string $field12 = null;

    // Step 2 fields
    #[Assert\NotBlank(groups: ['step2'])]
    public ?string $field21 = null;

    #[Assert\NotBlank(groups: ['step2'])]
    #[Assert\GreaterThanOrEqual(value: 10, groups: ['step2'])]
    public ?int $field22 = null;

    // Step 3 fields
    #[Assert\NotBlank(groups: ['step3'])]
    #[Assert\Length(min: 3, groups: ['step3'])]
    public ?string $field31 = null;

    #[Assert\IsTrue(groups: ['step3'])]
    public ?bool $field32 = null;

    // Step tracking property
    public ?string $currentStep = null;
}

```
Tokens:
Raw