<?php

/**
 * SOTESHOP/stProduct
 *
 * Ten plik należy do aplikacji stProduct opartej na licencji (Open License SOTE) Otwarta Licencja SOTE.
 * Nie zmieniaj tego pliku, jeśli chcesz korzystać z automatycznych aktualizacji oprogramowania.
 * Jeśli chcesz wprowadzać swoje modyfikacje do programu, zapoznaj się z dokumentacją, jak zmieniać
 * oprogramowanie bez zmiany kodu bazowego http://www.sote.pl/modifications
 *
 * @package     stProduct
 * @subpackage  actions
 * @copyright   SOTE (www.sote.pl)
 * @license     http://www.sote.pl/license/open (Open License SOTE) Otwarta Licencja SOTE
 * @version     $Id: actions.class.php 2594 2009-08-14 14:12:36Z krzysiek $
 */

/**
 * Akcje produktu
 *
 * @author Krzysztof Bebło <krzysztof.beblo@sote.pl>
 *
 * @package     stProduct
 * @subpackage  actions
 */
class stProductActions extends stActions
{
   public function preExecute()
   {
      if ($this->hasRequestParameter('producer'))
      {
         $this->processProducerFriendlyUrl($this->getRequestParameter('producer'));

         if ($this->producer)
         {
            stProducer::setSelectedProducerId($this->producer->getId());
         }
         else
         {
            $this->getRequest()->setParameter('producer', null);
            return $this->forward('stProduct', 'producerNotFound');
         }
      }

      parent::preExecute();
   }
   public function executeAttachmentList()
   {

      if(!$this->getRequest()->isXmlHttpRequest() && $this->getController()->getRenderMode() != sfView::RENDER_VAR){  

        $this->getResponse()->setStatusCode(404);

        $this->getResponse()->setHttpHeader('Status', '404 Not Found');

        return $this->forward('stErrorFrontend', 'error404');
     }

      $product_id = $this->getRequestParameter('id');

      $this->product = ProductPeer::retrieveByPK($product_id);

      $this->smarty = new stSmarty('stProduct');

      $c = new Criteria();

      $c->addJoin(ProductHasAttachmentPeer::SF_ASSET_ID, sfAssetPeer::ID);

      $c->add(ProductHasAttachmentPeer::PRODUCT_ID, $this->product->getId());

      $c->add(ProductHasAttachmentPeer::IS_ACTIVE, true);

      $c->add(ProductHasAttachmentPeer::OPT_CULTURE, $this->getUser()->getCulture());

      $this->attachments = sfAssetPeer::doSelectWithI18n($c);

      $this->setLayout(false);
   }

   /**
    * Lista Produktow z produktów danego producenta 
    */
   public function executeProducerList()
   {
      $this->page = $this->getRequestParameter('page');

      if (!$this->processProducerFriendlyUrl())
      {
         return $this->forward('stProduct', 'producerNotFound');
      }  

      $this->getRequest()->setParameter('producer', $this->getRequestParameter('url'));

      stProducer::setSelectedProducerId($this->producer->getId()); 
      
      $this->config = stConfig::getInstance(sfContext::getInstance(), 'stProduct');

      $this->smarty = new stSmarty($this->getModuleName());

      $pager = new stPropelPager('Product');

      $c = new Criteria();

      $this->productPagerInit($c);

      $this->product_on_page = $this->product_pager->getCntResults();

      $this->forLinkInit($this->producer->getFriendlyUrl(), $this->product_pager->getPage());
      
      $this->config_points = stConfig::getInstance(sfContext::getInstance(), 'stPointsBackend');
      $this->config_points->setCulture(sfContext::getInstance()->getUser()->getCulture());

      $this->sort_labels = $this->getSortColumns('label_names');

      $this->view_labels = $this->getViewTypes('label_names');

      $this->title = $this->producer->getName();

      $this->addRelLinks('producerList', $this->producer->getFriendlyUrl());
   }

   /**
    * Strona nieznalezionej grupy produktów
    *
    */
   public function executeProducerNotFound()
   {
      $this->getResponse()->setStatusCode(404);

      $this->getResponse()->setHttpHeader('Status', '404 Not Found');

      $this->getResponse()->addMeta('robots', 'noindex');

      $this->smarty = new stSmarty($this->getModuleName());
   }

   /**
    * Dodaje kryteria producenta
    *
    * @param      Criteria    $c
    */
   protected function addProducerCriteria(Criteria $c)
   {
      if ($this->getTheme()->getVersion() < 7)
      {
         $producer_id = $this->getUser()->getAttribute('producer_filter', stProducer::getSelectedProducerId(), stProductFilter::getNamespace($this->getContext(), 'soteshop/stProduct'));
      
         if ($producer_id)
         {
            $c->add(ProductPeer::PRODUCER_ID, $producer_id);
         }
      }
      else
      {
         $filters = stProductFilter::getFilters($this->getContext());

         if (isset($filters['producer']) && $filters['producer'])
         {
            if (is_array($filters['producer']))
            {
               $c->add(ProductPeer::PRODUCER_ID, array_values($filters['producer']), Criteria::IN);
            }
            else
            {
               $c->add(ProductPeer::PRODUCER_ID, $filters['producer']);
            }
         }
      }
   }

   /**
    * Dodaje dodatkowe kryteria filtrowania
    *
    */
   protected function addFiltersCriteria(Criteria $c)
   {

   }

   /**
    *
    * Lista Produktow z danej grupy
    * @author Marcin Butlak <marcin.butlak@sote.pl>
    *
    */
   public function executeGroupList()
   {
      $this->page = $this->getRequestParameter('page');

      if (!$this->processGroup301Redirects())
      {
         return $this->forward('stProduct', 'productGroupNotFound');
      }

      if (!$this->processGroupFriendlyUrl())
      {
         return $this->forward('stProduct', 'productGroupNotFound');
      }

      $producer_id = stProducer::getSelectedProducerId();
      stProducer::clearSelectedProducerId();   

      $this->config = stConfig::getInstance(sfContext::getInstance(), 'stProduct');

      $this->config_points = stConfig::getInstance(sfContext::getInstance(), 'stPointsBackend');

      $this->config_points->setCulture(sfContext::getInstance()->getUser()->getCulture());

      $config_product_group = stConfig::getInstance('stProductGroup');

      $new_type = $config_product_group->get('new_type');

      $this->smarty = new stSmarty($this->getModuleName());

      $pager = new stPropelPager('Product');


      $c = new Criteria();

      $this->addProductGroup($c);

      $this->productPagerInit($c);

      $this->product_on_page = $this->product_pager->getCntResults();

      if ($new_type == 'date' && $this->product_group->getProductGroup() == 'NEW')
      {
         $c->clear();

         $this->addNew($c);

         $this->productPagerInit($c);

         $this->product_on_page = $this->product_pager->getCntResults();
      }

      $page = $this->product_pager->getPage();

      $this->forLinkInit($this->product_group->getFriendlyUrl(), $page);

      $this->sort_labels = $this->getSortColumns('label_names');

      $this->view_labels = $this->getViewTypes('label_names');

      $this->title = $this->product_group->getName();

      $this->addRelLinks('groupList', $this->product_group->getFriendlyUrl());

      $this->getUser()->setParameter('selected', $this->product_group, 'soteshop/stProductGroup');

      stProducer::setSelectedProducerId($producer_id);  
   }

