Processes the input, e.g. store given order.
A view must be available and this method doesn't generate any output
besides setting view variables.
180123
public function process()
	{
		$view = $this->getView();
		$context = $this->getContext();

		if( $view->param( 'c_step' ) !== 'process'
			|| $view->get( 'standardErrorList', [] ) !== []
			|| $view->get( 'standardStepActive' ) !== null
		) {
			return;
		}

		try
		{
			$orderCntl = \Aimeos\Controller\Frontend::create( $context, 'order' );
			$basketCntl = \Aimeos\Controller\Frontend::create( $context, 'basket' );


			if ( $view->param( 'cs_order', null ) !== null )
			{
				parent::process();

				$basket = $basketCntl->store();
				$orderItem = $orderCntl->add( $basket->getId(), ['order.type' => 'web'] )->store();

				$context->getSession()->set( 'aimeos/orderid', $orderItem->getId() );
			}
			elseif ( $view->param( 'cp_payment', null ) !== null )
			{
				$parts = \Aimeos\MShop\Order\Item\Base\Base::PARTS_ALL;
				$orderItem = $orderCntl->get( $context->getSession()->get( 'aimeos/orderid' ), false );
				$basket = $basketCntl->load( $orderItem->getBaseId(), $parts, false );
			}
			else
			{
				return;
			}

			$total = $basket->getPrice()->getValue() + $basket->getPrice()->getCosts();
			$services = $basket->getService( \Aimeos\MShop\Order\Item\Base\Service\Base::TYPE_PAYMENT );

			if( $services === [] || $total <= 0 && $this->isSubscription( $basket->getProducts() ) === false )
			{
				$orderCntl->save( $orderItem->setPaymentStatus( \Aimeos\MShop\Order\Item\Base::PAY_AUTHORIZED ) );
			}
			elseif( ( $form = $this->processPayment( $basket, $orderItem ) ) !== null )
			{
				$view->standardUrlNext = $form->getUrl();
				$view->standardMethod = $form->getMethod();
				$view->standardProcessParams = $form->getValues();
				$view->standardUrlExternal = $form->getExternal();
				$view->standardHtml = $form->getHtml();

				return;
			}

			$view->standardUrlNext = $this->getUrlConfirm( $view, [], [] );
			$view->standardMethod = 'POST';
		}
		catch( \Aimeos\Client\Html\Exception $e )
		{
			$error = array( $context->getI18n()->dt( 'client', $e->getMessage() ) );
			$view->standardErrorList = $view->get( 'standardErrorList', [] ) + $error;
		}
		catch( \Aimeos\Controller\Frontend\Exception $e )
		{
			$error = array( $context->getI18n()->dt( 'controller/frontend', $e->getMessage() ) );
			$view->standardErrorList = $view->get( 'standardErrorList', [] ) + $error;
		}
		catch( \Aimeos\MShop\Exception $e )
		{
			$error = array( $context->getI18n()->dt( 'mshop', $e->getMessage() ) );
			$view->standardErrorList = $view->get( 'standardErrorList', [] ) + $error;
		}
		catch( \Exception $e )
		{
			$error = array( $context->getI18n()->dt( 'client', 'A non-recoverable error occured' ) );
			$view->standardErrorList = $view->get( 'standardErrorList', [] ) + $error;
			$this->logException( $e );
		}
	}
