Source for file tags.php

Documentation is available at tags.php

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

Documentation generated on Tue, 19 Nov 2013 15:15:16 +0100 by phpDocumentor 1.4.3