   /**
    *
    * Lista Produktow
    * @author Marcin Butlak <marcin.butlak@sote.pl>
    *
    */
   public function executeList()
   {
      $this->page = $this->getRequestParameter('page');

      $this->processSearchQuery();

      if ($this->hasRequestParameter('producer'))
      {
        $this->getResponse()->addMeta('robots', "noindex");
      }

      if (null === $this->query)
      {
         if (!$this->processGroup301Redirects())
         {
            return $this->forward('stProduct', 'groupNotFound');
         }

         if (!$this->processNew301Redirects())
         {
            return $this->forward('stProduct', 'groupNotFound');
         }

         if (!$this->processCategory301Redirects())
         {
            return $this->forward('stProduct', 'categoryNotFound');
         }

         if (!$this->processCategoryFriendlyUrl())
         {
            return $this->forward('stProduct', 'categoryNotFound');
         }
      }

      $this->config = stConfig::getInstance(sfContext::getInstance(), 'stProduct');
      
      $this->config_points = stConfig::getInstance(sfContext::getInstance(), 'stPointsBackend');
      $this->config_points->setCulture(sfContext::getInstance()->getUser()->getCulture());

      $this->smarty = new stSmarty($this->getModuleName());

      $c = new Criteria();

      $this->productPagerInit($c);

      $this->product_on_page = $this->query !== null && $this->revelance == 0 ? 0 : $this->product_pager->getCntResults();

      if (!$this->product_on_page && null === $this->query && stConfig::getInstance('stCategory')->get('hide_categories_without_products') && !$this->hasRequestParameter('filter') && (!$this->category || $this->category->isLeaf()))
      {
         return $this->forward('stProduct', 'categoryNotFound');  
      }

      $page = $this->product_pager->getPage();

      $this->forLinkInit($this->category ? $this->category->getFriendlyUrl() : null, $page);

      if (trim($this->getRequestParameter('query_url'))) 
      {
         $this->for_link['query_url'] = trim($this->getRequestParameter('query_url'));
      }

      $this->sort_labels = $this->getSortColumns('label_names');

      $this->view_labels = $this->getViewTypes('label_names');

      if ($this->getTheme()->getVersion() >= 7)
      {
         if (null !== $this->query)
         {
            $this->getTheme()->setLayoutName('one_column');
         }
         else
         {
            $this->getTheme()->setLayoutName('two_column');
         }
      }

      if ($this->category)
      {
         $this->addRelLinks('list', $this->category->getFriendlyUrl());
      }
   }

   /**
    * Wyświetla opis szczegółowy produktu
    */
   public function executeShow()
   {
      $this->config = stConfig::getInstance(sfContext::getInstance(), 'stProduct');
      
      $this->config_points = stConfig::getInstance(sfContext::getInstance(), 'stPointsBackend');
      $this->config_points->setCulture(sfContext::getInstance()->getUser()->getCulture());


      $this->smarty = new stSmarty($this->getModuleName());

      if (!$this->processProduct301Redirects())
      {
         return $this->forward('stProduct', 'productNotFound');
      }

      if (!$this->processProductFriendlyUrl())
      {
         return $this->forward('stProduct', 'productNotFound');
      }

      if (!$this->product->isActive())
      {
         return $this->forward('stProduct', 'productNotFound');
      }

      if (stProducer::getSelectedProducerId() != $this->product->getProducerId())
      {
         stProducer::clearSelectedProducerId();
      }

      $this->description = $this->product->getDescription();

      if ($this->hasRequestParameter('uniqid'))
      {
         $this->uniqid = $this->getRequestParameter('uniqid');
         $this->getUser()->setAttribute('uniqid', $this->getRequestParameter('uniqid'));
         $this->getUser()->setAttribute('uniqid_product_id', $this->product->getId());
      }
      else
      {
         $this->uniqid = false;
      }

      if ($this->product->getProducerId())
      {
         $this->producer = $this->product->getProducer();
      }

      $this->category = null;

      $category = $this->getUser()->getAttribute('selected', null, 'soteshop/stCategory');

      $refinfo = parse_url($this->getRequest()->getReferer());

      if ($category)
      {
         $this->category = preg_match('#/category/'.$category->getFriendlyUrl().'$#', $refinfo['path']) || preg_match('#/manufacturer/[^/]+/'.$category->getFriendlyUrl().'#', $refinfo['path']) ? $category : null;
      }

      if ($this->category)
      {
         $c = new Criteria();
         $c->add(ProductHasCategoryPeer::PRODUCT_ID, $this->product->getId());
         
         if (!$this->category->getShowChildrenProducts())
         {  
            $c->add(ProductHasCategoryPeer::CATEGORY_ID, $this->category->getId());
         }
         else
         {
            $c->addJoin(ProductHasCategoryPeer::CATEGORY_ID, CategoryPeer::ID);
            $c->add(CategoryPeer::SCOPE, $this->category->getScope());
            $c->add(CategoryPeer::LFT, sprintf('%s BETWEEN %d AND %d', CategoryPeer::LFT, $this->category->getLft(), $this->category->getRgt()), Criteria::CUSTOM);
         }

         if (ProductHasCategoryPeer::doCount($c) == 0) 
         {            
            $this->category = null;
         }
      }

      if (null === $this->category)
      {
         $category = $this->product->getDefaultCategory();

         if ($category && $category->getIsActive())
         {
            $this->category = $category;
         }
      }
      elseif (!$this->product->getDefaultCategory())
      {
         $this->category = null;         
      }

      $this->addTabs();

      if ($this->category)
      {         
         $this->getUser()->setParameter('selected', $this->category, 'soteshop/stCategory');
         $this->getUser()->setAttribute('selected', $this->category, 'soteshop/stCategory');
      }
      else
      {
        $this->getUser()->setParameter('selected', null, 'soteshop/stCategory');
        $this->getUser()->setAttribute('selected', null, 'soteshop/stCategory');
      }

      $this->themeVersion = $this->getController()->getTheme()->getVersion();

      sfLoader::loadHelpers(array('Helper', 'stUrl'));

      $this->images_in_options = $this->getImagesInOptions();

      $this->getResponse()->setCanonicalLink(st_url_for('stProduct/show?url='.$this->product->getFriendlyUrl(), true, null, stLanguage::getInstance($this->getContext())->getDomain()));

      $c = new Criteria();
      $c->add(ReviewPeer::PRODUCT_ID, $this->product->getId());
      $c->add(ReviewPeer::SCORE, null, Criteria::ISNOTNULL);
      $c->add(ReviewPeer::AGREEMENT,1);
      $this->structure_review = ReviewPeer::doSelectOne($c);
   }