1157825
public function process()
	{
		$view = $this->getView();
		$context = $this->_getContext();
		$ids = $view->param( 'watch-id', array() );

		if( $context->getUserId() != null && !empty( $ids ) )
		{
			$typeItem = $this->_getTypeItem();
			$manager = MShop_Factory::createManager( $context, 'customer/list' );

			$search = $manager->createSearch();
			$expr = array(
				$search->compare( '==', 'customer.list.parentid', $context->getUserId() ),
				$search->compare( '==', 'customer.list.refid', $ids ),
				$search->compare( '==', 'customer.list.domain', 'product' ),
				$search->compare( '==', 'customer.list.typeid', $typeItem->getId() ),
			);
			$search->setConditions( $search->combine( '&&', $expr ) );

			$items = array();
			foreach( $manager->searchItems( $search ) as $item ) {
				$items[ $item->getRefId() ] = $item;
			}


			switch( $view->param( 'watch-action' ) )
			{
				case 'add':

					$search = $manager->createSearch();
					$expr = array(
						$search->compare( '==', 'customer.list.parentid', $context->getUserId() ),
						$search->compare( '==', 'customer.list.typeid', $typeItem->getId() ),
						$search->compare( '==', 'customer.list.domain', 'product' ),
					);
					$search->setConditions( $search->combine( '&&', $expr ) );
					$search->setSlice( 0, 0 );

					$total = 0;
					$manager->searchItems( $search, array(), $total );

					/** client/html/account/watch/default/maxitems
					 * Maximum number of products that can be watched in parallel
					 *
					 * This option limits the number of products that can be watched
					 * after the users added the products to their watch list.
					 * It must be a positive integer value greater than 0.
					 *
					 * Note: It's recommended to set this value not too high as this
					 * leads to a high memory consumption when the e-mails are generated
					 * to notify the customers. The memory used will up to 100*maxitems
					 * of the footprint of one product item including the associated
					 * texts, prices and media.
					 *
					 * @param integer Number of products
					 * @since 2014.09
					 * @category User
					 * @category Developer
					 */
					$max = $context->getConfig()->get( 'client/html/account/watch/default/maxitems', 100 );

					$item = $manager->createItem();
					$item->setParentId( $context->getUserId() );
					$item->setTypeId( $typeItem->getId() );
					$item->setDomain( 'product' );
					$item->setStatus( 1 );

					foreach( (array) $view->param( 'watch-id', array() ) as $id )
					{
						if( $total >= $max )
						{
							$error = array( sprintf( $context->getI18n()->dt( 'client/html', 'You can only watch up to %1$s products' ), $max ) );
							$view->watchErrorList = $view->get( 'watchErrorList', array() ) + $error;
							break;
						}

						if( !isset( $items[$id] ) )
						{
							$item->setId( null );
							$item->setRefId( $id );

							$manager->saveItem( $item );
							$manager->moveItem( $item->getId() );

							$total++;
						}
					}

					break;

				case 'edit':

					foreach( (array) $view->param( 'watch-id', array() ) as $id )
					{
						if( isset( $items[$id] ) )
						{
							$item = $items[$id];

							$config = array(
								'timeframe' => $view->param( 'watch-timeframe', 7 ),
								'price-value' => $view->param( 'watch-price-value', '0.00' ),
								'price' => $view->param( 'watch-price', 0 ),
								'stock' => $view->param( 'watch-stock', 0 ),
							);
							$time = time() + ( $config['timeframe'] + 1 ) * 86400;

							$item->setDateEnd( date( 'Y-m-d 00:00:00', $time ) );
							$item->setConfig( $config );

							$manager->saveItem( $item );
						}
					}

					break;

				case 'delete':

					$listIds = array();

					foreach( (array) $view->param( 'watch-id', array() ) as $id )
					{
						if( isset( $items[$id] ) ) {
							$listIds[] = $items[$id]->getId();
						}
					}

					$manager->deleteItems( $listIds );
					break;
			}
		}

		parent::process();
	}
