Source for file content.php

Documentation is available at content.php

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

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