   /**
    * Polecane produkty w opisie szczegółowym produktu
    */
   public function executeRecommendProducts()
   {
      if(!$this->getRequest()->isXmlHttpRequest() && $this->getController()->getRenderMode() != sfView::RENDER_VAR)
      {  
         $this->getResponse()->setStatusCode(404);

         $this->getResponse()->setHttpHeader('Status', '404 Not Found');

         return $this->forward('stErrorFrontend', 'error404');
      }

      $this->setLayout(false);

      $this->config = stConfig::getInstance(sfContext::getInstance(), 'stProduct');
      
      $this->config_points = stConfig::getInstance(sfContext::getInstance(), 'stPointsBackend');
      $this->config_points->setCulture(sfContext::getInstance()->getUser()->getCulture());

      $this->smarty = new stSmarty($this->getModuleName());

      $this->product_id = $this->getRequestParameter('id');

      $product = ProductPeer::retrieveByPK($this->product_id);

      $c = new Criteria();

      $this->addProductFilterCriteria($c);

      $ids = $this->getRequestParameter('category_ids');

      if ($ids)
      {
         $c->addDescendingOrderByColumn(ProductI18nPeer::NAME);
         $c->addJoin(ProductHasCategoryPeer::PRODUCT_ID, ProductPeer::ID);
         $c->add(ProductHasCategoryPeer::CATEGORY_ID, explode(",", $ids), Criteria::IN);
         $c->add(ProductPeer::ID, $this->product_id, Criteria::NOT_EQUAL);
         $c->setLimit($this->config->get('other_products_num'));

         $c = $this->getDispatcher()->filter(new sfEvent($this, 'stProductActions.filterRecommendProductsCriteria'), $c)->getReturnValue();

         $this->products = ProductPeer::doSelectForPager($c);         
      }
      elseif (null !== $product && $product->countProductHasRecommendsRelatedByProductId()>0)
      {
         $c->addJoin(ProductHasRecommendPeer::RECOMMEND_ID, ProductPeer::ID);
         $c->add(ProductHasRecommendPeer::PRODUCT_ID, $this->product_id);
         $c->setLimit($this->config->get('other_products_num'));
         $c->addAscendingOrderByColumn(ProductHasRecommendPeer::ID);

         $c = $this->getDispatcher()->filter(new sfEvent($this, 'stProductActions.filterRecommendProductsCriteria'), $c)->getReturnValue();
         
         $this->products = ProductPeer::doSelectForPager($c);
      }
      else
      {  
         $c->addDescendingOrderByColumn(ProductI18nPeer::NAME);
         $c->addJoin(ProductHasCategoryPeer::PRODUCT_ID, ProductPeer::ID);
         $c->add(ProductHasCategoryPeer::CATEGORY_ID, $this->getRequestParameter('id_category'));
         $c->add(ProductPeer::ID, $this->product_id, Criteria::NOT_EQUAL);
         $c->setLimit($this->config->get('other_products_num'));

         $c = $this->getDispatcher()->filter(new sfEvent($this, 'stProductActions.filterRecommendProductsCriteria'), $c)->getReturnValue();

         $this->products = ProductPeer::doSelectForPager($c);
      }

      $this->list_type = "listOther";
   }

   /**
    * Wyświetla opis produktu
    */
   public function executeProductDescription()
   {

    if(!$this->getRequest()->isXmlHttpRequest() && $this->getController()->getRenderMode() != sfView::RENDER_VAR){  

        $this->getResponse()->setStatusCode(404);

        $this->getResponse()->setHttpHeader('Status', '404 Not Found');

        return $this->forward('stErrorFrontend', 'error404');
     }

      $this->smarty = new stSmarty($this->getModuleName());

      $this->setLayout(false);

      $this->product = ProductPeer::getShowedProduct();
      if (!is_object($this->product))
         $this->product = ProductPeer::retrieveByPk($this->getRequestParameter('id'));

      $this->description = $this->product->getDescription();
   }

   /**
    * Strona nieznalezionej kategorii
    *
    */
   public function executeCategoryNotFound()
   {
      $this->getResponse()->setStatusCode(404);

      $this->getResponse()->setHttpHeader('Status', '404 Not Found');

      $this->getResponse()->addMeta('robots', 'noindex');

      $this->smarty = new stSmarty($this->getModuleName());
   }

   /**
    * Zwraca zawartość obrazka typu 'big'
    *
    * @author Marcin Butlak <marcin.butlak@sote.pl>
    * @return sfView
    */
   public function executeShowImage()
   {
      $image = $this->getRequestParameter('image');

      $folder = sfAssetFolderPeer::retrieveByPK($this->getRequestParameter('folder'));

      if ($folder)
      {
         $asset = sfAssetPeer::retrieveFromUrl($folder->getRelativePath() . '/' . $image);
      }

      sfLoader::loadHelpers(array('Helper', 'stProductImage'));

      $file = st_product_image_path($asset, 'big', true, true);

      $info = getimagesize($file);

      $this->getResponse()->setHttpHeader('Content-Type', image_type_to_mime_type($info[2]));

      return $this->renderText(file_get_contents($file));
   }

   /**
    * Generuje obrazek z ajax requesta
    *
    * @return   void
    */
   public function executePhotoAjax()
   {
      $product = ProductPeer::retrieveByPK($this->getRequestParameter('id'));
      $this->image = '/uploads/products/' . $product->getImage() . '/' . $this->getRequestParameter("asset_id");
      $dimensions = getimagesize('uploads/products/' . $product->getImage() . '/' . $this->getRequestParameter("asset_id"));
      $dimensions[0] += 20;
      $dimensions[1] += 30;
      $this->dimensions = $dimensions;
   }