891317
public function process()
	{
		$view = $this->getView();
		$context = $this->getContext();
		$controller = \Aimeos\Controller\Frontend::create( $context, 'basket' );

		try
		{
			switch( $view->param( 'b_action' ) )
			{
				case 'add':
					$this->addProducts( $view );
					break;
				case 'coupon-delete':
					$this->deleteCoupon( $view );
					break;
				case 'delete':
					$this->deleteProducts( $view );
					break;
				default:
					$this->updateProducts( $view );
					$this->addCoupon( $view );
			}

			parent::process();

			/** client/html/basket/standard/check
			 * Alters the behavior of the product checks before continuing with the checkout
			 *
			 * By default, the product related checks are performed every time the basket
			 * is shown. They test if there are any products in the basket and execute all
			 * basket plugins that have been registered for the "check.before" and "check.after"
			 * events.
			 *
			 * Using this configuration setting, you can either disable all checks completely
			 * (0) or display a "Check" button instead of the "Checkout" button (2). In the
			 * later case, customers have to click on the "Check" button first to perform
			 * the checks and if everything is OK, the "Checkout" button will be displayed
			 * that allows the customers to continue the checkout process. If one of the
			 * checks fails, the customers have to fix the related basket item and must click
			 * on the "Check" button again before they can continue.
			 *
			 * Available values are:
			 *  0 = no product related checks
			 *  1 = checks are performed every time when the basket is displayed
			 *  2 = checks are performed only when clicking on the "check" button
			 *
			 * @param integer One of the allowed values (0, 1 or 2)
			 * @since 2016.08
			 * @category Developer
			 * @category User
			 */
			$check = (int) $view->config( 'client/html/basket/standard/check', 1 );

			switch( $check )
			{
				case 2:
					if( $view->param( 'b_check', 0 ) == 0 ) { break; }
				case 1:
					$controller->get()->check( \Aimeos\MShop\Order\Item\Base\Base::PARTS_PRODUCT );
				default:
					$view->standardCheckout = true;
			}
		}
		catch( \Aimeos\Controller\Frontend\Exception $e )
		{
			$error = array( $context->getI18n()->dt( 'controller/frontend', $e->getMessage() ) );
			$view->standardErrorList = $view->get( 'standardErrorList', [] ) + $error;
		}
		catch( \Aimeos\MShop\Plugin\Provider\Exception $e )
		{
			$errors = array( $context->getI18n()->dt( 'mshop', $e->getMessage() ) );
			$errors = array_merge( $errors, $this->translatePluginErrorCodes( $e->getErrorCodes() ) );

			$view->standardErrorCodes = $e->getErrorCodes();
			$view->standardErrorList = $view->get( 'standardErrorList', [] ) + $errors;
		}
		catch( \Aimeos\MShop\Exception $e )
		{
			$error = array( $context->getI18n()->dt( 'mshop', $e->getMessage() ) );
			$view->standardErrorList = $view->get( 'standardErrorList', [] ) + $error;
		}
		catch( \Exception $e )
		{
			$error = array( $context->getI18n()->dt( 'client', 'A non-recoverable error occured' ) );
			$view->standardErrorList = $view->get( 'standardErrorList', [] ) + $error;
			$this->logException( $e );
		}

		// store updated basket after plugins updated content and have thrown an exception
		$controller->save();
	}
87939
public function process(){
    if ( $this->check() ){
      $this->obj = new \stdClass();
      if ( !\is_array($this->info)){
        $this->log("No info in MVC", $this->info);
        die("No info in MVC");
      }
      if ( !$this->controller ){
        $this->controller = new mvc\controller($this, $this->info, $this->data, $this->obj);
      }
      $this->controller->process();
    }
	}
1059239
protected function process()
    {

        // prepare the store view code
        $this->prepareStoreViewCode($this->getRow());

        // return immediately if we're have no store view code set
        if (StoreViewCodes::ADMIN !== $this->getStoreViewCode(StoreViewCodes::ADMIN)) {
            return;
        }

        // query whether or not the option has already been created
        if (!$this->exists($name = $this->getValue(ColumnKeys::BUNDLE_VALUE_NAME))) {
            // load the bundle option
            $bundleOption = $this->initializeBundleOption($this->prepareAttributes());

            // persist the product bundle option
            $optionId = $this->persistProductBundleOption($bundleOption);

            // store the name => option ID mapping
            $this->addNameOptionIdMapping($name, $optionId);
        }
    }
962569
protected function process()
    {

        // initialize the store view code
        $this->getSubject()->prepareStoreViewCode();

        // load the PK
        $pk = $this->getValue($this->getPrimaryKeyColumnName());

        // load the store view - if no store view has been set, we assume the admin
        // store view, which will contain the default (fallback) attribute values
        $storeViewCode = $this->getSubject()->getStoreViewCode(StoreViewCodes::ADMIN);

        // query whether or not the row has already been processed
        if ($this->storeViewHasBeenProcessed($pk, $storeViewCode)) {
            // log a message
            $this->getSystemLogger()->warning(
                $this->getSubject()->appendExceptionSuffix(
                    sprintf(
                        'Attributes for %s "%s" + store view code "%s" has already been processed',
                        $this->getPrimaryKeyColumnName(),
                        $pk,
                        $storeViewCode
                    )
                )
            );

            // return immediately
            return;
        }

        // load the store ID, use the admin store if NO store view code has been set
        $storeId = $this->getSubject()->getRowStoreId(StoreViewCodes::ADMIN);

        // load the image attribute
        $attribute = $this->getEavAttributeByAttributeCode('image');

        // remove the image if one exists
        if ($value = $this->loadVarcharAttribute($pk, $attribute[MemberNames::ATTRIBUTE_ID], $storeId)) {
            $this->deleteVarcharAttribute(array(MemberNames::VALUE_ID => $value[MemberNames::VALUE_ID]));
        }
    }
