Source for file categories.php

Documentation is available at categories.php

  1. <?php
  2. /**
  3.  * @package     Joomla.Plugin
  4.  * @subpackage  Finder.Categories
  5.  *
  6.  * @copyright   Copyright (C) 2005 - 2013 Open Source Matters, Inc. All rights reserved.
  7.  * @license     GNU General Public License version 2 or later; see LICENSE
  8.  */
  9.  
  10. defined('JPATH_BASE') or die;
  11.  
  12. require_once JPATH_ADMINISTRATOR . '/components/com_finder/helpers/indexer/adapter.php';
  13.  
  14. /**
  15.  * Finder adapter for Joomla Categories.
  16.  *
  17.  * @package     Joomla.Plugin
  18.  * @subpackage  Finder.Categories
  19.  * @since       2.5
  20.  */
  21. class PlgFinderCategories extends FinderIndexerAdapter
  22. {
  23.     /**
  24.      * The plugin identifier.
  25.      *
  26.      * @var    string 
  27.      * @since  2.5
  28.      */
  29.     protected $context = 'Categories';
  30.  
  31.     /**
  32.      * The extension name.
  33.      *
  34.      * @var    string 
  35.      * @since  2.5
  36.      */
  37.     protected $extension = 'com_categories';
  38.  
  39.     /**
  40.      * The sublayout to use when rendering the results.
  41.      *
  42.      * @var    string 
  43.      * @since  2.5
  44.      */
  45.     protected $layout = 'category';
  46.  
  47.     /**
  48.      * The type of content that the adapter indexes.
  49.      *
  50.      * @var    string 
  51.      * @since  2.5
  52.      */
  53.     protected $type_title = 'Category';
  54.  
  55.     /**
  56.      * The table name.
  57.      *
  58.      * @var    string 
  59.      * @since  2.5
  60.      */
  61.     protected $table = '#__categories';
  62.  
  63.     /**
  64.      * The field the published state is stored in.
  65.      *
  66.      * @var    string 
  67.      * @since  2.5
  68.      */
  69.     protected $state_field = 'published';
  70.  
  71.     /**
  72.      * Load the language file on instantiation.
  73.      *
  74.      * @var    boolean 
  75.      * @since  3.1
  76.      */
  77.     protected $autoloadLanguage = true;
  78.  
  79.     /**
  80.      * Method to remove the link information for items that have been deleted.
  81.      *
  82.      * @param   string  $context  The context of the action being performed.
  83.      * @param   JTable  $table    A JTable object containing the record to be deleted
  84.      *
  85.      * @return  boolean  True on success.
  86.      *
  87.      * @since   2.5
  88.      * @throws  Exception on database error.
  89.      */
  90.     public function onFinderDelete($context, $table)
  91.     {
  92.         if ($context == 'com_categories.category')
  93.         {
  94.             $id = $table->id;
  95.         }
  96.         elseif ($context == 'com_finder.index')
  97.         {
  98.             $id = $table->link_id;
  99.         }
  100.         else
  101.         {
  102.             return true;
  103.         }
  104.         // Remove the items.
  105.         return $this->remove($id);
  106.     }
  107.  
  108.     /**
  109.      * Method to determine if the access level of an item changed.
  110.      *
  111.      * @param   string   $context  The context of the content passed to the plugin.
  112.      * @param   JTable   $row      A JTable object
  113.      * @param   boolean  $isNew    If the content has just been created
  114.      *
  115.      * @return  boolean  True on success.
  116.      *
  117.      * @since   2.5
  118.      * @throws  Exception on database error.
  119.      */
  120.     public function onFinderAfterSave($context, $row, $isNew)
  121.     {
  122.         // We only want to handle categories here
  123.         if ($context == 'com_categories.category')
  124.         {
  125.             // Check if the access levels are different
  126.             if (!$isNew && $this->old_access != $row->access)
  127.             {
  128.                 // Process the change.
  129.                 $this->itemAccessChange($row);
  130.  
  131.                 // Reindex the item
  132.                 $this->reindex($row->id);
  133.             }
  134.  
  135.             // Check if the parent access level is different
  136.             if (!$isNew && $this->old_cataccess != $row->access)
  137.             {
  138.                 $this->categoryAccessChange($row);
  139.             }
  140.  
  141.         }
  142.         return true;
  143.     }
  144.  
  145.     /**
  146.      * Method to reindex the link information for an item that has been saved.
  147.      * This event is fired before the data is actually saved so we are going
  148.      * to queue the item to be indexed later.
  149.      *
  150.      * @param   string   $context  The context of the content passed to the plugin.
  151.      * @param   JTable   $row     A JTable object
  152.      * @param   boolean  $isNew    If the content is just about to be created
  153.      *
  154.      * @return  boolean  True on success.
  155.      *
  156.      * @since   2.5
  157.      * @throws  Exception on database error.
  158.      */
  159.     public function onFinderBeforeSave($context, $row, $isNew)
  160.     {
  161.         // We only want to handle categories here
  162.         if ($context == 'com_categories.category')
  163.         {
  164.             // Query the database for the old access level and the parent if the item isn't new
  165.             if (!$isNew)
  166.             {
  167.                 $this->checkItemAccess($row);
  168.                 $this->checkCategoryAccess($row);
  169.             }
  170.         }
  171.  
  172.         return true;
  173.     }
  174.  
  175.     /**
  176.      * Method to update the link information for items that have been changed
  177.      * from outside the edit screen. This is fired when the item is published,
  178.      * unpublished, archived, or unarchived from the list view.
  179.      *
  180.      * @param   string   $context  The context for the content passed to the plugin.
  181.      * @param   array    $pks      A list of primary key ids of the content that has changed state.
  182.      * @param   integer  $value    The value of the state that the content has been changed to.
  183.      *
  184.      * @return  void 
  185.      *
  186.      * @since   2.5
  187.      */
  188.     public function onFinderChangeState($context, $pks, $value)
  189.     {
  190.         // We only want to handle categories here
  191.         if ($context == 'com_categories.category')
  192.         {
  193.             // The category published state is tied to the parent category
  194.             // published state so we need to look up all published states
  195.             // before we change anything.
  196.             foreach ($pks as $pk)
  197.             {
  198.                 /* TODO: The $item variable does not seem to be used at all
  199.                 $query = clone($this->getStateQuery());
  200.                 $query->where('a.id = ' . (int) $pk);
  201.  
  202.                 // Get the published states.
  203.                 $this->db->setQuery($query);
  204.                 $item = $this->db->loadObject();
  205.                 */
  206.  
  207.                 // Translate the state.
  208.                 $state = null;
  209.  
  210.                 if ($item->parent_id != 1)
  211.                 {
  212.                     $state = $item->cat_state;
  213.                 }
  214.  
  215.                 $temp = $this->translateState($value, $state);
  216.  
  217.                 // Update the item.
  218.                 $this->change($pk, 'state', $temp);
  219.  
  220.                 // Reindex the item
  221.                 $this->reindex($pk);
  222.             }
  223.         }
  224.  
  225.         // Handle when the plugin is disabled
  226.         if ($context == 'com_plugins.plugin' && $value === 0)
  227.         {
  228.             $this->pluginDisable($pks);
  229.         }
  230.     }
  231.  
  232.     /**
  233.      * Method to index an item. The item must be a FinderIndexerResult object.
  234.      *
  235.      * @param   FinderIndexerResult  $item    The item to index as an FinderIndexerResult object.
  236.      * @param   string               $format  The item format
  237.      *
  238.      * @return  void 
  239.      *
  240.      * @since   2.5
  241.      * @throws  Exception on database error.
  242.      */
  243.     protected function index(FinderIndexerResult $item, $format = 'html')
  244.     {
  245.         // Check if the extension is enabled
  246.         if (JComponentHelper::isEnabled($this->extension) == false)
  247.         {
  248.             return;
  249.         }
  250.  
  251.         $item->setLanguage();
  252.  
  253.         // Need to import component route helpers dynamically, hence the reason it's handled here
  254.         $path = JPATH_SITE . '/components/' . $item->extension . '/helpers/route.php';
  255.         if (is_file($path))
  256.         {
  257.             include_once $path;
  258.         }
  259.  
  260.         $extension = ucfirst(substr($item->extension, 4));
  261.  
  262.         // Initialize the item parameters.
  263.         $registry = new JRegistry;
  264.         $registry->loadString($item->params);
  265.         $item->params = $registry;
  266.  
  267.         $registry = new JRegistry;
  268.         $registry->loadString($item->metadata);
  269.         $item->metadata = $registry;
  270.  
  271.         /* Add the meta-data processing instructions based on the categories
  272.          * configuration parameters.
  273.          */
  274.         // Add the meta-author.
  275.         $item->metaauthor = $item->metadata->get('author');
  276.  
  277.         // Handle the link to the meta-data.
  278.         $item->addInstruction(FinderIndexer::META_CONTEXT, 'link');
  279.         $item->addInstruction(FinderIndexer::META_CONTEXT, 'metakey');
  280.         $item->addInstruction(FinderIndexer::META_CONTEXT, 'metadesc');
  281.         $item->addInstruction(FinderIndexer::META_CONTEXT, 'metaauthor');
  282.         $item->addInstruction(FinderIndexer::META_CONTEXT, 'author');
  283.         //$item->addInstruction(FinderIndexer::META_CONTEXT, 'created_by_alias');
  284.  
  285.         // Trigger the onContentPrepare event.
  286.         $item->summary = FinderIndexerHelper::prepareContent($item->summary, $item->params);
  287.  
  288.         // Build the necessary route and path information.
  289.         $item->url = $this->getURL($item->id, $item->extension, $this->layout);
  290.  
  291.         $class = $extension . 'HelperRoute';
  292.         if (class_exists($class) && method_exists($class, 'getCategoryRoute'))
  293.         {
  294.             $item->route = $class::getCategoryRoute($item->id);
  295.         }
  296.         else
  297.         {
  298.             $item->route = ContentHelperRoute::getCategoryRoute($item->slug, $item->catid);
  299.         }
  300.         $item->path = FinderIndexerHelper::getContentPath($item->route);
  301.  
  302.         // Get the menu title if it exists.
  303.         $title = $this->getItemMenuTitle($item->url);
  304.  
  305.         // Adjust the title if necessary.
  306.         if (!empty($title) && $this->params->get('use_menu_title', true))
  307.         {
  308.             $item->title = $title;
  309.         }
  310.  
  311.         // Translate the state. Categories should only be published if the parent category is published.
  312.         $item->state = $this->translateState($item->state);
  313.  
  314.         // Add the type taxonomy data.
  315.         $item->addTaxonomy('Type', 'Category');
  316.  
  317.         // Add the language taxonomy data.
  318.         $item->addTaxonomy('Language', $item->language);
  319.  
  320.         // Get content extras.
  321.         FinderIndexerHelper::getContentExtras($item);
  322.  
  323.         // Index the item.
  324.         $this->indexer->index($item);
  325.     }
  326.  
  327.     /**
  328.      * Method to setup the indexer to be run.
  329.      *
  330.      * @return  boolean  True on success.
  331.      *
  332.      * @since   2.5
  333.      */
  334.     protected function setup()
  335.     {
  336.         // Load com_content route helper as it is the fallback for routing in the indexer in this instance.
  337.         include_once JPATH_SITE . '/components/com_content/helpers/route.php';
  338.  
  339.         return true;
  340.     }
  341.  
  342.     /**
  343.      * Method to get the SQL query used to retrieve the list of content items.
  344.      *
  345.      * @param   mixed  $query  A JDatabaseQuery object or null.
  346.      *
  347.      * @return  JDatabaseQuery  A database object.
  348.      *
  349.      * @since   2.5
  350.      */
  351.     protected function getListQuery($query = null)
  352.     {
  353.         $db = JFactory::getDbo();
  354.         // Check if we can use the supplied SQL query.
  355.         $query = $query instanceof JDatabaseQuery ? $query : $db->getQuery(true)
  356.             ->select('a.id, a.title, a.alias, a.description AS summary, a.extension')
  357.             ->select('a.created_user_id AS created_by, a.modified_time AS modified, a.modified_user_id AS modified_by')
  358.             ->select('a.metakey, a.metadesc, a.metadata, a.language, a.lft, a.parent_id, a.level')
  359.             ->select('a.created_time AS start_date, a.published AS state, a.access, a.params');
  360.  
  361.         // Handle the alias CASE WHEN portion of the query
  362.         $case_when_item_alias = ' CASE WHEN ';
  363.         $case_when_item_alias .= $query->charLength('a.alias', '!=', '0');
  364.         $case_when_item_alias .= ' THEN ';
  365.         $a_id = $query->castAsChar('a.id');
  366.         $case_when_item_alias .= $query->concatenate(array($a_id, 'a.alias'), ':');
  367.         $case_when_item_alias .= ' ELSE ';
  368.         $case_when_item_alias .= $a_id.' END as slug';
  369.         $query->select($case_when_item_alias)
  370.             ->from('#__categories AS a')
  371.             ->where($db->quoteName('a.id') . ' > 1');
  372.  
  373.         return $query;
  374.     }
  375.  
  376.     /**
  377.      * Method to get a SQL query to load the published and access states for
  378.      * an article and category.
  379.      *
  380.      * @return  JDatabaseQuery  A database object.
  381.      *
  382.      * @since   2.5
  383.      */
  384.     protected function getStateQuery()
  385.     {
  386.         $query = $this->db->getQuery(true)
  387.             ->select($this->db->quoteName('a.id'))
  388.             ->select('a.' . $this->state_field . ' AS state, c.published AS cat_state')
  389.             ->select('a.access, c.access AS cat_access')
  390.             ->from($this->db->quoteName('#__categories') . ' AS a')
  391.             ->join('LEFT', '#__categories AS c ON c.id = a.parent_id');
  392.  
  393.         return $query;
  394.     }
  395. }

Documentation generated on Tue, 19 Nov 2013 14:55:11 +0100 by phpDocumentor 1.4.3