   public function executeDownloadAttachment()
   {
      $folder = $this->getRequestParameter('folder');

      $culture = $this->getRequestParameter('culture');

      $filename = $this->getRequestParameter('filename');

      $file = sfAssetPeer::retrieveFromUrl('/media/products/' . $folder . '/attachments/' . $culture . '/' . $filename);

      if (!$file)
      {
         return $this->forward404();
      }

      $filepath = $file->getFullPath();

      $response = $this->getResponse();

      $response->setHttpHeader('Content-Description', 'File Transfer');

      $response->setHttpHeader('Content-Type', 'application/octet-stream');

      $response->setHttpHeader('Content-Disposition', 'attachment; filename=' . $file->getFilename());

      $response->setHttpHeader('Content-Transfer-Encoding', 'binary');

      $response->setHttpHeader('Expires', 0);

      $response->setHttpHeader('Cache-Control', 'must-revalidate, post-check=0, pre-check=0');

      $response->setHttpHeader('Pragma', 'public');

      $response->setHttpHeader('Content-Length', filesize($filepath));

      return $this->renderText(file_get_contents($filepath));
   }

   /**
    * Strona nieznalezionego produktu
    *
    */
   public function executeProductNotFound()
   {
      $this->getResponse()->setStatusCode(404);

      $this->getResponse()->setHttpHeader('Status', '404 Not Found');

      $this->getResponse()->addMeta('robots', 'noindex');

      $this->smarty = new stSmarty($this->getModuleName());
   }

   public function executeClearFilter()
   {
      $filter = $this->getRequestParameter('filter');
      $scope = $this->getRequestParameter('scope');

      $this->loadCategoryFromRequest();

      if ($scope == 'filter')
      {
         stProductFilter::clearFilters($this->getContext(), $filter);
      }

      $this->postExecute();

      if ($this->getRequest()->isXmlHttpRequest())
      {
         return $this->renderUpdateFilters();
      }

      return $this->redirect($this->getRequest()->getReferer()); 
   }

   public function executeFilter()
   {
      if ($this->getRequest()->getMethod() == sfRequest::POST)
      {
         $this->loadCategoryFromRequest();

         $fields = $this->getRequestParameter('fields');

         if ($fields)
         {
            $data = $this->getRequestParameter('product_filter', array());
            $filters = stProductFilter::getFilters($this->getContext());

            foreach (explode(',', $fields) as $field)
            {
               $field = trim($field);
               $filters[$field] = isset($data[$field]) ? $data[$field] : null;
            }

            stProductFilter::setFilters($this->getContext(), $filters);            
         }

         $this->postExecute();

         stFastCacheController::disable();

         if ($this->getRequest()->isXmlHttpRequest())
         {
            return $this->renderUpdateFilters();
         }
      }

      return $this->redirect(appProductAttributeHelper::getFilterUrl($this->getRequest()->getReferer()));
   }

   /**
    * Strona nieznalezionej grupy produktów
    *
    */
   public function executeProductGroupNotFound()
   {

      $this->getResponse()->setStatusCode(404);

      $this->getResponse()->setHttpHeader('Status', '404 Not Found');

      $this->getResponse()->addMeta('robots', 'noindex');

      $this->smarty = new stSmarty($this->getModuleName());
   }

   /**
    * Strona z historią zmiany cen Product Price History
    */
   public function executePriceHistory()
   {             
      // Wywołanie akcji oprzeniesionej do stPriceHistoryPlugin
      $price_history = new stPriceHistoryFrontend();
      return $price_history->frontendPriceHistory($this);               
   }

   public function postExecute()
   {
      if (isset($this->smarty))
      {
         $this->smarty->register_function('st_product_image_tag', 'st_product_smarty_image_tag');
      }

      parent::postExecute();
   }


   /**
    *
    * Pobiera nowy obiekt stPropelPager dla produktu
    * @author Marcin Butlak <marcin.butlak@sote.pl>
    *
    */
   protected function productPagerInit(Criteria $c)
   {
      $this->product_pager = new stPropelPager('Product');

      $c = clone $c;

      $this->processFilters();

      $this->addType();

      if (null !== $this->query) 
      {
         $this->revelance = $this->addSearchCriteria($c, $this->query);
      }

      $this->addSort($c);

      $this->product_pager->setPage($this->page);

      $this->product_pager->setCriteria($c);

      $this->product_pager->setPeerMethod('doSelectForPager');

      if (null !== $this->query)
      {
         $this->product_pager->setPeerCountMethod(array('ProductSearchTagPeer', 'doCountProduct')); 
      }

      ProductPeer::addFilterCriteria($this->getContext(), $c, true, false);

      $this->addProducerCriteria($c);

      $this->addFiltersCriteria($c);

      $this->getUser()->setParameter('pre_filter_criteria', clone $c, 'soteshop/stProduct'); 

      stEventDispatcher::getInstance()->notify(new sfEvent($this, 'stProductActions.preProductPagerInit', array('pager_criteria' => $this->product_pager->getCriteria())));

      ProductPeer::addPriceFilterCriteria($this->getContext(), $c);

      appProductAttributeHelper::addProductPagerCriteria($this->product_pager);

      $this->product_pager->init();
   }

   protected function processProducerFriendlyUrl($url = null)
   {
      if (!isset($this->producer) && $this->getRequest()->getParameter('url', $url))
      {
         if (null === $url)
         {
            $url = $this->getRequest()->getParameter('url');
         }

         $this->producer = ProducerPeer::retrieveByUrl($url);

         if ($this->producer)
         {
            $this->getUser()->setParameter('selected', $this->producer, 'soteshop/stProducer');
            $this->producer->setCulture($this->getUser()->getCulture());

            if ($url != $this->producer->getFriendlyUrl())
            {
               sfLoader::loadHelpers(array('Helper', 'stUrl'));

               $r = sfRouting::getInstance();

               list(, $redirect) = $this->getController()->convertUrlStringToParameters($r->getCurrentInternalUri());

               $redirect['url'] = $this->producer->getFriendlyUrl();

               $this->redirect(st_url_for($redirect, true), 301);
            }
         }
         else
         {
            return false;
         }
      }

      return true;
   }   