1241163
protected function process()
    {

        // initialize the URL key and array for the categories
        $urlKey = null;
        $categories = array();

        // query whether or not the URL key column has a value
        if ($this->hasValue(ColumnKeys::URL_KEY)) {
            $urlKey = $this->getValue(ColumnKeys::URL_KEY);
        } else {
            $this->setValue(
                ColumnKeys::URL_KEY,
                $urlKey = $this->convertNameToUrlKey($this->getValue(ColumnKeys::NAME))
            );
        }

        // explode the path into the category names
        if ($categories = $this->explode($this->getValue(ColumnKeys::PATH), '/')) {
            // initialize the category with the actual category's URL key
            $categoryPaths = array($urlKey);
            // prepare the store view code
            $this->prepareStoreViewCode();
            // load ID of the actual store view
            $storeId = $this->getRowStoreId(StoreViewCodes::ADMIN);

            // iterate over the category names and try to load the category therefore
            for ($i = sizeof($categories) - 1; $i > 1; $i--) {
                try {
                    // prepare the expected category name
                    $categoryPath = implode('/', array_slice($categories, 0, $i));
                    // load the existing category and prepend the URL key the array with the category URL keys
                    $existingCategory = $this->getCategoryByPkAndStoreId($this->mapPath($categoryPath), $storeId);
                    // query whether or not an URL key is available or not
                    if (isset($existingCategory[MemberNames::URL_KEY])) {
                        array_unshift($categoryPaths, $existingCategory[MemberNames::URL_KEY]);
                    } else {
                        $this->getSystemLogger()->debug(sprintf('Can\'t find URL key for category %s', $categoryPath));
                    }
                } catch (\Exception $e) {
                    $this->getSystemLogger()->debug(sprintf('Can\'t load parent category %s', $categoryPath));
                }
            }

            // create the header for the URL path
            if (!$this->hasHeader(ColumnKeys::URL_PATH)) {
                $this->addHeader(ColumnKeys::URL_PATH);
            }

            // set the URL path
            $this->setValue(ColumnKeys::URL_PATH, implode('/', $categoryPaths));
        }
    }
1280137
public function process()
    {
        parent::process();

        foreach ($this->columns as $column) {
            $column->process();
        }

        foreach ($this->spanning_columns as $column) {
            $column->process();
        }

        foreach ($this->extra_rows as $row) {
            $row->process();
        }

        // this is part of the old selection API
        if ($this->hasColumn('checkbox')) {
            $items = $this->getColumn('checkbox');
            $this->checked_items = $items->getItems();
        }
    }
536306
private void processSavedViewState() throws IOException
   {
      DirectoryEntry dir = (DirectoryEntry) m_viewDir.getEntry("CEdl");
      VarMeta varMeta = new VarMeta12(new DocumentInputStream(((DocumentEntry) dir.getEntry("VarMeta"))));
      Var2Data varData = new Var2Data(varMeta, new DocumentInputStream(((DocumentEntry) dir.getEntry("Var2Data"))));
      //System.out.println(varMeta);
      //System.out.println(varData);

      InputStream is = new DocumentInputStream(((DocumentEntry) dir.getEntry("FixedData")));
      byte[] fixedData = new byte[is.available()];
      is.read(fixedData);
      is.close();
      //System.out.println(ByteArrayHelper.hexdump(fixedData, false, 16, ""));

      ViewStateReader reader = new ViewStateReader12();
      reader.process(m_file, varData, fixedData);
   }
