vendor/isotope/isotope-core/system/modules/isotope/library/Isotope/Module/Checkout.php line 602

Open in your IDE?
  1. <?php
  3. /*
  4.  * Isotope eCommerce for Contao Open Source CMS
  5.  *
  6.  * Copyright (C) 2009 - 2019 terminal42 gmbh & Isotope eCommerce Workgroup
  7.  *
  8.  * @link       https://isotopeecommerce.org
  9.  * @license    https://opensource.org/licenses/lgpl-3.0.html
  10.  */
  12. namespace Isotope\Module;
  14. use Contao\Controller;
  15. use Contao\CoreBundle\Exception\PageNotFoundException;
  16. use Contao\CoreBundle\Exception\RedirectResponseException;
  17. use Contao\CoreBundle\Exception\ResponseException;
  18. use Contao\CoreBundle\Routing\ResponseContext\HtmlHeadBag\HtmlHeadBag;
  19. use Contao\PageModel;
  20. use Contao\StringUtil;
  21. use Contao\System;
  22. use Haste\Generator\RowClass;
  23. use Haste\Input\Input;
  24. use Haste\Util\Url;
  25. use Isotope\CheckoutStep\OrderConditions;
  26. use Isotope\Interfaces\IsotopeCheckoutStep;
  27. use Isotope\Interfaces\IsotopeNotificationTokens;
  28. use Isotope\Interfaces\IsotopeProductCollection;
  29. use Isotope\Isotope;
  30. use Isotope\Model\ProductCollection\Order;
  31. use Isotope\Template;
  32. use Symfony\Component\HttpFoundation\Response;
  35. /**
  36.  * Class ModuleIsotopeCheckout
  37.  * Front end module Isotope "checkout".
  38.  *
  39.  * @property array $iso_payment_modules
  40.  * @property array $iso_shipping_modules
  41.  * @property bool  $iso_forward_review
  42.  * @property array $iso_notifications
  43.  * @property bool  $iso_addToAddressbook
  44.  * @property array $iso_checkout_skippable
  45.  * @property array $iso_order_conditions
  46.  * @property int   $orderCompleteJumpTo
  47.  */
  48. class Checkout extends Module
  49. {
  50.     const STEP_ADDRESS = 'address';
  51.     const STEP_SHIPPING = 'shipping';
  52.     const STEP_PAYMENT = 'payment';
  53.     const STEP_REVIEW = 'review';
  54.     const STEP_PROCESS = 'process';
  55.     const STEP_COMPLETE = 'complete';
  56.     const STEP_FAILED = 'failed';
  58.     /**
  59.      * Template
  60.      * @var string
  61.      */
  62.     protected $strTemplate = 'mod_iso_checkout';
  64.     /**
  65.      * Do not continue to next step
  66.      * @var boolean
  67.      */
  68.     public $doNotSubmit = false;
  70.     /**
  71.      * Disable caching of the frontend page if this module is in use.
  72.      * @var boolean
  73.      */
  74.     protected $blnDisableCache = true;
  76.     /**
  77.      * Current step
  78.      * @var string
  79.      */
  80.     protected $strCurrentStep;
  82.     /**
  83.      * Checkout steps that can be skipped
  84.      * @var array
  85.      */
  86.     protected $skippableSteps = array();
  88.     /**
  89.      * Form ID
  90.      * @var string
  91.      */
  92.     protected $strFormId = 'iso_mod_checkout';
  94.     /**
  95.      * @inheritDoc
  96.      */
  97.     protected function getSerializedProperties()
  98.     {
  99.         $props = parent::getSerializedProperties();
  101.         $props[] = 'iso_checkout_skippable';
  103.         return $props;
  104.     }
  107.     /**
  108.      * Display a wildcard in the back end
  109.      *
  110.      * @return string
  111.      */
  112.     public function generate()
  113.     {
  114.         if ('BE' === TL_MODE) {
  115.             return $this->generateWildcard();
  116.         }
  118.         $this->strCurrentStep = Input::getAutoItem('step');
  120.         if ($this->strCurrentStep == '') {
  121.             $this->redirectToNextStep();
  122.         }
  124.         return parent::generate();
  125.     }
  127.     /**
  128.      * Returns the current form ID
  129.      *
  130.      * @return string
  131.      */
  132.     public function getFormId()
  133.     {
  134.         return $this->strFormId;
  135.     }
  137.     /**
  138.      * Generate module
  139.      */
  140.     protected function compile()
  141.     {
  142.         $arrBuffer = array();
  144.         // Default template settings. Must be set at beginning so they can be overwritten later (eg. trough callback)
  145.         $this->Template->formId = $this->strFormId;
  146.         $this->Template->formSubmit = $this->strFormId;
  147.         $this->Template->enctype = 'application/x-www-form-urlencoded';
  148.         $this->Template->previousLabel = StringUtil::specialchars($GLOBALS['TL_LANG']['MSC']['previousStep']);
  149.         $this->Template->nextLabel = StringUtil::specialchars($GLOBALS['TL_LANG']['MSC']['nextStep']);
  150.         $this->Template->nextClass = 'next';
  151.         $this->Template->showPrevious = true;
  152.         $this->Template->showNext = true;
  153.         $this->Template->showForm = true;
  154.         $this->Template->steps = array();
  156.         // These steps are handled internally by the checkout module and are not in the config array
  157.         switch ($this->strCurrentStep) {
  159.             // Complete order after successful payment
  160.             // At this stage, we do no longer use the client's cart but the order through UID in URL
  161.             case self::STEP_COMPLETE:
  162.                 /** @var Order $objOrder */
  163.                 if (($objOrder = Order::findOneBy('uniqid', (string) Input::get('uid'))) === null) {
  164.                     if (Isotope::getCart()->isEmpty()) {
  165.                         throw new PageNotFoundException();
  166.                     }
  168.                     static::redirectToStep(self::STEP_FAILED);
  169.                 }
  171.                 // Order already completed (see #1441)
  172.                 if ($objOrder->checkout_complete) {
  173.                     Controller::redirect(Url::addQueryString('uid=' . $objOrder->uniqid, $this->orderCompleteJumpTo));
  174.                 }
  176.                 $strBuffer = $objOrder->hasPayment() ? $objOrder->getPaymentMethod()->processPayment($objOrder, $this) : true;
  178.                 // true means the payment is successful and order should be completed
  179.                 if ($strBuffer === true) {
  180.                     // If checkout is successful, complete order and redirect to confirmation page
  181.                     if ($objOrder->checkout() && $objOrder->complete()) {
  182.                         Controller::redirect(
  183.                             Url::addQueryString('uid=' . $objOrder->uniqid, $this->orderCompleteJumpTo)
  184.                         );
  185.                     }
  187.                     // Checkout failed, show error message
  188.                     static::redirectToStep(self::STEP_FAILED);
  189.                 }
  191.                 // False means payment has failed
  192.                 elseif ($strBuffer === false) {
  193.                     static::redirectToStep(self::STEP_FAILED);
  194.                 }
  196.                 // Otherwise we assume a string that shows a message to customer
  197.                 else {
  198.                     $this->Template->showNext     = false;
  199.                     $this->Template->showPrevious = false;
  200.                     $arrBuffer                    = array(array('html' => $strBuffer, 'class' => $this->strCurrentStep));
  201.                 }
  202.                 break;
  204.             // Process order and initiate payment method if necessary
  205.             case self::STEP_PROCESS:
  207.                 // canCheckout will override the template and show a message
  208.                 if (!$this->canCheckout()) {
  209.                     return;
  210.                 }
  212.                 $arrSteps = $this->getSteps();
  214.                 // Make sure all steps have passed successfully
  215.                 foreach ($arrSteps as $step => $arrModules) {
  216.                     /** @var IsotopeCheckoutStep $objModule */
  217.                     foreach ($arrModules as $objModule) {
  218.                         $objModule->generate();
  220.                         if ($objModule->hasError()) {
  221.                             static::redirectToStep($step);
  222.                         }
  223.                     }
  224.                 }
  226.                 $objOrder = Isotope::getCart()->getDraftOrder();
  227.                 $objOrder->checkout_info        = $this->getCheckoutInfo($arrSteps);
  228.                 $objOrder->nc_notification      = $this->iso_notifications;
  229.                 $objOrder->iso_addToAddressbook = $this->iso_addToAddressbook;
  230.                 $objOrder->iso_checkout_skippable = $this->iso_checkout_skippable;
  231.                 $objOrder->orderdetails_page = $this->orderCompleteJumpTo;
  232.                 $objOrder->email_data           = $this->getNotificationTokensFromSteps($arrSteps, $objOrder);
  234.                 // !HOOK: pre-process checkout
  235.                 if (isset($GLOBALS['ISO_HOOKS']['preCheckout']) && \is_array($GLOBALS['ISO_HOOKS']['preCheckout'])) {
  236.                     foreach ($GLOBALS['ISO_HOOKS']['preCheckout'] as $callback) {
  238.                         if (System::importStatic($callback[0])->{$callback[1]}($objOrder, $this) === false) {
  239.                             System::log('Callback ' . $callback[0] . '::' . $callback[1] . '() cancelled checkout for Order ID ' . $this->id, __METHOD__, TL_ERROR);
  241.                             static::redirectToStep(self::STEP_FAILED);
  242.                         }
  243.                     }
  244.                 }
  246.                 $objOrder->lock();
  248.                 $strBuffer = $objOrder->hasPayment() ? $objOrder->getPaymentMethod()->checkoutForm($objOrder, $this) : false;
  250.                 if ($strBuffer instanceof Response) {
  251.                     throw new ResponseException($strBuffer);
  252.                 }
  254.                 if (false === $strBuffer) {
  255.                     static::redirectToStep(self::STEP_COMPLETE, $objOrder);
  256.                 }
  258.                 $this->Template->showForm = false;
  259.                 $this->doNotSubmit        = true;
  260.                 $arrBuffer                = array(array('html' => $strBuffer, 'class' => $this->strCurrentStep));
  261.                 break;
  263.             // Checkout/payment has failed, show the review page again with an error message
  264.             /** @noinspection PhpMissingBreakStatementInspection */
  265.             case self::STEP_FAILED:
  266.                 $this->Template->mtype   = 'error';
  267.                 $this->Template->message = \strlen(Input::get('reason')) ? Input::get('reason') : $GLOBALS['TL_LANG']['ERR']['orderFailed'];
  268.                 $this->strCurrentStep    = 'review';
  269.                 // no break
  271.             default:
  273.                 // canCheckout will override the template and show a message
  274.                 if (!$this->canCheckout()) {
  275.                     return;
  276.                 }
  278.                 $arrBuffer = $this->generateSteps($this->getSteps());
  279.                 break;
  280.         }
  282.         RowClass::withKey('class')->addFirstLast()->applyTo($arrBuffer);
  284.         $this->Template->fields = $arrBuffer;
  285.     }
  287.     /**
  288.      * Run through all steps until we find the current one or one reports failure
  289.      *
  290.      * @param array $arrSteps
  291.      *
  292.      * @return array
  293.      */
  294.     protected function generateSteps(array $arrSteps)
  295.     {
  296.         $arrBuffer = array();
  297.         $intCurrentStep = 0;
  298.         $intTotalSteps  = \count($arrSteps);
  300.         if (!isset($arrSteps[$this->strCurrentStep])) {
  301.             $this->redirectToNextStep();
  302.         }
  304.         $arrStepKeys = array_keys($arrSteps);
  305.         $this->skippableSteps = array();
  307.         /**
  308.          * Run trough all steps until we find the current one or one reports failure
  309.          * @var string                $step
  310.          * @var IsotopeCheckoutStep[] $arrModules
  311.          */
  312.         foreach ($arrSteps as $step => $arrModules) {
  313.             $this->strFormId            = 'iso_mod_checkout_' . $step;
  314.             $this->Template->formId     = $this->strFormId;
  315.             $this->Template->formSubmit = $this->strFormId;
  317.             ++$intCurrentStep;
  319.             $arrBuffer                   = array();
  320.             $this->skippableSteps[$step] = true;
  322.             foreach ($arrModules as $objModule) {
  323.                 $arrBuffer[] = array(
  324.                     'class' => StringUtil::standardize($step) . ' ' . $objModule->getStepClass(),
  325.                     'html'  => $objModule->generate()
  326.                 );
  328.                 if (!$objModule->isSkippable()) {
  329.                     $this->skippableSteps[$step] = false;
  330.                 }
  332.                 if ($objModule->hasError()) {
  333.                     $this->doNotSubmit = true;
  334.                     $this->skippableSteps[$step]  = false;
  335.                 }
  337.                 // the user wanted to proceed but the current step is not completed yet
  338.                 if ($this->doNotSubmit && $step != $this->strCurrentStep) {
  339.                     static::redirectToStep($step);
  340.                 }
  341.             }
  343.             if ($this->skippableSteps[$step] ?? false) {
  344.                 unset($arrStepKeys[array_search($step, $arrStepKeys)]);
  345.                 $intCurrentStep -= 1;
  346.                 $intTotalSteps -= 1;
  347.             }
  349.             if ($step == $this->strCurrentStep) {
  350.                 if ($this->skippableSteps[$step] ?? false) {
  351.                     $this->redirectToNextStep();
  352.                 }
  354.                 global $objPage;
  355.                 $pageTitle = sprintf($GLOBALS['TL_LANG']['MSC']['checkoutStep'], $intCurrentStep, $intTotalSteps, ($GLOBALS['TL_LANG']['MSC']['checkout_' . $step] ?: $step)) . ($objPage->pageTitle ?: $objPage->title);
  357.                 // Support response context in Contao 4.13
  358.                 if (System::getContainer()->has('contao.routing.response_context_accessor')) {
  359.                     $responseContext = System::getContainer()->get('contao.routing.response_context_accessor')->getResponseContext();
  360.                     $htmlDecoder = System::getContainer()->get('contao.string.html_decoder');
  362.                     if ($responseContext && $htmlDecoder && $responseContext->has(HtmlHeadBag::class)) {
  363.                         $responseContext
  364.                             ->get(HtmlHeadBag::class)
  365.                             ->setTitle($htmlDecoder->inputEncodedToPlainText($pageTitle))
  366.                         ;
  367.                         break;
  368.                     }
  369.                 }
  371.                 $objPage->pageTitle = $pageTitle;
  372.                 break;
  373.             }
  374.         }
  376.         $arrStepKeys = array_values($arrStepKeys);
  378.         $this->Template->steps      = $this->generateStepNavigation($arrStepKeys);
  379.         $this->Template->activeStep = $GLOBALS['TL_LANG']['MSC']['activeStep'];
  381.         // Hide back buttons it this is the first step
  382.         if (array_search($this->strCurrentStep, $arrStepKeys) === 0) {
  383.             $this->Template->showPrevious = false;
  384.         }
  386.         // Show "confirm order" button if this is the last step
  387.         if (array_search($this->strCurrentStep, $arrStepKeys) === (\count($arrStepKeys) - 1)) {
  388.             $this->Template->nextClass = 'confirm';
  389.             $this->Template->nextLabel = StringUtil::specialchars($GLOBALS['TL_LANG']['MSC']['confirmOrder']);
  390.         }
  392.         // User pressed "back" button
  393.         if (\strlen(Input::post('previousStep'))) {
  394.             $this->redirectToPreviousStep();
  395.         } // Valid input data, redirect to next step
  396.         elseif (Input::post('FORM_SUBMIT') == $this->strFormId && !$this->doNotSubmit) {
  397.             $this->redirectToNextStep();
  398.         }
  400.         return $arrBuffer;
  401.     }
  403.     /**
  404.      * Redirect visitor to the next step in ISO_CHECKOUTSTEP
  405.      */
  406.     protected function redirectToNextStep()
  407.     {
  408.         $arrSteps = array_keys($this->getSteps());
  409.         $intKey   = array_search($this->strCurrentStep, $arrSteps);
  411.         if (false === $intKey) {
  412.             if ($this->iso_forward_review) {
  413.                 static::redirectToStep('review');
  414.             }
  416.             $intKey = -1;
  417.         } // redirect to step "process" if the next step is the last one
  418.         elseif (($intKey + 1) == \count($arrSteps)) {
  419.             static::redirectToStep(self::STEP_PROCESS);
  420.         }
  422.         $step = $arrSteps[$intKey + 1];
  424.         if ($this->skippableSteps[$step] ?? false) {
  425.             $this->strCurrentStep = $step;
  426.             $this->redirectToNextStep();
  427.         }
  429.         static::redirectToStep($step);
  430.     }
  432.     /**
  433.      * Redirect visitor to the previous step in ISO_CHECKOUTSTEP
  434.      */
  435.     protected function redirectToPreviousStep()
  436.     {
  437.         $arrSteps = array_keys($this->getSteps());
  438.         $intKey   = array_search($this->strCurrentStep, $arrSteps);
  440.         if (false === $intKey || 0 === $intKey) {
  441.             $intKey = 1;
  442.         }
  444.         $step = $arrSteps[$intKey - 1];
  446.         if ($this->skippableSteps[$step] ?? false) {
  447.             $this->strCurrentStep = $step;
  448.             $this->redirectToPreviousStep();
  449.         }
  451.         static::redirectToStep($step);
  452.     }
  454.     /**
  455.      * Return the checkout information as array
  456.      *
  457.      * @param array $arrSteps
  458.      *
  459.      * @return array
  460.      */
  461.     public function getCheckoutInfo(array $arrSteps = null)
  462.     {
  463.         if (null === $arrSteps) {
  464.             $arrSteps = $this->getSteps();
  465.         }
  467.         $arrCheckoutInfo = array();
  469.         // Run trough all steps to collect checkout information
  470.         /** @var IsotopeCheckoutStep[] $arrModules */
  471.         foreach ($arrSteps as $arrModules) {
  472.             foreach ($arrModules as $objModule) {
  474.                 $arrInfo = $objModule->review();
  476.                 if (!empty($arrInfo) && \is_array($arrInfo)) {
  477.                     /** @noinspection AdditionOperationOnArraysInspection */
  478.                     $arrCheckoutInfo += $arrInfo;
  479.                 }
  480.             }
  481.         }
  483.         RowClass::withKey('class')->addFirstLast()->applyTo($arrCheckoutInfo);
  485.         return $arrCheckoutInfo;
  486.     }
  488.     /**
  489.      * Retrieve the array of notification data for parsing simple tokens
  490.      *
  491.      * @param array                    $arrSteps
  492.      * @param IsotopeProductCollection $objOrder
  493.      *
  494.      * @return array
  495.      */
  496.     protected function getNotificationTokensFromSteps(array $arrSteps, IsotopeProductCollection $objOrder)
  497.     {
  498.         $arrTokens = array();
  500.         // Run through all steps to collect checkout information
  501.         foreach ($arrSteps as $arrModules) {
  503.             /** @var IsotopeCheckoutStep $objModule */
  504.             foreach ($arrModules as $objModule) {
  505.                 // Method check is BC for when IsotopeCheckoutStep contained "getNotificationTokens" method
  506.                 if ($objModule instanceof IsotopeNotificationTokens || \method_exists($objModule, 'getNotificationTokens')) {
  507.                     $arrTokens = array_merge($arrTokens, $objModule->getNotificationTokens($objOrder));
  508.                 }
  509.             }
  510.         }
  512.         return $arrTokens;
  513.     }
  515.     /**
  516.      * Check if the checkout can be executed
  517.      *
  518.      * @return bool
  519.      */
  520.     protected function canCheckout()
  521.     {
  522.         // Redirect to login page if not logged in
  523.         if ('member' === $this->iso_checkout_method && true !== FE_USER_LOGGED_IN) {
  525.             /** @var PageModel $objJump */
  526.             $objJump = PageModel::findPublishedById($this->iso_login_jumpTo);
  528.             if (null === $objJump) {
  529.                 $this->Template          = new Template('mod_message');
  530.                 $this->Template->type    = 'error';
  531.                 $this->Template->message = $GLOBALS['TL_LANG']['ERR']['isoLoginRequired'];
  533.                 return false;
  534.             }
  536.             $objJump->loadDetails();
  537.             Controller::redirect($objJump->getFrontendUrl(null, $objJump->language));
  539.         } elseif ('guest' === $this->iso_checkout_method && true === FE_USER_LOGGED_IN) {
  540.             $this->Template          = new Template('mod_message');
  541.             $this->Template->type    = 'error';
  542.             $this->Template->message = $GLOBALS['TL_LANG']['ERR']['checkoutNotAllowed'];
  544.             return false;
  545.         }
  547.         // Return error message if cart is empty
  548.         if (Isotope::getCart()->isEmpty()) {
  549.             $this->Template          = new Template('mod_message');
  550.             $this->Template->type    = 'empty';
  551.             $this->Template->message = $GLOBALS['TL_LANG']['MSC']['noItemsInCart'];
  553.             return false;
  554.         }
  556.         // Insufficient cart subtotal
  557.         if (Isotope::getCart()->hasErrors()) {
  558.             if ($this->iso_cart_jumpTo > 0) {
  560.                 /** @var PageModel $objJump */
  561.                 $objJump = PageModel::findPublishedById($this->iso_cart_jumpTo);
  563.                 if (null !== $objJump) {
  564.                     $objJump->loadDetails();
  565.                     Controller::redirect($objJump->getFrontendUrl(null, $objJump->language));
  566.                 }
  567.             }
  569.             $this->Template          = new Template('mod_message');
  570.             $this->Template->type    = 'error';
  571.             $this->Template->message = implode("</p>\n<p class=\"error message\">", Isotope::getCart()->getErrors());
  573.             return false;
  574.         }
  576.         return true;
  577.     }
  579.     /**
  580.      * Returns whether the checkout step by given name can be skipped.
  581.      *
  582.      * @param string $step
  583.      *
  584.      * @return bool
  585.      */
  586.     public function canSkipStep($step)
  587.     {
  588.         return \in_array($step, $this->iso_checkout_skippable, true);
  589.     }
  591.     /**
  592.      * Return array of instantiated checkout step modules
  593.      *
  594.      * @return array
  595.      */
  596.     protected function getSteps()
  597.     {
  598.         $arrOrderConditions = [];
  599.         $arrSteps = [];
  601.         $productTypeIds = [];
  602.         foreach (Isotope::getCart()->getItems() as $objItem) {
  603.             if ($objItem->hasProduct()) {
  604.                 $productType = $objItem->getProduct()->getType();
  605.                 $productTypeIds[] = null === $productType ? 0 : (int) $productType->id;
  606.             }
  607.         }
  608.         $productTypeIds = array_unique($productTypeIds);
  610.         foreach (StringUtil::deserialize($this->iso_order_conditions, true) as $config) {
  611.             if (empty($config['form'])) {
  612.                 continue;
  613.             }
  615.             $configProductTypes = StringUtil::deserialize($config['product_types']);
  617.             if (!empty($configProductTypes) && \is_array($configProductTypes)) {
  618.                 switch ($config['product_types_condition']) {
  619.                     case 'onlyAvailable':
  620.                         if (\count(array_diff($productTypeIds, $configProductTypes)) > 0) {
  621.                             continue(2);
  622.                         }
  623.                         break;
  625.                     case 'oneAvailable':
  626.                         if (\count(array_intersect($configProductTypes, $productTypeIds)) === 0) {
  627.                             continue(2);
  628.                         }
  629.                         break;
  631.                     case 'allAvailable':
  632.                         if (\count(array_intersect($configProductTypes, $productTypeIds)) !== \count($configProductTypes)) {
  633.                             continue(2);
  634.                         }
  635.                         break;
  636.                 }
  637.             }
  639.             $arrOrderConditions[$config['step']][$config['position']][] = $config['form'];
  640.         }
  642.         foreach ($GLOBALS['ISO_CHECKOUTSTEP'] as $strStep => $arrModules) {
  643.             foreach ($arrModules as $strClass) {
  644.                 $objModule = new $strClass($this);
  646.                 if (!$objModule instanceof IsotopeCheckoutStep) {
  647.                     throw new \RuntimeException("$strClass has to implement Isotope\\Interfaces\\IsotopeCheckoutStep");
  648.                 }
  650.                 if (isset($arrOrderConditions[$strClass]['before'])) {
  651.                     foreach ($arrOrderConditions[$strClass]['before'] as $form) {
  652.                         $arrSteps[$strStep][] = new OrderConditions($this, $form);
  653.                     }
  654.                 }
  656.                 if ($objModule->isAvailable()) {
  657.                     $arrSteps[$strStep][] = $objModule;
  658.                 }
  660.                 if (isset($arrOrderConditions[$strClass]['after'])) {
  661.                     foreach ($arrOrderConditions[$strClass]['after'] as $form) {
  662.                         $arrSteps[$strStep][] = new OrderConditions($this, $form);
  663.                     }
  664.                 }
  665.             }
  666.         }
  668.         return $arrSteps;
  669.     }
  671.     /**
  672.      * Generate checkout step navigation
  673.      *
  674.      * @param array $arrStepKeys
  675.      *
  676.      * @return array
  677.      */
  678.     protected function generateStepNavigation(array $arrStepKeys)
  679.     {
  680.         $arrItems  = array();
  681.         $blnPassed = true;
  683.         foreach ($arrStepKeys as $step) {
  685.             $blnActive = false;
  686.             $href      = '';
  687.             $class     = StringUtil::standardize($step);
  689.             if ($this->strCurrentStep == $step) {
  690.                 $blnPassed = false;
  691.                 $blnActive = true;
  692.                 $class .= ' active';
  693.             } elseif ($blnPassed) {
  694.                 $href = static::generateUrlForStep($step);
  695.                 $class .= ' passed';
  696.             }
  698.             $arrItems[] = array
  699.             (
  700.                 'isActive' => $blnActive,
  701.                 'class'    => $class,
  702.                 'link'     => $GLOBALS['TL_LANG']['MSC']['checkout_' . $step] ? : $step,
  703.                 'href'     => $href,
  704.                 'title'    => StringUtil::specialchars(sprintf($GLOBALS['TL_LANG']['MSC']['checkboutStepBack'], ($GLOBALS['TL_LANG']['MSC']['checkout_' . $step] ? : $step))),
  705.             );
  706.         }
  708.         // Add first/last classes
  709.         RowClass::withKey('class')->addFirstLast()->applyTo($arrItems);
  711.         return $arrItems;
  712.     }
  714.     /**
  715.      * Redirect to given checkout step
  716.      *
  717.      * @param string                   $strStep
  718.      * @param IsotopeProductCollection $objCollection
  719.      */
  720.     public static function redirectToStep($strStep, IsotopeProductCollection $objCollection = null)
  721.     {
  722.         Isotope::getCart()->save();
  724.         throw new RedirectResponseException(static::generateUrlForStep($strStep, $objCollection, null, true));
  725.     }
  727.     /**
  728.      * Generate frontend URL for current page including the given checkout step
  729.      *
  730.      * @param string $strStep
  731.      *
  732.      * @return string
  733.      */
  734.     public static function generateUrlForStep($strStep, IsotopeProductCollection $objCollection = null, PageModel $objTarget = null, bool $absolute = false)
  735.     {
  736.         if (null === $objTarget) {
  737.             global $objPage;
  738.             $objTarget = $objPage;
  739.         }
  741.         if (!$GLOBALS['TL_CONFIG']['useAutoItem'] || !\in_array('step', $GLOBALS['TL_AUTO_ITEM'], true)) {
  742.             $strStep = 'step/' . $strStep;
  743.         }
  745.         $strUrl = $absolute ? $objTarget->getAbsoluteUrl('/' . $strStep) : $objTarget->getFrontendUrl('/' . $strStep);
  747.         if (null !== $objCollection) {
  748.             $strUrl = Url::addQueryString('uid=' . $objCollection->getUniqueId(), $strUrl);
  749.         }
  751.         return $strUrl;
  752.     }
  753. }