   /**
    *
    * Obsluga przyjaznych linkow dla kategorii
    * @author Marcin Butlak <marcin.butlak@sote.pl>
    *
    */
   protected function processCategoryFriendlyUrl()
   {

      if ($this->getRequest()->hasParameter('url'))
      {
         $url = $this->getRequest()->getParameter('url');

         $category = CategoryPeer::retrieveByUrl($url);
  
         if ($category && $category->getIsActive())
         {
            $this->category = $category;

            $this->category->setCulture($this->getUser()->getCulture());

            if ($url != $this->category->getFriendlyUrl())
            {
               sfLoader::loadHelpers(array('Helper', 'stUrl'));

               $r = sfRouting::getInstance();

               list(, $redirect) = $this->getController()->convertUrlStringToParameters($r->getCurrentInternalUri());

               $redirect['url'] = $this->category->getFriendlyUrl();

               $this->redirect(st_url_for($redirect, true), 301);
            }

            $this->getUser()->setParameter('selected', $this->category, 'soteshop/stCategory');   
            $this->getUser()->setAttribute('selected', $this->category, 'soteshop/stCategory');         
         }
         else
         {
            return false;
         }
      }

      return true;
   }

   /**
    *
    * Obluga przyjaznych linkow dla grup produktow
    * @author Marcin Butlak <marcin.butlak@sote.pl>
    *
    */
   protected function processGroupFriendlyUrl()
   {
      if ($this->getRequest()->hasParameter('url'))
      {
         $url = $this->getRequest()->getParameter('url');

         $this->product_group = ProductGroupPeer::retrieveByUrl($url);

         if ($this->product_group)
         {
            $this->product_group->setCulture($this->getUser()->getCulture());

            $this->getUser()->setParameter('selected', $this->product_group, 'soteshop/stProductGroup');  

            if ($url != $this->product_group->getFriendlyUrl())
            {
               sfLoader::loadHelpers(array('Helper', 'stUrl'));

               $r = sfRouting::getInstance();

               list(, $redirect) = $this->getController()->convertUrlStringToParameters($r->getCurrentInternalUri());

               $redirect['url'] = $this->product_group->getFriendlyUrl();

               $this->redirect(st_url_for($redirect, true), 301);
            }
         }
         else
         {
            return false;
         }
      }

      return true;
   }

   protected function processProductFriendlyUrl()
   {
      if ($this->getRequest()->hasParameter('url'))
      {
         $url = $this->getRequest()->getParameter('url');

         $this->product = ProductPeer::retrieveByUrl($url);

         if ($this->product && $this->product->isActive(true))
         {
            $this->product->setCulture($this->getUser()->getCulture());

            $this->getUser()->setParameter('selected', $this->product, 'soteshop/stProduct');  

            if ($url != $this->product->getFriendlyUrl())
            {
               sfLoader::loadHelpers(array('Helper', 'stUrl'));

               $r = sfRouting::getInstance();

               list(, $redirect) = $this->getController()->convertUrlStringToParameters($r->getCurrentInternalUri());

               $redirect['url'] = $this->product->getFriendlyUrl();

               $this->redirect(st_url_for($redirect, true), 301);
            }
         }
         else
         {
            return false;
         }
      }

      return true;
   }

   /**
    *
    * Obsluga przekierowan dla starych linkow
    * @author Marcin Butlak <marcin.butlak@sote.pl>
    *
    */
   protected function processCategory301Redirects()
   {
      if ($this->hasRequestParameter('id_category'))
      {
         sfLoader::loadHelpers(array('Helper', 'stUrl'));

         $category_id = $this->getRequestParameter('id_category');

         $category = CategoryPeer::retrieveByPK($category_id);

         if (is_null($category))
         {
            return false;
         }

         $category->setCulture($this->getUser()->getCulture());

         if ($this->page)
         {
            $this->redirect(st_url_for('stProduct/list?url=' . $category->getFriendlyUrl() . '&page=' . $this->page, true), 301);
         }
         else
         {
            $this->redirect(st_url_for('stProduct/list?url=' . $category->getFriendlyUrl(), true), 301);
         }
      }

      return true;
   }

   protected function processGroup301Redirects()
   {
      if ($this->hasRequestParameter('group_id'))
      {
         sfLoader::loadHelpers(array('Helper', 'stUrl'));

         $produt_group_id = $this->getRequestParameter('group_id');

         $product_group = ProductGroupPeer::retrieveByPK($produt_group_id);

         if (is_null($product_group))
         {
            return false;
         }

         $product_group->setCulture($this->getUser()->getCulture());

         if ($this->page)
         {
            return $this->redirect(st_url_for('stProduct/groupList?url=' . $product_group->getFriendlyUrl() . '&page=' . $this->page, true), 301);
         }
         else
         {
            return $this->redirect(st_url_for('stProduct/groupList?url=' . $product_group->getFriendlyUrl(), true), 301);
         }
      }

      return true;
   }

   protected function processNew301Redirects()
   {
      if ($this->hasRequestParameter('new'))
      {
         sfLoader::loadHelpers(array('Helper', 'stUrl'));

         $c = new Criteria();

         $c->add(ProductGroupPeer::PRODUCT_GROUP, 'NEW');

         $product_group = ProductGroupPeer::doSelectOne($c);

         if (is_null($product_group))
         {
            return false;
         }

         $product_group->setCulture($this->getUser()->getCulture());

         if ($this->page)
         {
            return $this->redirect(st_url_for('stProduct/groupList?url=' . $product_group->getFriendlyUrl() . '&page=' . $this->page, true), 301);
         }
         else
         {
            return $this->redirect(st_url_for('stProduct/groupList?url=' . $product_group->getFriendlyUrl(), true), 301);
         }
      }

      return true;
   }

   protected function processProduct301Redirects()
   {
      if ($this->hasRequestParameter('id'))
      {
         sfLoader::loadHelpers(array('Helper', 'stUrl'));

         $product_id = $this->getRequestParameter('id');

         $product = ProductPeer::retrieveByPK($product_id);

         if (is_null($product))
         {
            return false;
         }

         $product->setCulture($this->getUser()->getCulture());

         return $this->redirect(st_url_for('stProduct/show?url=' . $product->getFriendlyUrl(), true), 301);
      }

      return true;
   }

   /**
    * Typ wyświetlanej listy
    *
    * @param        object      $pager
    */
   protected function addType()
   {
      $view_types = $this->getViewTypes('view_names');

      if ($this->hasRequestParameter('type'))
      {
         $this->getUser()->setAttribute('view_type', $this->getRequestParameter('type'), 'soteshop/stProduct');
      }

      $this->type_list_url = $this->getUser()->getAttribute('view_type', $this->config->get('list_type'), 'soteshop/stProduct');

      if ($this->getTheme()->getVersion() >= 7)
      {
          if($this->type_list_url=="short"){
              $this->type_list_url = "description";
          }
      }

      if (!isset($view_types[$this->type_list_url]))
      {
         $this->type_list_url = $this->config->get('list_type');
      }
        

      if (isset($view_types[$this->type_list_url]))
      {
         $this->list_type = $view_types[$this->type_list_url];
         
        if ($this->getTheme()->getVersion() >= 7 && $this->type_list_url=="description")
        {              
            $this->product_pager->setMaxPerPage($this->config->get("short" . '_list'));              
        }else{
            $this->product_pager->setMaxPerPage($this->config->get($this->type_list_url . '_list'));    
        }
         
      }
   }

