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

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. }