903612
protected function process()
    {

        // extract the child SKU and attribute code from the row
        $parentSku = $this->getValue(ColumnKeys::VARIANT_PARENT_SKU);
        $attributeCode = $this->getValue(ColumnKeys::VARIANT_ATTRIBUTE_CODE);

        // query whether or not the super attribute has already been processed
        if ($this->hasBeenProcessedRelation($parentSku, $attributeCode, RelationTypes::VARIANT_SUPER_ATTRIBUTE)) {
            return;
        }

        // prepare the store view code
        $this->prepareStoreViewCode($this->getRow());

        // preserve the parent ID
        $this->setParentId($this->mapParentSku($parentSku));

        // load the store and set the store ID
        $store = $this->getStoreByStoreCode($this->getStoreViewCode(StoreViewCodes::ADMIN));
        $this->storeId = $store[MemberNames::STORE_ID];

        try {
            // load the EAV attribute with the found attribute code
            $this->eavAttribute = $this->getEavAttributeByAttributeCode($attributeCode);
        } catch (\Exception $e) {
            throw $this->wrapException(array(ColumnKeys::VARIANT_ATTRIBUTE_CODE), $e);
        }

        try {
            // initialize and save the super attribute
            $productSuperAttribute = $this->initializeProductSuperAttribute($this->prepareProducSuperAttributeAttributes());
            $this->productSuperAttributeId = $this->persistProductSuperAttribute($productSuperAttribute);

            // initialize and save the super attribute label
            $productSuperAttributeLabel = $this->initializeProductSuperAttributeLabel($this->prepareProductSuperAttributeLabelAttributes());
            $this->persistProductSuperAttributeLabel($productSuperAttributeLabel);

            // mark the super attribute as processed
            $this->addProcessedRelation($parentSku, $attributeCode, RelationTypes::VARIANT_SUPER_ATTRIBUTE);
        } catch (\Exception $e) {
            // prepare a more detailed error message
            $message = $this->appendExceptionSuffix(
                sprintf(
                    'Super attribute for SKU %s and attribute %s can\'t be created',
                    $parentSku,
                    $attributeCode
                )
            );

            // if we're NOT in debug mode, re-throw a more detailed exception
            $wrappedException = $this->wrapException(
                array(ColumnKeys::VARIANT_PARENT_SKU, ColumnKeys::VARIANT_ATTRIBUTE_CODE),
                new \Exception($message, null, $e)
            );

            // query whether or not, debug mode is enabled
            if ($this->isDebugMode()) {
                // log a warning and return immediately
                $this->getSystemLogger()->warning($wrappedException->getMessage());
                return;
            }

            // else, throw the exception
            throw $wrappedException;
        }
    }
630194
function process() {
    global $order, $currencies;
    if ($_SESSION['cot_gv']) {
      $od_amount = $this->calculate_deductions($this->get_order_total());
      $this->deduction = $od_amount['total'];
      if ($od_amount['total'] > 0) {
        reset($order->info['tax_groups']);
        $tax = 0;
        while (list($key, $value) = each($order->info['tax_groups'])) {
          if ($od_amount['tax_groups'][$key]) {
            $order->info['tax_groups'][$key] -= $od_amount['tax_groups'][$key];
            $tax += $od_amount['tax_groups'][$key];
          }
        }
        $order->info['total'] = $order->info['total'] - $od_amount['total'];
        if ($this->calculate_tax = "Standard") $order->info['total'] -= $tax;
        if ($order->info['total'] < 0) $order->info['total'] = 0;
        $order->info['tax'] = $order->info['tax'] - $od_amount['tax'];
        // prepare order-total output for display and storing to invoice
        $this->output[] = array('title' => $this->title . ':',
        'text' => '-' . $currencies->format($od_amount['total']),
        'value' => $od_amount['total']);
      }
    }
  }
74848
protected function doProcess(): void
    {
        $module = Request::getModule();
        $controller = Request::getController();
        $params = Request::getParams();

        try {
            // try to dispatch controller
            $result = $this->dispatch($module, $controller, $params);
        } catch (ForbiddenException $e) {
            // dispatch default error controller
            $result = $this->forbidden($e);
        } catch (RedirectException $e) {
            // should return `null` for disable output and setup redirect headers
            $result = $this->redirect($e);
        } catch (\Exception $e) {
            // dispatch default error controller
            $result = $this->error($e);
        }

        // setup layout, if needed
        if ($this->useLayout()) {
            // render view to layout
            // needed for headScript and headStyle helpers
            Layout::setContent($result->render());
            Response::setBody(Layout::getInstance());
        } else {
            Response::setBody($result);
        }
    }
725221
protected function process()
    {

        // load email and website code
        $email = $this->getValue(ColumnKeys::EMAIL);
        $website = $this->getValue(ColumnKeys::WEBSITE);

        // add the customer identifier => entity ID mapping
        $this->addCustomerIdentifierEntityIdMapping($email, $website);

        // clean-up the repositories etc. to free memory
        $this->getCustomerBunchProcessor()->cleanUp();

        // temporary persist the last customer identifier
        $this->setLastIdentifier(array($email, $website));
    }