   /**
    * Wyświetla nowości
    *
    * @param      Criteria    $c
    */
   protected function addNew(Criteria $c)
   {
      $config = stConfig::getInstance(sfContext::getInstance(), 'stProduct');

      $c->add(ProductPeer::CREATED_AT, strtotime($config->get('new_product_date')), Criteria::GREATER_THAN);

      $this->new = $this->getRequestParameter('new');
   }

   /**
    * Wyświetla daną grupę produktów
    *
    * @param      Criteria    $c
    */
   protected function addProductGroup(Criteria $c)
   {
      $c->addJoin(ProductGroupHasProductPeer::PRODUCT_ID, ProductPeer::ID);
      $c->add(ProductGroupHasProductPeer::PRODUCT_GROUP_ID, $this->product_group->getId());
   }

   /**
    * Dodaje Sortowanie
    *
    * @param      Criteria    $c
    */
   protected function addSort(Criteria $c)
   {
      $sort_columns = $this->getSortColumns('table_names');

      if ($this->hasRequestParameter('sort_order'))
      {
         $this->getUser()->setAttribute('sort_order', $this->getRequestParameter('sort_order'), 'soteshop/stProduct');
      }

      if ($this->hasRequestParameter('sort_by'))
      {
         $this->getUser()->setAttribute('sort_by', $this->getRequestParameter('sort_by'), 'soteshop/stProduct');
      }
      elseif (null !== $this->query && $this->revelance)
      {
         $this->getUser()->setAttribute('sort_order', 'desc', 'soteshop/stProduct');
         $this->getUser()->setAttribute('sort_by', 'accuracy', 'soteshop/stProduct');         
      }

      $this->sort_order = $this->getUser()->getAttribute('sort_order', $this->config->get('sort_asc_desc'), 'soteshop/stProduct');

      $this->sort_by = $this->getUser()->getAttribute('sort_by', $this->config->get('sort_type'), 'soteshop/stProduct');

      if (!isset($sort_columns[$this->sort_by]))
      {
         $this->sort_by = $this->config->get('sort_type');
         $this->sort_order = $this->config->get('sort_asc_desc');
         $this->getUser()->setAttribute('sort_by', $this->sort_by, 'soteshop/stProduct');
         $this->getUser()->setAttribute('sort_order', $this->sort_order, 'soteshop/stProduct');
      }

      if (isset($sort_columns[$this->sort_by]))
      {
         if ($this->sort_order == "asc")
         {
            $c->addAscendingOrderByColumn($sort_columns[$this->sort_by]);
            $c->addAscendingOrderByColumn(ProductPeer::ID);
         }
         else
         {
            $c->addDescendingOrderByColumn($sort_columns[$this->sort_by]);
            $c->addAscendingOrderByColumn(ProductPeer::ID);
         }

         if ($this->sort_by == "priority")
         {

           if ($this->sort_order == "asc")
           {
              $c->addAscendingOrderByColumn(ProductI18nPeer::NAME);
           }
           else
           {
              $c->addDescendingOrderByColumn(ProductI18nPeer::NAME);
           }

         }
         
      }
   }

   /**
    * Zakładki
    */
   protected function addTabs()
   {
      $version = $this->getController()->getTheme()->getVersion();

      $for_product = array(
         'id' => $this->product->getId(),
      );

      if ($this->category && $this->category->getId())
      {
         $for_product['id_category'] = $this->category->getId();
      }

      if ($this->product->getProducerId())
      {
         $for_product['id_producer'] = $this->product->getProducerId();
      }

      $config = stConfig::getInstance(sfContext::getInstance(), 'stProduct');

      $show_description = $config->get('show_description');

      $show_recommended_products = $config->get('show_other_products');
      
      $show_review=$config->get('show_review');

      if ($show_recommended_products)
      {
         $show_recommended_products = $this->product->countProductHasRecommendsRelatedByProductId() > 0;
         

         if (!$show_recommended_products && $this->category)
         { 
            if ($this->category->hasChildren())
            {
               $c = new Criteria();
               $c->addSelectColumn(CategoryPeer::ID);
               $c->addSelectColumn(CategoryPeer::LFT);
               $c->addSelectColumn(CategoryPeer::SCOPE);
               $c->add(ProductHasCategoryPeer::PRODUCT_ID, $this->product->getId());
               $c->addJoin(ProductHasCategoryPeer::CATEGORY_ID, CategoryPeer::ID);
               
               $rs = CategoryPeer::doSelectRS($c);
               
               $ids = array();

               while($rs->next())
               {
                  list($id, $lft, $scope) = $rs->getRow();

                  if ($lft >= $this->category->getLft() && $lft <= $this->category->getRgt() && $scope == $this->category->getScope())
                  {
                     $ids[] = $id;
                  }
               }

               if ($ids)
               {
                  $c = new Criteria();
                  $c->addJoin(ProductHasCategoryPeer::PRODUCT_ID, ProductPeer::ID);
                  $c->add(ProductHasCategoryPeer::CATEGORY_ID, $ids, Criteria::IN);
                  $c->add(ProductPeer::ID, $this->product->getId(), Criteria::NOT_EQUAL);
                  $this->addProductFilterCriteria($c);
                  $show_recommended_products = ProductPeer::doCount($c) > 0;

                  $for_product['category_ids'] = implode(',', $ids);
               }
            }
            else
            {
               $c = new Criteria();
               $c->addJoin(ProductHasCategoryPeer::PRODUCT_ID, ProductPeer::ID);
               $c->add(ProductHasCategoryPeer::CATEGORY_ID, $this->category->getId());
               $c->add(ProductPeer::ID, $this->product->getId(), Criteria::NOT_EQUAL);
               $this->addProductFilterCriteria($c);
               $show_recommended_products = ProductPeer::doCount($c) > 0;
            }
         }
      }

      $c = new Criteria();
      $c->add(ProductHasAttachmentPeer::IS_ACTIVE, true);
      $c->add(ProductHasAttachmentPeer::OPT_CULTURE, $this->getUser()->getCulture());
      $show_attachments = $this->product->countProductHasAttachments($c) > 0;  

      if ($version < 7)
      {  
         $this->productList = stTabNavigator::getInstance($this->getContext(), 'product_list', 'product/show?id=' . $this->product->getId());

         if ($show_recommended_products)
         {
            $this->productList->addTab('Polecamy produkty', 'stProduct', 'recommendProducts', $for_product);
         }

         $this->productList->setTab($this->getRequestParameter('product_list'));

         $this->productDescription = stTabNavigator::getInstance($this->getContext(), 'product_description', 'product/show?id=' . $this->product->getId());

         if ($version < 2)
         {
            if ($show_description == 1 )
            {
               $this->productDescription->addTab('Opis', 'stProduct', 'productDescription', $for_product);
            }
         }

         if ($show_attachments)
         {
            $this->productDescription->addTab('Załączniki', 'stProduct', 'attachmentList', $for_product);
         }

         $this->productDescription->setTab($this->getRequestParameter('product_description', 0));
      }
      else
      {
         $this->tabNavigator = stTabNavigator::getInstance($this->getContext(), null, null);

         if ($config->get('show_accessories'))
         {            
            $c = new Criteria();
            $c->addJoin(ProductHasAccessoriesPeer::ACCESSORIES_ID, ProductPeer::ID);
            $this->addProductFilterCriteria($c);

            if ($this->product->countProductHasAccessoriessRelatedByProductId($c) > 0)
            {               
               $this->tabNavigator->addTab('Akcesoria', 'stAccessoriesFrontend', 'accessoriesList',array('id' => $this->product->getId()));
            }
         }

         if ($show_recommended_products)
         {
            $this->tabNavigator->addTab('Polecamy produkty', 'stProduct', 'recommendProducts', $for_product);
         }

         if ($show_attachments)
         {
            $this->tabNavigator->addTab('Załączniki', 'stProduct', 'attachmentList', $for_product);
         }

        if($config->get('review_type') == "option_1")
        {

            $c = new Criteria();
            $c->add(ReviewPeer::PRODUCT_ID, $this->product->getId());
            $c->add(ReviewPeer::ACTIVE, 1);
            $criterion = $c->getNewCriterion(ReviewPeer::AGREEMENT, 1);
            $criterion->addOr($c->getNewCriterion(ReviewPeer::USER_IP, $this->getRequest()->getHttpHeader ('addr','remote')));
            $c->add($criterion);
            $c->add(ReviewPeer::DESCRIPTION, "", Criteria::NOT_IN);
            $c->add(ReviewPeer::LANGUAGE, $this->getUser()->getCulture());
            $count_review = ReviewPeer::doCount($c);     
             
             if ($show_review==1 && ReviewPeer::doCount($c))
             {
                 $i18n = $this->getContext()->getI18n();             
                 $this->tabNavigator->addTab($i18n->__('Recenzje').' ('.$count_review.')', 'stReview', 'listReviews', $for_product, 'review');
             }
         
        } 
      }
   }

