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

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\Validator\Constraints\GroupSequence;
  26. /**
  27.  * @author Christian Raue <christian.raue@gmail.com>
  28.  * @author Marcus Stöhr <dafish@soundtrack-board.de>
  29.  * @author Toni Uebernickel <tuebernickel@gmail.com>
  30.  * @copyright 2011-2024 Christian Raue
  31.  * @license http://opensource.org/licenses/mit-license.php MIT License
  32.  */
  33. abstract class FormFlow implements FormFlowInterface {
  35.     const TRANSITION_BACK = 'back';
  36.     const TRANSITION_RESET = 'reset';
  38.     /**
  39.      * @var FormFactoryInterface
  40.      */
  41.     protected $formFactory;
  43.     /**
  44.      * @var DataManagerInterface
  45.      */
  46.     protected $dataManager;
  48.     /**
  49.      * @var EventDispatcherInterface|null
  50.      */
  51.     protected $eventDispatcher = null;
  53.     /**
  54.      * @var string|null
  55.      */
  56.     protected $transition;
  58.     /**
  59.      * @var bool
  60.      */
  61.     protected $revalidatePreviousSteps = true;
  63.     /**
  64.      * @var bool
  65.      */
  66.     protected $allowDynamicStepNavigation = false;
  68.     /**
  69.      * @var bool If file uploads should be handled by serializing them into the storage.
  70.      */
  71.     protected $handleFileUploads = true;
  73.     /**
  74.      * @var string|null Directory for storing temporary files while handling uploads. If <code>null</code>, the system's default will be used.
  75.      */
  76.     protected $handleFileUploadsTempDir = null;
  78.     /**
  79.      * @var bool
  80.      */
  81.     protected $allowRedirectAfterSubmit = false;
  83.     /**
  84.      * @var string
  85.      */
  86.     protected $dynamicStepNavigationInstanceParameter = 'instance';
  88.     /**
  89.      * @var string
  90.      */
  91.     protected $dynamicStepNavigationStepParameter = 'step';
  93.     /**
  94.      * @var RequestStack
  95.      */
  96.     private $requestStack;
  98.     /**
  99.      * @var string|null Is only null if not yet initialized.
  100.      */
  101.     private $id = null;
  103.     /**
  104.      * @var string|null Is only null if not yet initialized.
  105.      */
  106.     private $instanceKey = null;
  108.     /**
  109.      * @var string|null Is only null if not yet initialized.
  110.      */
  111.     private $instanceId = null;
  113.     /**
  114.      * @var string|null Is only null if not yet initialized.
  115.      */
  116.     private $formStepKey = null;
  118.     /**
  119.      * @var string|null Is only null if not yet initialized.
  120.      */
  121.     private $formTransitionKey = null;
  123.     /**
  124.      * @var string|null Is only null if not yet initialized.
  125.      */
  126.     private $validationGroupPrefix = null;
  128.     /**
  129.      * @var StepInterface[]|null Is only null if not yet initialized.
  130.      */
  131.     private $steps = null;
  133.     /**
  134.      * @var int|null Is only null if not yet initialized.
  135.      */
  136.     private $stepCount = null;
  138.     /**
  139.      * @var string[]|null Is only null if not yet initialized.
  140.      */
  141.     private $stepLabels = null;
  143.     /**
  144.      * @var mixed|null Is only null if not yet initialized.
  145.      */
  146.     private $formData = null;
  148.     /**
  149.      * @var int|null Is only null if not yet initialized.
  150.      */
  151.     private $currentStepNumber = null;
  153.     /**
  154.      * @var FormInterface[]
  155.      */
  156.     private $stepForms = [];
  158.     /**
  159.      * Options applied to forms of all steps.
  160.      * @var array
  161.      */
  162.     private $genericFormOptions = [];
  164.     /**
  165.      * Flow was determined to be expired.
  166.      * @var bool
  167.      */
  168.     private $expired = false;
  170.     /**
  171.      * {@inheritDoc}
  172.      */
  173.     public function setFormFactory(FormFactoryInterface $formFactory) {
  174.         $this->formFactory = $formFactory;
  175.     }
  177.     /**
  178.      * {@inheritDoc}
  179.      */
  180.     public function setRequestStack(RequestStack $requestStack) {
  181.         $this->requestStack = $requestStack;
  182.     }
  184.     /**
  185.      * @return Request
  186.      * @throws \RuntimeException If the request is not available.
  187.      */
  188.     public function getRequest() {
  189.         $currentRequest = $this->requestStack->getCurrentRequest();
  191.         if ($currentRequest === null) {
  192.             throw new \RuntimeException('The request is not available.');
  193.         }
  195.         return $currentRequest;
  196.     }
  198.     /**
  199.      * {@inheritDoc}
  200.      */
  201.     public function setDataManager(DataManagerInterface $dataManager) {
  202.         $this->dataManager = $dataManager;
  203.     }
  205.     /**
  206.      * {@inheritDoc}
  207.      */
  208.     public function getDataManager() {
  209.         return $this->dataManager;
  210.     }
  212.     /**
  213.      * {@inheritDoc}
  214.      */
  215.     public function setEventDispatcher(EventDispatcherInterface $eventDispatcher) {
  216.         $this->eventDispatcher = $eventDispatcher;
  217.     }
  219.     public function setId($id) {
  220.         $this->id = $id;
  221.     }
  223.     /**
  224.      * {@inheritDoc}
  225.      */
  226.     public function getId() {
  227.         if ($this->id === null) {
  228.             $this->id = 'flow_' . $this->getName();
  229.         }
  231.         return $this->id;
  232.     }
  234.     /**
  235.      * {@inheritDoc}
  236.      */
  237.     public function getName() {
  238.         return StringUtil::fqcnToFlowName(get_class($this));
  239.     }
  241.     public function setInstanceKey($instanceKey) {
  242.         $this->instanceKey = $instanceKey;
  243.     }
  245.     public function getInstanceKey() {
  246.         if ($this->instanceKey === null) {
  247.             $this->instanceKey = $this->getId() . '_instance';
  248.         }
  250.         return $this->instanceKey;
  251.     }
  253.     public function setInstanceId($instanceId) {
  254.         $this->instanceId = $instanceId;
  255.     }
  257.     /**
  258.      * {@inheritDoc}
  259.      */
  260.     public function getInstanceId() {
  261.         if ($this->instanceId === null) {
  262.             $this->instanceId = $this->getId();
  263.         }
  265.         return $this->instanceId;
  266.     }
  268.     public function setFormStepKey($formStepKey) {
  269.         $this->formStepKey = $formStepKey;
  270.     }
  272.     public function getFormStepKey() {
  273.         if ($this->formStepKey === null) {
  274.             $this->formStepKey = $this->getId() . '_step';
  275.         }
  277.         return $this->formStepKey;
  278.     }
  280.     public function setFormTransitionKey($formTransitionKey) {
  281.         $this->formTransitionKey = $formTransitionKey;
  282.     }
  284.     public function getFormTransitionKey() {
  285.         if ($this->formTransitionKey === null) {
  286.             $this->formTransitionKey = $this->getId() . '_transition';
  287.         }
  289.         return $this->formTransitionKey;
  290.     }
  292.     public function setValidationGroupPrefix($validationGroupPrefix) {
  293.         $this->validationGroupPrefix = $validationGroupPrefix;
  294.     }
  296.     public function getValidationGroupPrefix() {
  297.         if ($this->validationGroupPrefix === null) {
  298.             $this->validationGroupPrefix = $this->getId() . '_step';
  299.         }
  301.         return $this->validationGroupPrefix;
  302.     }
  304.     /**
  305.      * {@inheritDoc}
  306.      */
  307.     public function getStepCount() {
  308.         if ($this->stepCount === null) {
  309.             $this->stepCount = count($this->getSteps());
  310.         }
  312.         return $this->stepCount;
  313.     }
  315.     /**
  316.      * {@inheritDoc}
  317.      */
  318.     public function getFormData() {
  319.         if ($this->formData === null) {
  320.             throw new \RuntimeException('Form data has not been evaluated yet and thus cannot be accessed.');
  321.         }
  323.         return $this->formData;
  324.     }
  326.     /**
  327.      * {@inheritDoc}
  328.      */
  329.     public function getCurrentStepNumber() {
  330.         if ($this->currentStepNumber === null) {
  331.             throw new \RuntimeException('The current step has not been determined yet and thus cannot be accessed.');
  332.         }
  334.         return $this->currentStepNumber;
  335.     }
  337.     public function setRevalidatePreviousSteps($revalidatePreviousSteps) {
  338.         $this->revalidatePreviousSteps = (bool) $revalidatePreviousSteps;
  339.     }
  341.     /**
  342.      * {@inheritDoc}
  343.      */
  344.     public function isRevalidatePreviousSteps() {
  345.         return $this->revalidatePreviousSteps;
  346.     }
  348.     public function setAllowDynamicStepNavigation($allowDynamicStepNavigation) {
  349.         $this->allowDynamicStepNavigation = (bool) $allowDynamicStepNavigation;
  350.     }
  352.     /**
  353.      * {@inheritDoc}
  354.      */
  355.     public function isAllowDynamicStepNavigation() {
  356.         return $this->allowDynamicStepNavigation;
  357.     }
  359.     public function setHandleFileUploads($handleFileUploads) {
  360.         $this->handleFileUploads = (bool) $handleFileUploads;
  361.     }
  363.     /**
  364.      * {@inheritDoc}
  365.      */
  366.     public function isHandleFileUploads() {
  367.         return $this->handleFileUploads;
  368.     }
  370.     public function setHandleFileUploadsTempDir($handleFileUploadsTempDir) {
  371.         $this->handleFileUploadsTempDir = $handleFileUploadsTempDir !== null ? (string) $handleFileUploadsTempDir : null;
  372.     }
  374.     /**
  375.      * {@inheritDoc}
  376.      */
  377.     public function getHandleFileUploadsTempDir() {
  378.         return $this->handleFileUploadsTempDir;
  379.     }
  381.     public function setAllowRedirectAfterSubmit($allowRedirectAfterSubmit) {
  382.         $this->allowRedirectAfterSubmit = (bool) $allowRedirectAfterSubmit;
  383.     }
  385.     /**
  386.      * {@inheritDoc}
  387.      */
  388.     public function isAllowRedirectAfterSubmit() {
  389.         return $this->allowRedirectAfterSubmit;
  390.     }
  392.     public function setDynamicStepNavigationInstanceParameter($dynamicStepNavigationInstanceParameter) {
  393.         $this->dynamicStepNavigationInstanceParameter = $dynamicStepNavigationInstanceParameter;
  394.     }
  396.     public function getDynamicStepNavigationInstanceParameter() {
  397.         return $this->dynamicStepNavigationInstanceParameter;
  398.     }
  400.     public function setDynamicStepNavigationStepParameter($dynamicStepNavigationStepParameter) {
  401.         $this->dynamicStepNavigationStepParameter = $dynamicStepNavigationStepParameter;
  402.     }
  404.     public function getDynamicStepNavigationStepParameter() {
  405.         return $this->dynamicStepNavigationStepParameter;
  406.     }
  408.     public function setGenericFormOptions(array $genericFormOptions) {
  409.         $this->genericFormOptions = $genericFormOptions;
  410.     }
  412.     public function getGenericFormOptions() {
  413.         return $this->genericFormOptions;
  414.     }
  416.     /**
  417.      * {@inheritDoc}
  418.      */
  419.     public function isStepSkipped($stepNumber) {
  420.         return $this->getStep($stepNumber)->isSkipped();
  421.     }
  423.     /**
  424.      * @param int $stepNumber Assumed step to which skipped steps shall be applied to.
  425.      * @param int $direction Either 1 (to skip forwards) or -1 (to skip backwards).
  426.      * @param int $boundsReached Internal counter to avoid endlessly bouncing back and forth.
  427.      * @return int Target step number with skipping applied.
  428.      * @throws \InvalidArgumentException If the value of <code>$direction</code> is invalid.
  429.      */
  430.     protected function applySkipping($stepNumber, $direction = 1, $boundsReached = 0) {
  431.         if ($direction !== 1 && $direction !== -1) {
  432.             throw new \InvalidArgumentException(sprintf('Argument of either -1 or 1 expected, "%s" given.', $direction));
  433.         }
  435.         $stepNumber = $this->ensureStepNumberRange($stepNumber);
  437.         if ($this->isStepSkipped($stepNumber)) {
  438.             $stepNumber += $direction;
  440.             // change direction if outer bounds are reached
  441.             if ($direction === 1 && $stepNumber > $this->getStepCount()) {
  442.                 $direction = -1;
  443.                 ++$boundsReached;
  444.             } elseif ($direction === -1 && $stepNumber < 1) {
  445.                 $direction = 1;
  446.                 ++$boundsReached;
  447.             }
  449.             if ($boundsReached > 2) {
  450.                 throw new AllStepsSkippedException();
  451.             }
  453.             return $this->applySkipping($stepNumber, $direction, $boundsReached);
  454.         }
  456.         return $stepNumber;
  457.     }
  459.     /**
  460.      * {@inheritDoc}
  461.      */
  462.     public function reset() {
  463.         $this->dataManager->drop($this);
  464.         $this->currentStepNumber = $this->getFirstStepNumber();
  466.         // re-evaluate to not keep steps marked as skipped when resetting
  467.         foreach ($this->getSteps() as $step) {
  468.             $step->evaluateSkipping($this->currentStepNumber, $this);
  469.         }
  470.     }
  472.     /**
  473.      * {@inheritDoc}
  474.      */
  475.     public function getFirstStepNumber() {
  476.         return $this->applySkipping(1);
  477.     }
  479.     /**
  480.      * {@inheritDoc}
  481.      */
  482.     public function getLastStepNumber() {
  483.         return $this->applySkipping($this->getStepCount(), -1);
  484.     }
  486.     /**
  487.      * {@inheritDoc}
  488.      */
  489.     public function nextStep() {
  490.         $currentStepNumber = $this->currentStepNumber + 1;
  492.         foreach ($this->getSteps() as $step) {
  493.             $step->evaluateSkipping($currentStepNumber, $this);
  494.         }
  496.         // There is no "next" step as the target step exceeds the actual step count.
  497.         if ($currentStepNumber > $this->getLastStepNumber()) {
  498.             return false;
  499.         }
  501.         $currentStepNumber = $this->applySkipping($currentStepNumber);
  503.         if ($currentStepNumber <= $this->getStepCount()) {
  504.             $this->currentStepNumber = $currentStepNumber;
  506.             return true;
  507.         }
  509.         return false; // should never be reached, but just in case
  510.     }
  512.     /**
  513.      * {@inheritDoc}
  514.      */
  515.     public function isStepDone($stepNumber) {
  516.         if ($this->isStepSkipped($stepNumber)) {
  517.             return true;
  518.         }
  520.         return array_key_exists($stepNumber, $this->retrieveStepData());
  521.     }
  523.     public function getRequestedTransition() {
  524.         if (!is_string($this->transition) || $this->transition === '') {
  525.             $this->transition = strtolower($this->getRequest()->request->get($this->getFormTransitionKey(), ''));
  526.         }
  528.         return $this->transition;
  529.     }
  531.     protected function getRequestedStepNumber() {
  532.         $defaultStepNumber = 1;
  534.         $request = $this->getRequest();
  536.         switch ($request->getMethod()) {
  537.             case 'PUT':
  538.             case 'POST':
  539.                 return intval($request->request->get($this->getFormStepKey(), $defaultStepNumber));
  540.             case 'GET':
  541.                 return $this->allowDynamicStepNavigation || $this->allowRedirectAfterSubmit ?
  542.                         intval($request->get($this->dynamicStepNavigationStepParameter, $defaultStepNumber)) :
  543.                         $defaultStepNumber;
  544.         }
  546.         return $defaultStepNumber;
  547.     }
  549.     /**
  550.      * Finds out which step is the current one.
  551.      * @return int
  552.      */
  553.     protected function determineCurrentStepNumber() {
  554.         $requestedStepNumber = $this->getRequestedStepNumber();
  556.         if ($this->getRequestedTransition() === self::TRANSITION_BACK) {
  557.             --$requestedStepNumber;
  558.         }
  560.         $requestedStepNumber = $this->ensureStepNumberRange($requestedStepNumber);
  561.         $requestedStepNumber = $this->refineCurrentStepNumber($requestedStepNumber);
  563.         if ($this->getRequestedTransition() === self::TRANSITION_BACK) {
  564.             $requestedStepNumber = $this->applySkipping($requestedStepNumber, -1);
  566.             // re-evaluate to not keep following steps marked as skipped (after skipping them while going back)
  567.             foreach ($this->getSteps() as $step) {
  568.                 $step->evaluateSkipping($requestedStepNumber, $this);
  569.             }
  570.         } else {
  571.             $requestedStepNumber = $this->applySkipping($requestedStepNumber);
  572.         }
  574.         return $requestedStepNumber;
  575.     }
  577.     /**
  578.      * Ensures that the step number is within the range of defined steps to avoid a possible OutOfBoundsException.
  579.      * @param int $stepNumber
  580.      * @return int
  581.      */
  582.     private function ensureStepNumberRange($stepNumber) {
  583.         return max(min($stepNumber, $this->getStepCount()), 1);
  584.     }
  586.     /**
  587.      * Refines the current step number by evaluating and considering skipped steps.
  588.      * @param int $refinedStepNumber
  589.      * @return int
  590.      */
  591.     protected function refineCurrentStepNumber($refinedStepNumber) {
  592.         foreach ($this->getSteps() as $step) {
  593.             $step->evaluateSkipping($refinedStepNumber, $this);
  594.         }
  596.         return $refinedStepNumber;
  597.     }
  599.     /**
  600.      * {@inheritDoc}
  601.      */
  602.     public function bind($formData) {
  603.         $this->setInstanceId($this->determineInstanceId());
  605.         if ($this->hasListeners(FormFlowEvents::PRE_BIND)) {
  606.             $this->dispatchEvent(new PreBindEvent($this), FormFlowEvents::PRE_BIND);
  607.         }
  609.         $this->formData = $formData;
  611.         $this->bindFlow();
  613.         if ($this->hasListeners(FormFlowEvents::POST_BIND_FLOW)) {
  614.             $this->dispatchEvent(new PostBindFlowEvent($this, $this->formData), FormFlowEvents::POST_BIND_FLOW);
  615.         }
  617.         if (!$this->dataManager->exists($this)) {
  618.             // initialize storage slot
  619.             $this->dataManager->save($this, []);
  620.         }
  621.     }
  623.     protected function determineInstanceId() {
  624.         $request = $this->getRequest();
  625.         $instanceId = null;
  627.         if ($this->allowDynamicStepNavigation || $this->allowRedirectAfterSubmit) {
  628.             $instanceId = $request->get($this->getDynamicStepNavigationInstanceParameter());
  629.         }
  631.         if ($instanceId === null) {
  632.             $instanceId = $request->request->get($this->getInstanceKey());
  633.         }
  635.         $instanceIdLength = 10;
  636.         if ($instanceId === null || !StringUtil::isRandomString($instanceId, $instanceIdLength)) {
  637.             $instanceId = StringUtil::generateRandomString($instanceIdLength);
  638.         }
  640.         return $instanceId;
  641.     }
  643.     protected function bindFlow() {
  644.         $request = $this->getRequest();
  645.         $reset = false;
  647.         if (!$this->allowDynamicStepNavigation && !$this->allowRedirectAfterSubmit && $request->isMethod('GET')) {
  648.             $reset = true;
  649.         }
  651.         if ($this->getRequestedTransition() === self::TRANSITION_RESET) {
  652.             $reset = true;
  653.         }
  655.         if (in_array($request->getMethod(), ['POST', 'PUT'], true) && $request->get($this->getFormStepKey()) !== null && !$this->dataManager->exists($this)) {
  656.             // flow is expired, drop posted data and reset
  657.             $request->request->replace();
  658.             $reset = true;
  659.             $this->expired = true;
  661.             // Regenerate instance ID so resubmits of the form will continue to give error. Otherwise, submitting
  662.             // the new form, then backing up to the old form won't give the error.
  663.             $this->setInstanceId($this->determineInstanceId());
  664.         }
  666.         if (!$reset) {
  667.             $this->applyDataFromSavedSteps();
  668.         }
  670.         $requestedStepNumber = $this->determineCurrentStepNumber();
  672.         if ($reset) {
  673.             $this->reset();
  674.             return;
  675.         }
  677.         // ensure that the requested step fits the current progress
  678.         if ($requestedStepNumber > $this->getFirstStepNumber()) {
  679.             for ($step = $this->getFirstStepNumber(); $step < $requestedStepNumber; ++$step) {
  680.                 if (!$this->isStepDone($step)) {
  681.                     $this->reset();
  682.                     return;
  683.                 }
  684.             }
  685.         }
  687.         $this->currentStepNumber = $requestedStepNumber;
  689.         if (!$this->allowDynamicStepNavigation && $this->getRequestedTransition() === self::TRANSITION_BACK) {
  690.             /*
  691.              * Don't invalidate data for the current step to properly show the filled out form for that step after
  692.              * pressing "back" and refreshing the page. Otherwise, the form would be blank since the data has already
  693.              * been invalidated previously.
  694.              */
  695.             $this->invalidateStepData($this->currentStepNumber + 1);
  696.         }
  697.     }
  699.     /**
  700.      * {@inheritDoc}
  701.      */
  702.     public function saveCurrentStepData(FormInterface $form) {
  703.         $stepData = $this->retrieveStepData();
  705.         $request = $this->getRequest();
  706.         $formName = $form->getName();
  708.         if (!\class_exists('Symfony\Component\HttpFoundation\InputBag')) {
  709.             // TODO remove as soon as Symfony >= 5.1 is required
  710.             $currentStepData = $request->request->get($formName, []);
  711.         } else {
  712.             $currentStepData = $request->request->all($formName);
  713.         }
  715.         if ($this->handleFileUploads) {
  716.             $currentStepData = array_replace_recursive($currentStepData, $request->files->get($formName, []));
  717.         }
  719.         $stepData[$this->getCurrentStepNumber()] = $currentStepData;
  721.         $this->saveStepData($stepData);
  722.     }
  724.     /**
  725.      * Invalidates data for steps >= $fromStepNumber.
  726.      * @param int $fromStepNumber
  727.      */
  728.     public function invalidateStepData($fromStepNumber) {
  729.         $stepData = $this->retrieveStepData();
  731.         for ($step = $fromStepNumber, $stepCount = $this->getStepCount(); $step < $stepCount; ++$step) {
  732.             unset($stepData[$step]);
  733.         }
  735.         $this->saveStepData($stepData);
  736.     }
  738.     /**
  739.      * Updates form data class with previously saved form data of all steps.
  740.      */
  741.     protected function applyDataFromSavedSteps() {
  742.         $stepData = $this->retrieveStepData();
  744.         $this->stepForms = [];
  746.         $options = [];
  747.         if (!$this->revalidatePreviousSteps) {
  748.             $options['validation_groups'] = false; // disable validation
  749.         }
  751.         foreach ($this->getSteps() as $step) {
  752.             $stepNumber = $step->getNumber();
  754.             if (array_key_exists($stepNumber, $stepData)) {
  755.                 $stepForm = $this->createFormForStep($stepNumber, $options);
  756.                 $stepForm->submit($stepData[$stepNumber]); // the form is validated here
  758.                 if ($this->revalidatePreviousSteps) {
  759.                     $this->stepForms[$stepNumber] = $stepForm;
  760.                 }
  762.                 if ($this->hasListeners(FormFlowEvents::POST_BIND_SAVED_DATA)) {
  763.                     $this->dispatchEvent(new PostBindSavedDataEvent($this, $this->formData, $stepNumber), FormFlowEvents::POST_BIND_SAVED_DATA);
  764.                 }
  765.             }
  766.         }
  767.     }
  769.     /**
  770.      * {@inheritDoc}
  771.      */
  772.     public function createForm() {
  773.         $form = $this->createFormForStep($this->currentStepNumber);
  775.         if ($this->expired && $this->hasListeners(FormFlowEvents::FLOW_EXPIRED)) {
  776.             $this->dispatchEvent(new FlowExpiredEvent($this, $form), FormFlowEvents::FLOW_EXPIRED);
  777.         }
  779.         return $form;
  780.     }
  782.     public function getFormOptions($step, array $options = []) {
  783.         // override options in a specific order
  784.         $options = array_merge(
  785.             $this->getGenericFormOptions(),
  786.             $this->getStep($step)->getFormOptions(),
  787.             $options
  788.         );
  790.         // add the generated step-based validation group, unless it's explicitly set to false, a closure, or a GroupSequence
  791.         if (!array_key_exists('validation_groups', $options)) {
  792.             $options['validation_groups'] = [$this->getValidationGroupPrefix() . $step];
  793.         } else {
  794.             $vg = $options['validation_groups'];
  796.             if ($vg !== false && !is_a($vg, 'Closure') && !$vg instanceof GroupSequence) {
  797.                 $options['validation_groups'] = array_merge(
  798.                     [$this->getValidationGroupPrefix() . $step],
  799.                     (array) $vg
  800.                 );
  801.             }
  802.         }
  804.         $options['flow_instance'] = $this->getInstanceId();
  805.         $options['flow_instance_key'] = $this->getInstanceKey();
  807.         $options['flow_step'] = $step;
  808.         $options['flow_step_key'] = $this->getFormStepKey();
  810.         return $options;
  811.     }
  813.     /**
  814.      * {@inheritDoc}
  815.      */
  816.     public function getStep($stepNumber) {
  817.         if (!is_int($stepNumber)) {
  818.             throw new InvalidTypeException($stepNumber, 'int');
  819.         }
  821.         $steps = $this->getSteps();
  822.         $index = $stepNumber - 1;
  824.         if (array_key_exists($index, $steps)) {
  825.             return $steps[$index];
  826.         }
  828.         throw new \OutOfBoundsException(sprintf('The step "%d" does not exist.', $stepNumber));
  829.     }
  831.     /**
  832.      * {@inheritDoc}
  833.      */
  834.     public function getSteps() {
  835.         // The steps have been loaded already.
  836.         if ($this->steps !== null) {
  837.             return $this->steps;
  838.         }
  840.         if ($this->hasListeners(FormFlowEvents::GET_STEPS)) {
  841.             $event = new GetStepsEvent($this);
  842.             $this->dispatchEvent($event, FormFlowEvents::GET_STEPS);
  844.             // A listener has provided the steps for this flow.
  845.             if ($event->isPropagationStopped()) {
  846.                 $this->steps = $event->getSteps();
  848.                 return $this->steps;
  849.             }
  850.         }
  852.         // There are either no listeners on the event at all or none created the steps for this flow, so load from configuration.
  853.         $this->steps = $this->createStepsFromConfig($this->loadStepsConfig());
  855.         return $this->steps;
  856.     }
  858.     /**
  859.      * {@inheritDoc}
  860.      */
  861.     public function getStepLabels() {
  862.         if ($this->stepLabels === null) {
  863.             $stepLabels = [];
  865.             foreach ($this->getSteps() as $step) {
  866.                 $stepLabels[] = $step->getLabel();
  867.             }
  869.             $this->stepLabels = $stepLabels;
  870.         }
  872.         return $this->stepLabels;
  873.     }
  875.     /**
  876.      * {@inheritDoc}
  877.      */
  878.     public function getCurrentStepLabel() {
  879.         return $this->getStep($this->currentStepNumber)->getLabel();
  880.     }
  882.     /**
  883.      * {@inheritDoc}
  884.      */
  885.     public function isValid(FormInterface $form) {
  886.         $request = $this->getRequest();
  888.         if (in_array($request->getMethod(), ['POST', 'PUT'], true) && !in_array($this->getRequestedTransition(), [
  889.             self::TRANSITION_BACK,
  890.             self::TRANSITION_RESET,
  891.         ], true)) {
  892.             $form->handleRequest($request);
  894.             if (!$form->isSubmitted()) {
  895.                 return false;
  896.             }
  898.             if ($this->hasListeners(FormFlowEvents::POST_BIND_REQUEST)) {
  899.                 $this->dispatchEvent(new PostBindRequestEvent($this, $form->getData(), $this->currentStepNumber), FormFlowEvents::POST_BIND_REQUEST);
  900.             }
  902.             if ($this->revalidatePreviousSteps) {
  903.                 // check if forms of previous steps are still valid
  904.                 foreach ($this->stepForms as $stepNumber => $stepForm) {
  905.                     // ignore form of the current step
  906.                     if ($this->currentStepNumber === $stepNumber) {
  907.                         break;
  908.                     }
  910.                     // ignore forms of skipped steps
  911.                     if ($this->isStepSkipped($stepNumber)) {
  912.                         break;
  913.                     }
  915.                     if (!$stepForm->isValid()) {
  916.                         if ($this->hasListeners(FormFlowEvents::PREVIOUS_STEP_INVALID)) {
  917.                             $this->dispatchEvent(new PreviousStepInvalidEvent($this, $form, $stepNumber), FormFlowEvents::PREVIOUS_STEP_INVALID);
  918.                         }
  920.                         return false;
  921.                     }
  922.                 }
  923.             }
  925.             if ($form->isValid()) {
  926.                 if ($this->hasListeners(FormFlowEvents::POST_VALIDATE)) {
  927.                     $this->dispatchEvent(new PostValidateEvent($this, $form->getData()), FormFlowEvents::POST_VALIDATE);
  928.                 }
  930.                 return true;
  931.             }
  932.         }
  934.         return false;
  935.     }
  937.     /**
  938.      * @param FormInterface $submittedForm
  939.      * @return bool If a redirection should be performed.
  940.      */
  941.     public function redirectAfterSubmit(FormInterface $submittedForm) {
  942.         if ($this->allowRedirectAfterSubmit && in_array($this->getRequest()->getMethod(), ['POST', 'PUT'], true)) {
  943.             switch ($this->getRequestedTransition()) {
  944.                 case self::TRANSITION_BACK:
  945.                 case self::TRANSITION_RESET:
  946.                     return true;
  947.                 default:
  948.                     // redirect after submit only if there are no errors for the submitted form
  949.                     return $submittedForm->isSubmitted() && $submittedForm->isValid();
  950.             }
  951.         }
  953.         return false;
  954.     }
  956.     /**
  957.      * Creates the form for the given step number.
  958.      * @param int $stepNumber
  959.      * @param array $options
  960.      * @return FormInterface
  961.      */
  962.     protected function createFormForStep($stepNumber, array $options = []) {
  963.         $formType = $this->getStep($stepNumber)->getFormType();
  964.         $options = $this->getFormOptions($stepNumber, $options);
  966.         if ($formType === null) {
  967.             $formType = FormType::class;
  968.         }
  970.         return $this->formFactory->create($formType, $this->formData, $options);
  971.     }
  973.     /**
  974.      * Creates all steps from the given configuration.
  975.      * @param array $stepsConfig
  976.      * @return StepInterface[] Value with index 0 is step 1.
  977.      */
  978.     public function createStepsFromConfig(array $stepsConfig) {
  979.         $steps = [];
  981.         // fix array indexes not starting at 0
  982.         $stepsConfig = array_values($stepsConfig);
  984.         foreach ($stepsConfig as $index => $stepConfig) {
  985.             $steps[] = Step::createFromConfig($index + 1, $stepConfig);
  986.         }
  988.         return $steps;
  989.     }
  991.     /**
  992.      * Defines the configuration for all steps of this flow.
  993.      * @return array
  994.      */
  995.     protected function loadStepsConfig() {
  996.         return [];
  997.     }
  999.     protected function retrieveStepData() {
  1000.         return $this->dataManager->load($this);
  1001.     }
  1003.     protected function saveStepData(array $data) {
  1004.         $this->dataManager->save($this, $data);
  1005.     }
  1007.     /**
  1008.      * @param string $eventName
  1009.      * @return bool
  1010.      */
  1011.     protected function hasListeners($eventName) {
  1012.         return $this->eventDispatcher !== null && $this->eventDispatcher->hasListeners($eventName);
  1013.     }
  1015.     /**
  1016.      * @param FormFlowEvent $event
  1017.      * @param string $eventName
  1018.      */
  1019.     private function dispatchEvent($event, $eventName) {
  1020.         $this->eventDispatcher->dispatch($event, $eventName);
  1021.     }
  1023.     /**
  1024.      * {@inheritDoc}
  1025.      */
  1026.     public function getStepsDone() {
  1027.         $stepsDone = [];
  1029.         foreach ($this->getSteps() as $step) {
  1030.             if ($this->isStepDone($step->getNumber())) {
  1031.                 $stepsDone[] = $step;
  1032.             }
  1033.         }
  1035.         return $stepsDone;
  1036.     }
  1038.     /**
  1039.      * {@inheritDoc}
  1040.      */
  1041.     public function getStepsRemaining() {
  1042.         $stepsRemaining = [];
  1044.         foreach ($this->getSteps() as $step) {
  1045.             if (!$this->isStepDone($step->getNumber())) {
  1046.                 $stepsRemaining[] = $step;
  1047.             }
  1048.         }
  1050.         return $stepsRemaining;
  1051.     }
  1053.     /**
  1054.      * {@inheritDoc}
  1055.      */
  1056.     public function getStepsDoneCount() {
  1057.         return count($this->getStepsDone());
  1058.     }
  1060.     /**
  1061.      * {@inheritDoc}
  1062.      */
  1063.     public function getStepsRemainingCount() {
  1064.         return count($this->getStepsRemaining());
  1065.     }
  1067.     // methods for BC with third-party templates (e.g. MopaBootstrapBundle)
  1069.     public function getCurrentStep() {
  1070.         @trigger_error('Method ' . __METHOD__ . ' is deprecated since CraueFormFlowBundle 2.0. Use method getCurrentStepNumber instead.', E_USER_DEPRECATED);
  1071.         return $this->getCurrentStepNumber();
  1072.     }
  1074.     public function getCurrentStepDescription() {
  1075.         @trigger_error('Method ' . __METHOD__ . ' is deprecated since CraueFormFlowBundle 2.0. Use method getCurrentStepLabel instead.', E_USER_DEPRECATED);
  1076.         return $this->getCurrentStepLabel();
  1077.     }
  1079.     public function getMaxSteps() {
  1080.         @trigger_error('Method ' . __METHOD__ . ' is deprecated since CraueFormFlowBundle 2.0. Use method getStepCount instead.', E_USER_DEPRECATED);
  1081.         return $this->getStepCount();
  1082.     }
  1084.     public function getStepDescriptions() {
  1085.         @trigger_error('Method ' . __METHOD__ . ' is deprecated since CraueFormFlowBundle 2.0. Use method getStepLabels instead.', E_USER_DEPRECATED);
  1086.         return $this->getStepLabels();
  1087.     }
  1089.     public function getFirstStep() {
  1090.         @trigger_error('Method ' . __METHOD__ . ' is deprecated since CraueFormFlowBundle 2.0. Use method getFirstStepNumber instead.', E_USER_DEPRECATED);
  1091.         return $this->getFirstStepNumber();
  1092.     }
  1094.     public function getLastStep() {
  1095.         @trigger_error('Method ' . __METHOD__ . ' is deprecated since CraueFormFlowBundle 2.0. Use method getLastStepNumber instead.', E_USER_DEPRECATED);
  1096.         return $this->getLastStepNumber();
  1097.     }
  1099.     public function hasSkipStep($stepNumber) {
  1100.         @trigger_error('Method ' . __METHOD__ . ' is deprecated since CraueFormFlowBundle 2.0. Use method isStepSkipped instead.', E_USER_DEPRECATED);
  1101.         return $this->isStepSkipped($stepNumber);
  1102.     }
  1104. }