vendor/craue/formflow-bundle/Form/FormFlow.php line 603

Open in your IDE?
  1. <?php
  3. namespace Craue\FormFlowBundle\Form;
  5. use Craue\FormFlowBundle\Event\FlowExpiredEvent;
  6. use Craue\FormFlowBundle\Event\FormFlowEvent;
  7. use Craue\FormFlowBundle\Event\GetStepsEvent;
  8. use Craue\FormFlowBundle\Event\PostBindFlowEvent;
  9. use Craue\FormFlowBundle\Event\PostBindRequestEvent;
  10. use Craue\FormFlowBundle\Event\PostBindSavedDataEvent;
  11. use Craue\FormFlowBundle\Event\PostValidateEvent;
  12. use Craue\FormFlowBundle\Event\PreBindEvent;
  13. use Craue\FormFlowBundle\Event\PreviousStepInvalidEvent;
  14. use Craue\FormFlowBundle\Exception\AllStepsSkippedException;
  15. use Craue\FormFlowBundle\Exception\InvalidTypeException;
  16. use Craue\FormFlowBundle\Storage\DataManagerInterface;
  17. use Craue\FormFlowBundle\Util\StringUtil;
  18. use Symfony\Component\EventDispatcher\EventDispatcherInterface;
  19. use Symfony\Component\Form\Extension\Core\Type\FormType;
  20. use Symfony\Component\Form\FormFactoryInterface;
  21. use Symfony\Component\Form\FormInterface;
  22. use Symfony\Component\HttpFoundation\Request;
  23. use Symfony\Component\HttpFoundation\RequestStack;
  24. use Symfony\Component\HttpKernel\Kernel;
  25. use Symfony\Component\Validator\Constraints\GroupSequence;
  27. /**
  28.  * @author Christian Raue <christian.raue@gmail.com>
  29.  * @author Marcus Stöhr <dafish@soundtrack-board.de>
  30.  * @author Toni Uebernickel <tuebernickel@gmail.com>
  31.  * @copyright 2011-2021 Christian Raue
  32.  * @license http://opensource.org/licenses/mit-license.php MIT License
  33.  */
  34. abstract class FormFlow implements FormFlowInterface {
  36.     const TRANSITION_BACK = 'back';
  37.     const TRANSITION_RESET = 'reset';
  39.     /**
  40.      * @var FormFactoryInterface
  41.      */
  42.     protected $formFactory;
  44.     /**
  45.      * @var DataManagerInterface
  46.      */
  47.     protected $dataManager;
  49.     /**
  50.      * @var EventDispatcherInterface|null
  51.      */
  52.     protected $eventDispatcher = null;
  54.     /**
  55.      * @var string
  56.      */
  57.     protected $transition;
  59.     /**
  60.      * @var bool
  61.      */
  62.     protected $revalidatePreviousSteps = true;
  64.     /**
  65.      * @var bool
  66.      */
  67.     protected $allowDynamicStepNavigation = false;
  69.     /**
  70.      * @var bool If file uploads should be handled by serializing them into the storage.
  71.      */
  72.     protected $handleFileUploads = true;
  74.     /**
  75.      * @var string|null Directory for storing temporary files while handling uploads. If <code>null</code>, the system's default will be used.
  76.      */
  77.     protected $handleFileUploadsTempDir = null;
  79.     /**
  80.      * @var bool
  81.      */
  82.     protected $allowRedirectAfterSubmit = false;
  84.     /**
  85.      * @var string
  86.      */
  87.     protected $dynamicStepNavigationInstanceParameter = 'instance';
  89.     /**
  90.      * @var string
  91.      */
  92.     protected $dynamicStepNavigationStepParameter = 'step';
  94.     /**
  95.      * @var RequestStack
  96.      */
  97.     private $requestStack;
  99.     /**
  100.      * @var string|null Is only null if not yet initialized.
  101.      */
  102.     private $id = null;
  104.     /**
  105.      * @var string|null Is only null if not yet initialized.
  106.      */
  107.     private $instanceKey = null;
  109.     /**
  110.      * @var string|null Is only null if not yet initialized.
  111.      */
  112.     private $instanceId = null;
  114.     /**
  115.      * @var string|null Is only null if not yet initialized.
  116.      */
  117.     private $formStepKey = null;
  119.     /**
  120.      * @var string|null Is only null if not yet initialized.
  121.      */
  122.     private $formTransitionKey = null;
  124.     /**
  125.      * @var string|null Is only null if not yet initialized.
  126.      */
  127.     private $validationGroupPrefix = null;
  129.     /**
  130.      * @var StepInterface[]|null Is only null if not yet initialized.
  131.      */
  132.     private $steps = null;
  134.     /**
  135.      * @var int|null Is only null if not yet initialized.
  136.      */
  137.     private $stepCount = null;
  139.     /**
  140.      * @var string[]|null Is only null if not yet initialized.
  141.      */
  142.     private $stepLabels = null;
  144.     /**
  145.      * @var mixed|null Is only null if not yet initialized.
  146.      */
  147.     private $formData = null;
  149.     /**
  150.      * @var int|null Is only null if not yet initialized.
  151.      */
  152.     private $currentStepNumber = null;
  154.     /**
  155.      * @var FormInterface[]
  156.      */
  157.     private $stepForms = [];
  159.     /**
  160.      * Options applied to forms of all steps.
  161.      * @var array
  162.      */
  163.     private $genericFormOptions = [];
  165.     /**
  166.      * Flow was determined to be expired.
  167.      * @var bool
  168.      */
  169.     private $expired = false;
  171.     /**
  172.      * {@inheritDoc}
  173.      */
  174.     public function setFormFactory(FormFactoryInterface $formFactory) {
  175.         $this->formFactory = $formFactory;
  176.     }
  178.     /**
  179.      * {@inheritDoc}
  180.      */
  181.     public function setRequestStack(RequestStack $requestStack) {
  182.         $this->requestStack = $requestStack;
  183.     }
  185.     /**
  186.      * @return Request
  187.      * @throws \RuntimeException If the request is not available.
  188.      */
  189.     public function getRequest() {
  190.         $currentRequest = $this->requestStack->getCurrentRequest();
  192.         if ($currentRequest === null) {
  193.             throw new \RuntimeException('The request is not available.');
  194.         }
  196.         return $currentRequest;
  197.     }
  199.     /**
  200.      * {@inheritDoc}
  201.      */
  202.     public function setDataManager(DataManagerInterface $dataManager) {
  203.         $this->dataManager = $dataManager;
  204.     }
  206.     /**
  207.      * {@inheritDoc}
  208.      */
  209.     public function getDataManager() {
  210.         return $this->dataManager;
  211.     }
  213.     /**
  214.      * {@inheritDoc}
  215.      */
  216.     public function setEventDispatcher(EventDispatcherInterface $eventDispatcher) {
  217.         $this->eventDispatcher = $eventDispatcher;
  218.     }
  220.     public function setId($id) {
  221.         $this->id = $id;
  222.     }
  224.     /**
  225.      * {@inheritDoc}
  226.      */
  227.     public function getId() {
  228.         if ($this->id === null) {
  229.             $this->id = 'flow_' . $this->getName();
  230.         }
  232.         return $this->id;
  233.     }
  235.     /**
  236.      * {@inheritDoc}
  237.      */
  238.     public function getName() {
  239.         return StringUtil::fqcnToFlowName(get_class($this));
  240.     }
  242.     public function setInstanceKey($instanceKey) {
  243.         $this->instanceKey = $instanceKey;
  244.     }
  246.     public function getInstanceKey() {
  247.         if ($this->instanceKey === null) {
  248.             $this->instanceKey = $this->getId() . '_instance';
  249.         }
  251.         return $this->instanceKey;
  252.     }
  254.     public function setInstanceId($instanceId) {
  255.         $this->instanceId = $instanceId;
  256.     }
  258.     /**
  259.      * {@inheritDoc}
  260.      */
  261.     public function getInstanceId() {
  262.         if ($this->instanceId === null) {
  263.             $this->instanceId = $this->getId();
  264.         }
  266.         return $this->instanceId;
  267.     }
  269.     public function setFormStepKey($formStepKey) {
  270.         $this->formStepKey = $formStepKey;
  271.     }
  273.     public function getFormStepKey() {
  274.         if ($this->formStepKey === null) {
  275.             $this->formStepKey = $this->getId() . '_step';
  276.         }
  278.         return $this->formStepKey;
  279.     }
  281.     public function setFormTransitionKey($formTransitionKey) {
  282.         $this->formTransitionKey = $formTransitionKey;
  283.     }
  285.     public function getFormTransitionKey() {
  286.         if ($this->formTransitionKey === null) {
  287.             $this->formTransitionKey = $this->getId() . '_transition';
  288.         }
  290.         return $this->formTransitionKey;
  291.     }
  293.     public function setValidationGroupPrefix($validationGroupPrefix) {
  294.         $this->validationGroupPrefix = $validationGroupPrefix;
  295.     }
  297.     public function getValidationGroupPrefix() {
  298.         if ($this->validationGroupPrefix === null) {
  299.             $this->validationGroupPrefix = $this->getId() . '_step';
  300.         }
  302.         return $this->validationGroupPrefix;
  303.     }
  305.     /**
  306.      * {@inheritDoc}
  307.      */
  308.     public function getStepCount() {
  309.         if ($this->stepCount === null) {
  310.             $this->stepCount = count($this->getSteps());
  311.         }
  313.         return $this->stepCount;
  314.     }
  316.     /**
  317.      * {@inheritDoc}
  318.      */
  319.     public function getFormData() {
  320.         if ($this->formData === null) {
  321.             throw new \RuntimeException('Form data has not been evaluated yet and thus cannot be accessed.');
  322.         }
  324.         return $this->formData;
  325.     }
  327.     /**
  328.      * {@inheritDoc}
  329.      */
  330.     public function getCurrentStepNumber() {
  331.         if ($this->currentStepNumber === null) {
  332.             throw new \RuntimeException('The current step has not been determined yet and thus cannot be accessed.');
  333.         }
  335.         return $this->currentStepNumber;
  336.     }
  338.     public function setRevalidatePreviousSteps($revalidatePreviousSteps) {
  339.         $this->revalidatePreviousSteps = (bool) $revalidatePreviousSteps;
  340.     }
  342.     /**
  343.      * {@inheritDoc}
  344.      */
  345.     public function isRevalidatePreviousSteps() {
  346.         return $this->revalidatePreviousSteps;
  347.     }
  349.     public function setAllowDynamicStepNavigation($allowDynamicStepNavigation) {
  350.         $this->allowDynamicStepNavigation = (bool) $allowDynamicStepNavigation;
  351.     }
  353.     /**
  354.      * {@inheritDoc}
  355.      */
  356.     public function isAllowDynamicStepNavigation() {
  357.         return $this->allowDynamicStepNavigation;
  358.     }
  360.     public function setHandleFileUploads($handleFileUploads) {
  361.         $this->handleFileUploads = (bool) $handleFileUploads;
  362.     }
  364.     /**
  365.      * {@inheritDoc}
  366.      */
  367.     public function isHandleFileUploads() {
  368.         return $this->handleFileUploads;
  369.     }
  371.     public function setHandleFileUploadsTempDir($handleFileUploadsTempDir) {
  372.         $this->handleFileUploadsTempDir = $handleFileUploadsTempDir !== null ? (string) $handleFileUploadsTempDir : null;
  373.     }
  375.     /**
  376.      * {@inheritDoc}
  377.      */
  378.     public function getHandleFileUploadsTempDir() {
  379.         return $this->handleFileUploadsTempDir;
  380.     }
  382.     public function setAllowRedirectAfterSubmit($allowRedirectAfterSubmit) {
  383.         $this->allowRedirectAfterSubmit = (bool) $allowRedirectAfterSubmit;
  384.     }
  386.     /**
  387.      * {@inheritDoc}
  388.      */
  389.     public function isAllowRedirectAfterSubmit() {
  390.         return $this->allowRedirectAfterSubmit;
  391.     }
  393.     public function setDynamicStepNavigationInstanceParameter($dynamicStepNavigationInstanceParameter) {
  394.         $this->dynamicStepNavigationInstanceParameter = $dynamicStepNavigationInstanceParameter;
  395.     }
  397.     public function getDynamicStepNavigationInstanceParameter() {
  398.         return $this->dynamicStepNavigationInstanceParameter;
  399.     }
  401.     public function setDynamicStepNavigationStepParameter($dynamicStepNavigationStepParameter) {
  402.         $this->dynamicStepNavigationStepParameter = $dynamicStepNavigationStepParameter;
  403.     }
  405.     public function getDynamicStepNavigationStepParameter() {
  406.         return $this->dynamicStepNavigationStepParameter;
  407.     }
  409.     public function setGenericFormOptions(array $genericFormOptions) {
  410.         $this->genericFormOptions = $genericFormOptions;
  411.     }
  413.     public function getGenericFormOptions() {
  414.         return $this->genericFormOptions;
  415.     }
  417.     /**
  418.      * {@inheritDoc}
  419.      */
  420.     public function isStepSkipped($stepNumber) {
  421.         return $this->getStep($stepNumber)->isSkipped();
  422.     }
  424.     /**
  425.      * @param int $stepNumber Assumed step to which skipped steps shall be applied to.
  426.      * @param int $direction Either 1 (to skip forwards) or -1 (to skip backwards).
  427.      * @param int $boundsReached Internal counter to avoid endlessly bouncing back and forth.
  428.      * @return int Target step number with skipping applied.
  429.      * @throws \InvalidArgumentException If the value of <code>$direction</code> is invalid.
  430.      */
  431.     protected function applySkipping($stepNumber, $direction = 1, $boundsReached = 0) {
  432.         if ($direction !== 1 && $direction !== -1) {
  433.             throw new \InvalidArgumentException(sprintf('Argument of either -1 or 1 expected, "%s" given.', $direction));
  434.         }
  436.         $stepNumber = $this->ensureStepNumberRange($stepNumber);
  438.         if ($this->isStepSkipped($stepNumber)) {
  439.             $stepNumber += $direction;
  441.             // change direction if outer bounds are reached
  442.             if ($direction === 1 && $stepNumber > $this->getStepCount()) {
  443.                 $direction = -1;
  444.                 ++$boundsReached;
  445.             } elseif ($direction === -1 && $stepNumber < 1) {
  446.                 $direction = 1;
  447.                 ++$boundsReached;
  448.             }
  450.             if ($boundsReached > 2) {
  451.                 throw new AllStepsSkippedException();
  452.             }
  454.             return $this->applySkipping($stepNumber, $direction, $boundsReached);
  455.         }
  457.         return $stepNumber;
  458.     }
  460.     /**
  461.      * {@inheritDoc}
  462.      */
  463.     public function reset() {
  464.         $this->dataManager->drop($this);
  465.         $this->currentStepNumber = $this->getFirstStepNumber();
  467.         // re-evaluate to not keep steps marked as skipped when resetting
  468.         foreach ($this->getSteps() as $step) {
  469.             $step->evaluateSkipping($this->currentStepNumber, $this);
  470.         }
  471.     }
  473.     /**
  474.      * {@inheritDoc}
  475.      */
  476.     public function getFirstStepNumber() {
  477.         return $this->applySkipping(1);
  478.     }
  480.     /**
  481.      * {@inheritDoc}
  482.      */
  483.     public function getLastStepNumber() {
  484.         return $this->applySkipping($this->getStepCount(), -1);
  485.     }
  487.     /**
  488.      * {@inheritDoc}
  489.      */
  490.     public function nextStep() {
  491.         $currentStepNumber = $this->currentStepNumber + 1;
  493.         foreach ($this->getSteps() as $step) {
  494.             $step->evaluateSkipping($currentStepNumber, $this);
  495.         }
  497.         // There is no "next" step as the target step exceeds the actual step count.
  498.         if ($currentStepNumber > $this->getLastStepNumber()) {
  499.             return false;
  500.         }
  502.         $currentStepNumber = $this->applySkipping($currentStepNumber);
  504.         if ($currentStepNumber <= $this->getStepCount()) {
  505.             $this->currentStepNumber = $currentStepNumber;
  507.             return true;
  508.         }
  510.         return false; // should never be reached, but just in case
  511.     }
  513.     /**
  514.      * {@inheritDoc}
  515.      */
  516.     public function isStepDone($stepNumber) {
  517.         if ($this->isStepSkipped($stepNumber)) {
  518.             return true;
  519.         }
  521.         return array_key_exists($stepNumber, $this->retrieveStepData());
  522.     }
  524.     public function getRequestedTransition() {
  525.         if (empty($this->transition)) {
  526.             $this->transition = strtolower($this->getRequest()->request->get($this->getFormTransitionKey()));
  527.         }
  529.         return $this->transition;
  530.     }
  532.     protected function getRequestedStepNumber() {
  533.         $defaultStepNumber = 1;
  535.         $request = $this->getRequest();
  537.         switch ($request->getMethod()) {
  538.             case 'PUT':
  539.             case 'POST':
  540.                 return intval($request->request->get($this->getFormStepKey(), $defaultStepNumber));
  541.             case 'GET':
  542.                 return $this->allowDynamicStepNavigation || $this->allowRedirectAfterSubmit ?
  543.                         intval($request->get($this->dynamicStepNavigationStepParameter, $defaultStepNumber)) :
  544.                         $defaultStepNumber;
  545.         }
  547.         return $defaultStepNumber;
  548.     }
  550.     /**
  551.      * Finds out which step is the current one.
  552.      * @return int
  553.      */
  554.     protected function determineCurrentStepNumber() {
  555.         $requestedStepNumber = $this->getRequestedStepNumber();
  557.         if ($this->getRequestedTransition() === self::TRANSITION_BACK) {
  558.             --$requestedStepNumber;
  559.         }
  561.         $requestedStepNumber = $this->ensureStepNumberRange($requestedStepNumber);
  562.         $requestedStepNumber = $this->refineCurrentStepNumber($requestedStepNumber);
  564.         if ($this->getRequestedTransition() === self::TRANSITION_BACK) {
  565.             $requestedStepNumber = $this->applySkipping($requestedStepNumber, -1);
  567.             // re-evaluate to not keep following steps marked as skipped (after skipping them while going back)
  568.             foreach ($this->getSteps() as $step) {
  569.                 $step->evaluateSkipping($requestedStepNumber, $this);
  570.             }
  571.         } else {
  572.             $requestedStepNumber = $this->applySkipping($requestedStepNumber);
  573.         }
  575.         return $requestedStepNumber;
  576.     }
  578.     /**
  579.      * Ensures that the step number is within the range of defined steps to avoid a possible OutOfBoundsException.
  580.      * @param int $stepNumber
  581.      * @return int
  582.      */
  583.     private function ensureStepNumberRange($stepNumber) {
  584.         return max(min($stepNumber, $this->getStepCount()), 1);
  585.     }
  587.     /**
  588.      * Refines the current step number by evaluating and considering skipped steps.
  589.      * @param int $refinedStepNumber
  590.      * @return int
  591.      */
  592.     protected function refineCurrentStepNumber($refinedStepNumber) {
  593.         foreach ($this->getSteps() as $step) {
  594.             $step->evaluateSkipping($refinedStepNumber, $this);
  595.         }
  597.         return $refinedStepNumber;
  598.     }
  600.     /**
  601.      * {@inheritDoc}
  602.      */
  603.     public function bind($formData) {
  604.         $this->setInstanceId($this->determineInstanceId());
  606.         if ($this->hasListeners(FormFlowEvents::PRE_BIND)) {
  607.             $this->dispatchEvent(new PreBindEvent($this), FormFlowEvents::PRE_BIND);
  608.         }
  610.         $this->formData = $formData;
  612.         $this->bindFlow();
  614.         if ($this->hasListeners(FormFlowEvents::POST_BIND_FLOW)) {
  615.             $this->dispatchEvent(new PostBindFlowEvent($this, $this->formData), FormFlowEvents::POST_BIND_FLOW);
  616.         }
  618.         if (!$this->dataManager->exists($this)) {
  619.             // initialize storage slot
  620.             $this->dataManager->save($this, []);
  621.         }
  622.     }
  624.     protected function determineInstanceId() {
  625.         $request = $this->getRequest();
  626.         $instanceId = null;
  628.         if ($this->allowDynamicStepNavigation || $this->allowRedirectAfterSubmit) {
  629.             $instanceId = $request->get($this->getDynamicStepNavigationInstanceParameter());
  630.         }
  632.         if ($instanceId === null) {
  633.             $instanceId = $request->request->get($this->getInstanceKey());
  634.         }
  636.         $instanceIdLength = 10;
  637.         if ($instanceId === null || !StringUtil::isRandomString($instanceId, $instanceIdLength)) {
  638.             $instanceId = StringUtil::generateRandomString($instanceIdLength);
  639.         }
  641.         return $instanceId;
  642.     }
  644.     protected function bindFlow() {
  645.         $request = $this->getRequest();
  646.         $reset = false;
  648.         if (!$this->allowDynamicStepNavigation && !$this->allowRedirectAfterSubmit && $request->isMethod('GET')) {
  649.             $reset = true;
  650.         }
  652.         if ($this->getRequestedTransition() === self::TRANSITION_RESET) {
  653.             $reset = true;
  654.         }
  656.         if (in_array($request->getMethod(), ['POST', 'PUT'], true) && $request->get($this->getFormStepKey()) !== null && !$this->dataManager->exists($this)) {
  657.             // flow is expired, drop posted data and reset
  658.             $request->request->replace();
  659.             $reset = true;
  660.             $this->expired = true;
  662.             // Regenerate instance ID so resubmits of the form will continue to give error. Otherwise, submitting
  663.             // the new form, then backing up to the old form won't give the error.
  664.             $this->setInstanceId($this->determineInstanceId());
  665.         }
  667.         if (!$reset) {
  668.             $this->applyDataFromSavedSteps();
  669.         }
  671.         $requestedStepNumber = $this->determineCurrentStepNumber();
  673.         if ($reset) {
  674.             $this->reset();
  675.             return;
  676.         }
  678.         // ensure that the requested step fits the current progress
  679.         if ($requestedStepNumber > $this->getFirstStepNumber()) {
  680.             for ($step = $this->getFirstStepNumber(); $step < $requestedStepNumber; ++$step) {
  681.                 if (!$this->isStepDone($step)) {
  682.                     $this->reset();
  683.                     return;
  684.                 }
  685.             }
  686.         }
  688.         $this->currentStepNumber = $requestedStepNumber;
  690.         if (!$this->allowDynamicStepNavigation && $this->getRequestedTransition() === self::TRANSITION_BACK) {
  691.             /*
  692.              * Don't invalidate data for the current step to properly show the filled out form for that step after
  693.              * pressing "back" and refreshing the page. Otherwise, the form would be blank since the data has already
  694.              * been invalidated previously.
  695.              */
  696.             $this->invalidateStepData($this->currentStepNumber + 1);
  697.         }
  698.     }
  700.     /**
  701.      * {@inheritDoc}
  702.      */
  703.     public function saveCurrentStepData(FormInterface $form) {
  704.         $stepData = $this->retrieveStepData();
  706.         $request = $this->getRequest();
  707.         $formName = $form->getName();
  709.         if (!\class_exists('Symfony\Component\HttpFoundation\InputBag')) {
  710.             // TODO remove as soon as Symfony >= 5.1 is required
  711.             $currentStepData = $request->request->get($formName, []);
  712.         } else {
  713.             $currentStepData = $request->request->all($formName);
  714.         }
  716.         if ($this->handleFileUploads) {
  717.             $currentStepData = array_replace_recursive($currentStepData, $request->files->get($formName, []));
  718.         }
  720.         $stepData[$this->getCurrentStepNumber()] = $currentStepData;
  722.         $this->saveStepData($stepData);
  723.     }
  725.     /**
  726.      * Invalidates data for steps >= $fromStepNumber.
  727.      * @param int $fromStepNumber
  728.      */
  729.     public function invalidateStepData($fromStepNumber) {
  730.         $stepData = $this->retrieveStepData();
  732.         for ($step = $fromStepNumber, $stepCount = $this->getStepCount(); $step < $stepCount; ++$step) {
  733.             unset($stepData[$step]);
  734.         }
  736.         $this->saveStepData($stepData);
  737.     }
  739.     /**
  740.      * Updates form data class with previously saved form data of all steps.
  741.      */
  742.     protected function applyDataFromSavedSteps() {
  743.         $stepData = $this->retrieveStepData();
  745.         $this->stepForms = [];
  747.         $options = [];
  748.         if (!$this->revalidatePreviousSteps) {
  749.             $options['validation_groups'] = false; // disable validation
  750.         }
  752.         foreach ($this->getSteps() as $step) {
  753.             $stepNumber = $step->getNumber();
  755.             if (array_key_exists($stepNumber, $stepData)) {
  756.                 $stepForm = $this->createFormForStep($stepNumber, $options);
  757.                 $stepForm->submit($stepData[$stepNumber]); // the form is validated here
  759.                 if ($this->revalidatePreviousSteps) {
  760.                     $this->stepForms[$stepNumber] = $stepForm;
  761.                 }
  763.                 if ($this->hasListeners(FormFlowEvents::POST_BIND_SAVED_DATA)) {
  764.                     $this->dispatchEvent(new PostBindSavedDataEvent($this, $this->formData, $stepNumber), FormFlowEvents::POST_BIND_SAVED_DATA);
  765.                 }
  766.             }
  767.         }
  768.     }
  770.     /**
  771.      * {@inheritDoc}
  772.      */
  773.     public function createForm() {
  774.         $form = $this->createFormForStep($this->currentStepNumber);
  776.         if ($this->expired && $this->hasListeners(FormFlowEvents::FLOW_EXPIRED)) {
  777.             $this->dispatchEvent(new FlowExpiredEvent($this, $form), FormFlowEvents::FLOW_EXPIRED);
  778.         }
  780.         return $form;
  781.     }
  783.     public function getFormOptions($step, array $options = []) {
  784.         // override options in a specific order
  785.         $options = array_merge(
  786.             $this->getGenericFormOptions(),
  787.             $this->getStep($step)->getFormOptions(),
  788.             $options
  789.         );
  791.         // add the generated step-based validation group, unless it's explicitly set to false, a closure, or a GroupSequence
  792.         if (!array_key_exists('validation_groups', $options)) {
  793.             $options['validation_groups'] = [$this->getValidationGroupPrefix() . $step];
  794.         } else {
  795.             $vg = $options['validation_groups'];
  797.             if ($vg !== false && !is_a($vg, 'Closure') && !$vg instanceof GroupSequence) {
  798.                 $options['validation_groups'] = array_merge(
  799.                     [$this->getValidationGroupPrefix() . $step],
  800.                     (array) $vg
  801.                 );
  802.             }
  803.         }
  805.         $options['flow_instance'] = $this->getInstanceId();
  806.         $options['flow_instance_key'] = $this->getInstanceKey();
  808.         $options['flow_step'] = $step;
  809.         $options['flow_step_key'] = $this->getFormStepKey();
  811.         return $options;
  812.     }
  814.     /**
  815.      * {@inheritDoc}
  816.      */
  817.     public function getStep($stepNumber) {
  818.         if (!is_int($stepNumber)) {
  819.             throw new InvalidTypeException($stepNumber, 'int');
  820.         }
  822.         $steps = $this->getSteps();
  823.         $index = $stepNumber - 1;
  825.         if (array_key_exists($index, $steps)) {
  826.             return $steps[$index];
  827.         }
  829.         throw new \OutOfBoundsException(sprintf('The step "%d" does not exist.', $stepNumber));
  830.     }
  832.     /**
  833.      * {@inheritDoc}
  834.      */
  835.     public function getSteps() {
  836.         // The steps have been loaded already.
  837.         if ($this->steps !== null) {
  838.             return $this->steps;
  839.         }
  841.         if ($this->hasListeners(FormFlowEvents::GET_STEPS)) {
  842.             $event = new GetStepsEvent($this);
  843.             $this->dispatchEvent($event, FormFlowEvents::GET_STEPS);
  845.             // A listener has provided the steps for this flow.
  846.             if ($event->isPropagationStopped()) {
  847.                 $this->steps = $event->getSteps();
  849.                 return $this->steps;
  850.             }
  851.         }
  853.         // There are either no listeners on the event at all or none created the steps for this flow, so load from configuration.
  854.         $this->steps = $this->createStepsFromConfig($this->loadStepsConfig());
  856.         return $this->steps;
  857.     }
  859.     /**
  860.      * {@inheritDoc}
  861.      */
  862.     public function getStepLabels() {
  863.         if ($this->stepLabels === null) {
  864.             $stepLabels = [];
  866.             foreach ($this->getSteps() as $step) {
  867.                 $stepLabels[] = $step->getLabel();
  868.             }
  870.             $this->stepLabels = $stepLabels;
  871.         }
  873.         return $this->stepLabels;
  874.     }
  876.     /**
  877.      * {@inheritDoc}
  878.      */
  879.     public function getCurrentStepLabel() {
  880.         return $this->getStep($this->currentStepNumber)->getLabel();
  881.     }
  883.     /**
  884.      * {@inheritDoc}
  885.      */
  886.     public function isValid(FormInterface $form) {
  887.         $request = $this->getRequest();
  889.         if (in_array($request->getMethod(), ['POST', 'PUT'], true) && !in_array($this->getRequestedTransition(), [
  890.             self::TRANSITION_BACK,
  891.             self::TRANSITION_RESET,
  892.         ], true)) {
  893.             $form->handleRequest($request);
  895.             if (!$form->isSubmitted()) {
  896.                 return false;
  897.             }
  899.             if ($this->hasListeners(FormFlowEvents::POST_BIND_REQUEST)) {
  900.                 $this->dispatchEvent(new PostBindRequestEvent($this, $form->getData(), $this->currentStepNumber), FormFlowEvents::POST_BIND_REQUEST);
  901.             }
  903.             if ($this->revalidatePreviousSteps) {
  904.                 // check if forms of previous steps are still valid
  905.                 foreach ($this->stepForms as $stepNumber => $stepForm) {
  906.                     // ignore form of the current step
  907.                     if ($this->currentStepNumber === $stepNumber) {
  908.                         break;
  909.                     }
  911.                     // ignore forms of skipped steps
  912.                     if ($this->isStepSkipped($stepNumber)) {
  913.                         break;
  914.                     }
  916.                     if (!$stepForm->isValid()) {
  917.                         if ($this->hasListeners(FormFlowEvents::PREVIOUS_STEP_INVALID)) {
  918.                             $this->dispatchEvent(new PreviousStepInvalidEvent($this, $form, $stepNumber), FormFlowEvents::PREVIOUS_STEP_INVALID);
  919.                         }
  921.                         return false;
  922.                     }
  923.                 }
  924.             }
  926.             if ($form->isValid()) {
  927.                 if ($this->hasListeners(FormFlowEvents::POST_VALIDATE)) {
  928.                     $this->dispatchEvent(new PostValidateEvent($this, $form->getData()), FormFlowEvents::POST_VALIDATE);
  929.                 }
  931.                 return true;
  932.             }
  933.         }
  935.         return false;
  936.     }
  938.     /**
  939.      * @param FormInterface $submittedForm
  940.      * @return bool If a redirection should be performed.
  941.      */
  942.     public function redirectAfterSubmit(FormInterface $submittedForm) {
  943.         if ($this->allowRedirectAfterSubmit && in_array($this->getRequest()->getMethod(), ['POST', 'PUT'], true)) {
  944.             switch ($this->getRequestedTransition()) {
  945.                 case self::TRANSITION_BACK:
  946.                 case self::TRANSITION_RESET:
  947.                     return true;
  948.                 default:
  949.                     // redirect after submit only if there are no errors for the submitted form
  950.                     return $submittedForm->isSubmitted() && $submittedForm->isValid();
  951.             }
  952.         }
  954.         return false;
  955.     }
  957.     /**
  958.      * Creates the form for the given step number.
  959.      * @param int $stepNumber
  960.      * @param array $options
  961.      * @return FormInterface
  962.      */
  963.     protected function createFormForStep($stepNumber, array $options = []) {
  964.         $formType = $this->getStep($stepNumber)->getFormType();
  965.         $options = $this->getFormOptions($stepNumber, $options);
  967.         if ($formType === null) {
  968.             $formType = FormType::class;
  969.         }
  971.         return $this->formFactory->create($formType, $this->formData, $options);
  972.     }
  974.     /**
  975.      * Creates all steps from the given configuration.
  976.      * @param array $stepsConfig
  977.      * @return StepInterface[] Value with index 0 is step 1.
  978.      */
  979.     public function createStepsFromConfig(array $stepsConfig) {
  980.         $steps = [];
  982.         // fix array indexes not starting at 0
  983.         $stepsConfig = array_values($stepsConfig);
  985.         foreach ($stepsConfig as $index => $stepConfig) {
  986.             $steps[] = Step::createFromConfig($index + 1, $stepConfig);
  987.         }
  989.         return $steps;
  990.     }
  992.     /**
  993.      * Defines the configuration for all steps of this flow.
  994.      * @return array
  995.      */
  996.     protected function loadStepsConfig() {
  997.         return [];
  998.     }
  1000.     protected function retrieveStepData() {
  1001.         return $this->dataManager->load($this);
  1002.     }
  1004.     protected function saveStepData(array $data) {
  1005.         $this->dataManager->save($this, $data);
  1006.     }
  1008.     /**
  1009.      * @param string $eventName
  1010.      * @return bool
  1011.      */
  1012.     protected function hasListeners($eventName) {
  1013.         return $this->eventDispatcher !== null && $this->eventDispatcher->hasListeners($eventName);
  1014.     }
  1016.     /**
  1017.      * @param FormFlowEvent $event
  1018.      * @param string $eventName
  1019.      */
  1020.     private function dispatchEvent($event, $eventName) {
  1021.         if (Kernel::VERSION_ID < 40300) {
  1022.             // TODO remove as soon as Symfony >= 4.3 is required
  1023.             $this->eventDispatcher->dispatch($eventName, $event);
  1024.         } else {
  1025.             $this->eventDispatcher->dispatch($event, $eventName);
  1026.         }
  1027.     }
  1029.     /**
  1030.      * {@inheritDoc}
  1031.      */
  1032.     public function getStepsDone() {
  1033.         $stepsDone = [];
  1035.         foreach ($this->getSteps() as $step) {
  1036.             if ($this->isStepDone($step->getNumber())) {
  1037.                 $stepsDone[] = $step;
  1038.             }
  1039.         }
  1041.         return $stepsDone;
  1042.     }
  1044.     /**
  1045.      * {@inheritDoc}
  1046.      */
  1047.     public function getStepsRemaining() {
  1048.         $stepsRemaining = [];
  1050.         foreach ($this->getSteps() as $step) {
  1051.             if (!$this->isStepDone($step->getNumber())) {
  1052.                 $stepsRemaining[] = $step;
  1053.             }
  1054.         }
  1056.         return $stepsRemaining;
  1057.     }
  1059.     /**
  1060.      * {@inheritDoc}
  1061.      */
  1062.     public function getStepsDoneCount() {
  1063.         return count($this->getStepsDone());
  1064.     }
  1066.     /**
  1067.      * {@inheritDoc}
  1068.      */
  1069.     public function getStepsRemainingCount() {
  1070.         return count($this->getStepsRemaining());
  1071.     }
  1073.     // methods for BC with third-party templates (e.g. MopaBootstrapBundle)
  1075.     public function getCurrentStep() {
  1076.         @trigger_error('Method ' . __METHOD__ . ' is deprecated since CraueFormFlowBundle 2.0. Use method getCurrentStepNumber instead.', E_USER_DEPRECATED);
  1077.         return $this->getCurrentStepNumber();
  1078.     }
  1080.     public function getCurrentStepDescription() {
  1081.         @trigger_error('Method ' . __METHOD__ . ' is deprecated since CraueFormFlowBundle 2.0. Use method getCurrentStepLabel instead.', E_USER_DEPRECATED);
  1082.         return $this->getCurrentStepLabel();
  1083.     }
  1085.     public function getMaxSteps() {
  1086.         @trigger_error('Method ' . __METHOD__ . ' is deprecated since CraueFormFlowBundle 2.0. Use method getStepCount instead.', E_USER_DEPRECATED);
  1087.         return $this->getStepCount();
  1088.     }
  1090.     public function getStepDescriptions() {
  1091.         @trigger_error('Method ' . __METHOD__ . ' is deprecated since CraueFormFlowBundle 2.0. Use method getStepLabels instead.', E_USER_DEPRECATED);
  1092.         return $this->getStepLabels();
  1093.     }
  1095.     public function getFirstStep() {
  1096.         @trigger_error('Method ' . __METHOD__ . ' is deprecated since CraueFormFlowBundle 2.0. Use method getFirstStepNumber instead.', E_USER_DEPRECATED);
  1097.         return $this->getFirstStepNumber();
  1098.     }
  1100.     public function getLastStep() {
  1101.         @trigger_error('Method ' . __METHOD__ . ' is deprecated since CraueFormFlowBundle 2.0. Use method getLastStepNumber instead.', E_USER_DEPRECATED);
  1102.         return $this->getLastStepNumber();
  1103.     }
  1105.     public function hasSkipStep($stepNumber) {
  1106.         @trigger_error('Method ' . __METHOD__ . ' is deprecated since CraueFormFlowBundle 2.0. Use method isStepSkipped instead.', E_USER_DEPRECATED);
  1107.         return $this->isStepSkipped($stepNumber);
  1108.     }
  1110. }