   protected function getSortColumns($type = null, $columns = array())
   {
      $defaults = array(
          'label_names' => array(
              'name' => 'Nazwie',
              'price' => 'Cenie',
              'created_at' => 'Najnowszym',
              'priority' => 'Kolejność',
          ),
          'table_names' => array(
              'name' => ProductI18nPeer::NAME,
              'price' => ProductPeer::OPT_PRICE_BRUTTO,
              'created_at' => ProductPeer::CREATED_AT,
              'priority' => ProductPeer::PRIORITY,
          ),
      );

      if ($this->hasRequestParameter('query'))
      {
         $cmp = ProductPeer::getSearchSortCriteria($this->getRequestParameter('query'), $this->getUser()->getCulture());

         $defaults['label_names']['accuracy'] = "Trafność";
         $defaults['table_names']['accuracy'] = 'SUM('.ProductHasProductSearchTagPeer::TAG_VALUE.($cmp ? ' * '.implode(" + ", $cmp) : '').')'; 
      }

      $columns = $columns ? array_merge_recursive($defaults, $columns) : $defaults;

      return $type ? $columns[$type] : $columns;
   }

   protected function getViewTypes($type = null, $types = array())
   { 
      if ($this->getTheme()->getVersion() >= 7)
      {

         $defaults = array(
            'label_names' => array(
            'long' => 'Pełna lista',
            'description' => 'Opisowa lista',
            'other' => 'Lista alternatywna',
            ),
            'view_names' => array(
            'long' => 'listLongProduct',
            'description' => 'listDescriptionProduct',
            'other' => 'listOther',
            ),
         );

      }
      else
      {
         $defaults = array(
            'label_names' => array(
            'long' => 'Pełna lista',
            'short' => 'Skrócona lista',
            'other' => 'Lista alternatywna',
            ),
            'view_names' => array(
            'long' => 'listLongProduct',
            'short' => 'listShortProduct',
            'other' => 'listOther',
            ),
         );
      }

      $types = $types ? array_merge_recursive($defaults, $types) : $defaults;

      return $type ? $types[$type] : $types;
   }

   protected function processFilters()
   {
      $default = stProducer::getSelectedProducerId() ? stProducer::getSelectedProducerId() : 0;

      $request = $this->getRequest();

      if ($request->hasParameter('horizontal'))
      {
         stProducer::clearSelectedProducerId();
      }      
      
      if ($this->hasRequestParameter('producer_filter'))
      {
         $producer_filter = $this->getRequestParameter('producer_filter');

         $this->getUser()->setAttribute('producer_filter', $producer_filter, stProductFilter::getNamespace($this->getContext(), 'soteshop/stProduct'));
      }
      elseif (!$request->hasParameter('filter') && $request->getHttpHeader('X-Moz') != 'prefetch')
      {
         $this->getUser()->getAttributeHolder()->remove('producer_filter', stProductFilter::getNamespace($this->getContext(), 'soteshop/stProduct'));
      }

      $this->producer_filter = $this->getUser()->getAttribute('producer_filter', $default, stProductFilter::getNamespace($this->getContext(), 'soteshop/stProduct'));

      if (stProductFilter::hasFilters($this->getContext()) && !$request->hasParameter('filter') && $request->getHttpHeader('X-Moz') != 'prefetch') 
      {
         stProductFilter::clearFilters($this->getContext());
      }
   }

   protected function addProductFilterCriteria($c)
   {
      ProductPeer::addFilterCriteria($this->getContext(), $c, false);
   }   

   protected function addSearchCriteria($c, $query)
   {
      if ($query && mb_strlen($query) >= 3)
      {
         $analyzer = stTextAnalyzer::getInstance($this->getUser()->getCulture());
         $keywords = array_keys($analyzer->analyze($query));

         return ProductPeer::addSearchCriteria($c, $keywords, $this->getUser()->getCulture());
      }
      
      return 0;
   }