1134651
public function process()
	{
		$view = $this->getView();

		try
		{
			if( $view->param( 'cs_order', null ) === null ) {
				return;
			}


			$controller = \Aimeos\Controller\Frontend::create( $this->getContext(), 'basket' );
			$customerref = $view->param( 'cs_customerref' );
			$comment = $view->param( 'cs_comment' );

			if( $customerref || $comment )
			{
				$controller->get()->setCustomerReference( $customerref )->setComment( $comment );
				$controller->save();
			}


			// only start if there's something to do
			if( $view->param( 'cs_option_terms', null ) !== null
				&& ( $option = $view->param( 'cs_option_terms_value', 0 ) ) != 1
			) {
				$error = $view->translate( 'client', 'Please accept the terms and conditions' );
				$errors = $view->get( 'summaryErrorCodes', [] );
				$errors['option']['terms'] = $error;

				$view->summaryErrorCodes = $errors;
				$view->standardStepActive = 'summary';
				$view->standardErrorList = array( $error ) + $view->get( 'standardErrorList', [] );
			}


			parent::process();

			$controller->get()->check( \Aimeos\MShop\Order\Item\Base\Base::PARTS_ALL );
		}
		catch( \Exception $e )
		{
			$view->standardStepActive = 'summary';
			throw $e;
		}
	}
671441
public function process()
    {
        $handler = $this->getHandler();
        $response = $handler->getPayPalResponse();
        $data = $handler->getData();

        $order = $this->getOrder();
        $amount = $order->getRemainingOrderSum();
        $order->setVoidedAmount($amount);
        $order->setPaymentStatus($data->getOrderStatus());
        $order->save();

        $payment = oxNew(\OxidEsales\PayPalModule\Model\OrderPayment::class);
        $payment->setDate($this->getDate());
        $payment->setTransactionId($response->getAuthorizationId());
        $payment->setCorrelationId($response->getCorrelationId());
        $payment->setAction('void');
        $payment->setStatus('Voided');
        $payment->setAmount($amount);

        $payment = $order->getPaymentList()->addPayment($payment);

        if ($data->getComment()) {
            $comment = oxNew(\OxidEsales\PayPalModule\Model\OrderPaymentComment::class);
            $comment->setComment($data->getComment());
            $payment->addComment($comment);
        }
    }
1069620
protected function process()
    {

        // prepare the store view code
        $this->prepareStoreViewCode($this->getRow());

        // return immediately if we're have no store view code set
        if (StoreViewCodes::ADMIN !== $this->getStoreViewCode(StoreViewCodes::ADMIN)) {
            return;
        }

        // prepare, initialize and persist the product bundle selection data
        $productBundleSelection = $this->initializeBundleSelection($this->prepareAttributes());
        $selectionId = $this->persistProductBundleSelection($productBundleSelection);

        // add the mapping for the child SKU => selection ID
        $this->addChildSkuSelectionIdMapping($this->getValue(ColumnKeys::BUNDLE_VALUE_SKU), $selectionId);
    }
344162
public function process()
	{
		$view = $this->getView();
		$context = $this->getContext();
		$ids = (array) $view->param( 'fav_id', [] );

		try
		{
			if( $context->getUserId() != null && !empty( $ids ) )
			{
				switch( $view->param( 'fav_action' ) )
				{
					case 'add':
						$this->addFavorites( $ids ); break;
					case 'delete':
						$this->deleteFavorites( $ids ); break;
				}
			}

			parent::process();
		}
		catch( \Aimeos\MShop\Exception $e )
		{
			$error = array( $context->getI18n()->dt( 'mshop', $e->getMessage() ) );
			$view->favoriteErrorList = $view->get( 'favoriteErrorList', [] ) + $error;
		}
		catch( \Aimeos\Controller\Frontend\Exception $e )
		{
			$error = array( $context->getI18n()->dt( 'controller/frontend', $e->getMessage() ) );
			$view->favoriteErrorList = $view->get( 'favoriteErrorList', [] ) + $error;
		}
		catch( \Aimeos\Client\Html\Exception $e )
		{
			$error = array( $context->getI18n()->dt( 'client', $e->getMessage() ) );
			$view->favoriteErrorList = $view->get( 'favoriteErrorList', [] ) + $error;
		}
		catch( \Exception $e )
		{
			$error = array( $context->getI18n()->dt( 'client', 'A non-recoverable error occured' ) );
			$view->favoriteErrorList = $view->get( 'favoriteErrorList', [] ) + $error;
			$this->logException( $e );
		}
	}