   protected function addRelLinks($action, $url)
   {
      sfLoader::loadHelpers(array('Helper', 'stUrl', 'stProduct'), 'stProduct');

      $params = array(
         'url' => $url
      );

      if ($this->hasRequestParameter('producer') && !in_array($action, array('producerList'))  && stProducer::getSelectedProducer())
      {
         $params['producer'] = $this->getRequestParameter('producer');
      }

      $domain = stLanguage::getInstance($this->getContext())->getDomain();

      $page = $this->product_pager->getPage();

      if ($this->product_pager->haveToPaginate())
      {
         $filter = $this->getRequestParameter('filter') ? '?filter=1' : '';
         
         $last_page = $this->product_pager->getLastPage();
        
         if ($page == 2)
         {
            $product_url = _st_product_link_to($action, $params);
            $this->getResponse()->addLink(st_url_for($product_url, true, null, $domain).$filter, "prev");

            if ($last_page != 2)
            {
               $product_url = _st_product_link_to($action, $params, array('page' => $this->product_pager->getNextPage()));
               $this->getResponse()->addLink(st_url_for($product_url, true, null, $domain).$filter, "next");
            }

         }
         elseif ($page > 1 && $page <= $last_page)
         {
            $product_url = _st_product_link_to($action, $params, array('page' => $this->product_pager->getPreviousPage()));
            $this->getResponse()->addLink(st_url_for($product_url, true, null, $domain).$filter, "prev");
         }
         
         if ($page >= 1 && $page < $last_page)
         {
            $product_url = _st_product_link_to($action, $params, array('page' => $this->product_pager->getNextPage()));
            $this->getResponse()->addLink(st_url_for($product_url, true, null, $domain).$filter, "next");
         }
      }

      if ($page > 1)
      {
         $product_url = _st_product_link_to($action, $params, array('page' => $page));
      }
      else
      {
         $product_url = _st_product_link_to($action, $params);
      }

      if ($this->hasRequestParameter('sort_by') || $this->hasRequestParameter('filter'))
      {
         $this->getResponse()->addMeta('robots', "noindex, nofollow");     
      } 
      else
      {
         $this->getResponse()->setCanonicalLink(st_url_for($product_url, true, null, $domain));
      }

      // if (!$this->product_pager->getCntResults())
      // {
      //    $this->getResponse()->setStatusCode(404);
      // }
   }

   protected function renderUpdateFilters()
   {
      $this->loadCategoryFromRequest();

      $c = new Criteria();

      ProductPeer::addFilterCriteria($this->getContext(), $c);

      if (!stConfig::getInstance('stProduct')->get('disable_filter_dependency'))
      {
         $this->addProducerCriteria($c);
      }

      $this->getDispatcher()->notify(new sfEvent($this, 'stProductActions.renderUpdateFiltersCriteria', array('criteria' => $c)));

      if (isset($this->product_group))
      {
         $gc = new Criteria();
         $gc->add(ProductGroupHasProductPeer::PRODUCT_GROUP_ID, $this->product_group->getId());
         if (ProductGroupHasProductPeer::doCount($gc))
         {
            $this->addProductGroup($c);
         }
         else
         {
            $config = stConfig::getInstance('stProduct');
            $c->add(ProductPeer::CREATED_AT, $config->get('new_product_date'), Criteria::GREATER_THAN);            
         }
      }

      return $this->renderText($this->getRenderComponent('stProduct', 'filters', array('criteria' => $c)));      
   }

   protected function loadCategoryFromRequest()
   {
      $category_id = $this->getRequestParameter('category_id');
      $group_id = $this->getRequestParameter('group_id');  

      if ($category_id && !$this->getUser()->getParameter('selected', null, 'soteshop/stCategory'))
      {
         $category = CategoryPeer::retrieveByPK($category_id);

         if ($category)
         {
            $this->getUser()->setParameter('selected', $category, 'soteshop/stCategory');
         }
      } 
      elseif ($group_id && !$this->getUser()->getParameter('selected', null, 'soteshop/stProductGroup'))
      {
         $group = ProductGroupPeer::retrieveByPK($group_id);            
         $this->getUser()->setParameter('selected', $group, 'soteshop/stProductGroup');
         $this->product_group = $group;
      }
   }

   protected function forLinkInit($url, $page)
   {
      $this->for_link = array(
         'type' => $this->type_list_url,
         'sort_by' => $this->sort_by,
         'sort_order' => $this->sort_order,
         'page' => $page,
      );

      $action = $this->getModuleName().'/'.$this->getActionName();

      if ($action != 'stProduct/producerList' && $this->hasRequestParameter('producer')) 
      {
         $this->for_link['producer'] = $this->getRequestParameter('producer');
      }
      elseif ($action != 'stProduct/producerList')
      {
         $this->for_link['producer_filter'] = $this->producer_filter;
      }

      if (null !== $url)
      {
         $this->for_link['url'] = $url;
      }
   }

   protected function getImagesInOptions()
   {
      $results = array();
      
      $c = new Criteria();
      $c->addSelectColumn(ProductOptionsValuePeer::SF_ASSET_ID);
      $c->add(ProductOptionsValuePeer::PRODUCT_ID, $this->product->getId());
      $c->addGroupByColumn(ProductOptionsValuePeer::SF_ASSET_ID);

      $rs = ProductOptionsValuePeer::doSelectRS($c); 

      while($rs->next()) 
      {
         $row = $rs->getRow();
         $results[$row[0]] = $row[0];
      }

      return $results;        
   }

   protected function processSearchQuery()
   {
      $this->query = null;    

      $this->searchLink = null;

      $response = $this->getResponse();
      
      if ($this->hasRequestParameter('query'))
      {
         $query = strip_tags($this->getRequestParameter('query'));
         $this->query = stXssSafe::clean($query);
         $response->addMeta('robots', 'noindex');
      }
      elseif ($this->hasRequestParameter(('query_url')))
      {
         $query_url = $this->getRequestParameter('query_url');
         $this->searchLink = SearchLinkPeer::retrieveByUrl($query_url, $this->getUser()->getCulture());

         if (null !== $this->searchLink)
         {
            $this->getRequest()->setParameter('query', $this->searchLink->getSearchKeywords());
            $this->query = $this->searchLink->getSearchKeywords();

            $response->setTitle($this->searchLink->getMetaTitle());
            $response->addMeta('keywords', $this->searchLink->getMetaKeywords());
            $response->addMeta('description', $this->searchLink->getMetaDescription());
         }
         else
         {
            $this->getRequest()->setParameter('query', $query_url);
            $this->query = stXssSafe::clean($query_url);

            $response->addMeta('robots', 'noindex');
         }
      }
   }
}