Source for file taxonomy.php

Documentation is available at taxonomy.php

  1. <?php
  2. /**
  3.  * @package     Joomla.Administrator
  4.  * @subpackage  com_finder
  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('_JEXEC') or die;
  11.  
  12. /**
  13.  * Stemmer base class for the Finder indexer package.
  14.  *
  15.  * @package     Joomla.Administrator
  16.  * @subpackage  com_finder
  17.  * @since       2.5
  18.  */
  19. class FinderIndexerTaxonomy
  20. {
  21.     /**
  22.      * An internal cache of taxonomy branch data.
  23.      *
  24.      * @var    array 
  25.      * @since  2.5
  26.      */
  27.     public static $branches = array();
  28.  
  29.     /**
  30.      * An internal cache of taxonomy node data.
  31.      *
  32.      * @var    array 
  33.      * @since  2.5
  34.      */
  35.     public static $nodes = array();
  36.  
  37.     /**
  38.      * Method to add a branch to the taxonomy tree.
  39.      *
  40.      * @param   string   $title   The title of the branch.
  41.      * @param   integer  $state   The published state of the branch. [optional]
  42.      * @param   integer  $access  The access state of the branch. [optional]
  43.      *
  44.      * @return  integer  The id of the branch.
  45.      *
  46.      * @since   2.5
  47.      * @throws  Exception on database error.
  48.      */
  49.     public static function addBranch($title, $state = 1, $access = 1)
  50.     {
  51.         // Check to see if the branch is in the cache.
  52.         if (isset(self::$branches[$title]))
  53.         {
  54.             return self::$branches[$title]->id;
  55.         }
  56.  
  57.         // Check to see if the branch is in the table.
  58.         $db = JFactory::getDbo();
  59.         $query = $db->getQuery(true)
  60.             ->select('*')
  61.             ->from($db->quoteName('#__finder_taxonomy'))
  62.             ->where($db->quoteName('parent_id') . ' = 1')
  63.             ->where($db->quoteName('title') . ' = ' . $db->quote($title));
  64.         $db->setQuery($query);
  65.  
  66.         // Get the result.
  67.         $result = $db->loadObject();
  68.  
  69.         // Check if the database matches the input data.
  70.         if (!empty($result) && $result->state == $state && $result->access == $access)
  71.         {
  72.             // The data matches, add the item to the cache.
  73.             self::$branches[$title] = $result;
  74.  
  75.             return self::$branches[$title]->id;
  76.         }
  77.  
  78.         /*
  79.          * The database did not match the input. This could be because the
  80.          * state has changed or because the branch does not exist. Let's figure
  81.          * out which case is true and deal with it.
  82.          */
  83.         $branch = new JObject;
  84.         if (empty($result))
  85.         {
  86.             // Prepare the branch object.
  87.             $branch->parent_id = 1;
  88.             $branch->title = $title;
  89.             $branch->state = (int) $state;
  90.             $branch->access = (int) $access;
  91.         }
  92.         else
  93.         {
  94.             // Prepare the branch object.
  95.             $branch->id = (int) $result->id;
  96.             $branch->parent_id = (int) $result->parent_id;
  97.             $branch->title = $result->title;
  98.             $branch->state = (int) $result->title;
  99.             $branch->access = (int) $result->access;
  100.             $branch->ordering = (int) $result->ordering;
  101.         }
  102.  
  103.         // Store the branch.
  104.         self::storeNode($branch);
  105.  
  106.         // Add the branch to the cache.
  107.         self::$branches[$title] = $branch;
  108.  
  109.         return self::$branches[$title]->id;
  110.     }
  111.  
  112.     /**
  113.      * Method to add a node to the taxonomy tree.
  114.      *
  115.      * @param   string   $branch  The title of the branch to store the node in.
  116.      * @param   string   $title   The title of the node.
  117.      * @param   integer  $state   The published state of the node. [optional]
  118.      * @param   integer  $access  The access state of the node. [optional]
  119.      *
  120.      * @return  integer  The id of the node.
  121.      *
  122.      * @since   2.5
  123.      * @throws  Exception on database error.
  124.      */
  125.     public static function addNode($branch, $title, $state = 1, $access = 1)
  126.     {
  127.         // Check to see if the node is in the cache.
  128.         if (isset(self::$nodes[$branch][$title]))
  129.         {
  130.             return self::$nodes[$branch][$title]->id;
  131.         }
  132.  
  133.         // Get the branch id, insert it if it does not exist.
  134.         $branchId = self::addBranch($branch);
  135.  
  136.         // Check to see if the node is in the table.
  137.         $db = JFactory::getDbo();
  138.         $query = $db->getQuery(true)
  139.             ->select('*')
  140.             ->from($db->quoteName('#__finder_taxonomy'))
  141.             ->where($db->quoteName('parent_id') . ' = ' . $db->quote($branchId))
  142.             ->where($db->quoteName('title') . ' = ' . $db->quote($title));
  143.         $db->setQuery($query);
  144.  
  145.         // Get the result.
  146.         $result = $db->loadObject();
  147.  
  148.         // Check if the database matches the input data.
  149.         if (!empty($result) && $result->state == $state && $result->access == $access)
  150.         {
  151.             // The data matches, add the item to the cache.
  152.             self::$nodes[$branch][$title] = $result;
  153.  
  154.             return self::$nodes[$branch][$title]->id;
  155.         }
  156.  
  157.         /*
  158.          * The database did not match the input. This could be because the
  159.          * state has changed or because the node does not exist. Let's figure
  160.          * out which case is true and deal with it.
  161.          */
  162.         $node = new JObject;
  163.         if (empty($result))
  164.         {
  165.             // Prepare the node object.
  166.             $node->parent_id = (int) $branchId;
  167.             $node->title = $title;
  168.             $node->state = (int) $state;
  169.             $node->access = (int) $access;
  170.         }
  171.         else
  172.         {
  173.             // Prepare the node object.
  174.             $node->id = (int) $result->id;
  175.             $node->parent_id = (int) $result->parent_id;
  176.             $node->title = $result->title;
  177.             $node->state = (int) $result->title;
  178.             $node->access = (int) $result->access;
  179.             $node->ordering = (int) $result->ordering;
  180.         }
  181.  
  182.         // Store the node.
  183.         self::storeNode($node);
  184.  
  185.         // Add the node to the cache.
  186.         self::$nodes[$branch][$title] = $node;
  187.  
  188.         return self::$nodes[$branch][$title]->id;
  189.     }
  190.  
  191.     /**
  192.      * Method to add a map entry between a link and a taxonomy node.
  193.      *
  194.      * @param   integer  $linkId  The link to map to.
  195.      * @param   integer  $nodeId  The node to map to.
  196.      *
  197.      * @return  boolean  True on success.
  198.      *
  199.      * @since   2.5
  200.      * @throws  Exception on database error.
  201.      */
  202.     public static function addMap($linkId, $nodeId)
  203.     {
  204.         // Insert the map.
  205.         $db = JFactory::getDbo();
  206.  
  207.         $query = $db->getQuery(true)
  208.             ->select($db->quoteName('link_id'))
  209.             ->from($db->quoteName('#__finder_taxonomy_map'))
  210.             ->where($db->quoteName('link_id') . ' = ' . (int) $linkId)
  211.             ->where($db->quoteName('node_id') . ' = ' . (int) $nodeId);
  212.         $db->setQuery($query);
  213.         $db->execute();
  214.         $id = (int) $db->loadResult();
  215.  
  216.         $map = new JObject;
  217.         $map->link_id = (int) $linkId;
  218.         $map->node_id = (int) $nodeId;
  219.  
  220.         if ($id)
  221.         {
  222.             $db->updateObject('#__finder_taxonomy_map', $map, array('link_id', 'node_id'));
  223.         }
  224.         else
  225.         {
  226.             $db->insertObject('#__finder_taxonomy_map', $map);
  227.         }
  228.  
  229.         return true;
  230.     }
  231.  
  232.     /**
  233.      * Method to get the title of all taxonomy branches.
  234.      *
  235.      * @return  array  An array of branch titles.
  236.      *
  237.      * @since   2.5
  238.      * @throws  Exception on database error.
  239.      */
  240.     public static function getBranchTitles()
  241.     {
  242.         $db = JFactory::getDbo();
  243.  
  244.         // Set user variables
  245.         $user = JFactory::getUser();
  246.         $groups = implode(',', $user->getAuthorisedViewLevels());
  247.  
  248.         // Create a query to get the taxonomy branch titles.
  249.         $query = $db->getQuery(true)
  250.             ->select($db->quoteName('title'))
  251.             ->from($db->quoteName('#__finder_taxonomy'))
  252.             ->where($db->quoteName('parent_id') . ' = 1')
  253.             ->where($db->quoteName('state') . ' = 1')
  254.             ->where($db->quoteName('access') . ' IN (' . $groups . ')');
  255.  
  256.         // Get the branch titles.
  257.         $db->setQuery($query);
  258.         $results = $db->loadColumn();
  259.  
  260.         return $results;
  261.     }
  262.  
  263.     /**
  264.      * Method to find a taxonomy node in a branch.
  265.      *
  266.      * @param   string  $branch  The branch to search.
  267.      * @param   string  $title   The title of the node.
  268.      *
  269.      * @return  mixed  Integer id on success, null on no match.
  270.      *
  271.      * @since   2.5
  272.      * @throws  Exception on database error.
  273.      */
  274.     public static function getNodeByTitle($branch, $title)
  275.     {
  276.         $db = JFactory::getDbo();
  277.  
  278.         // Set user variables
  279.         $user = JFactory::getUser();
  280.         $groups = implode(',', $user->getAuthorisedViewLevels());
  281.  
  282.         // Create a query to get the node.
  283.         $query = $db->getQuery(true)
  284.             ->select('t1.*')
  285.             ->from($db->quoteName('#__finder_taxonomy') . ' AS t1')
  286.             ->join('INNER', $db->quoteName('#__finder_taxonomy') . ' AS t2 ON t2.id = t1.parent_id')
  287.             ->where('t1.access IN (' . $groups . ')')
  288.             ->where('t1.state = 1')
  289.             ->where('t1.title LIKE ' . $db->quote($db->escape($title) . '%'))
  290.             ->where('t2.access IN (' . $groups . ')')
  291.             ->where('t2.state = 1')
  292.             ->where('t2.title = ' . $db->quote($branch));
  293.  
  294.         // Get the node.
  295.         $db->setQuery($query, 0, 1);
  296.         $result = $db->loadObject();
  297.  
  298.         return $result;
  299.     }
  300.  
  301.     /**
  302.      * Method to remove map entries for a link.
  303.      *
  304.      * @param   integer  $linkId  The link to remove.
  305.      *
  306.      * @return  boolean  True on success.
  307.      *
  308.      * @since   2.5
  309.      * @throws  Exception on database error.
  310.      */
  311.     public static function removeMaps($linkId)
  312.     {
  313.         // Delete the maps.
  314.         $db = JFactory::getDbo();
  315.         $query = $db->getQuery(true)
  316.             ->delete($db->quoteName('#__finder_taxonomy_map'))
  317.             ->where($db->quoteName('link_id') . ' = ' . (int) $linkId);
  318.         $db->setQuery($query);
  319.         $db->execute();
  320.  
  321.         return true;
  322.     }
  323.  
  324.     /**
  325.      * Method to remove orphaned taxonomy nodes and branches.
  326.      *
  327.      * @return  integer  The number of deleted rows.
  328.      *
  329.      * @since   2.5
  330.      * @throws  Exception on database error.
  331.      */
  332.     public static function removeOrphanNodes()
  333.     {
  334.         // Delete all orphaned nodes.
  335.         $db = JFactory::getDbo();
  336.         $query = 'DELETE t' .
  337.             ' FROM ' . $db->quoteName('#__finder_taxonomy') . ' AS t' .
  338.             ' LEFT JOIN ' . $db->quoteName('#__finder_taxonomy_map') . ' AS m ON m.node_id = t.id' .
  339.             ' WHERE t.parent_id > 1' .
  340.             ' AND m.link_id IS NULL';
  341.         $db->setQuery($query);
  342.         $db->execute();
  343.  
  344.         return $db->getAffectedRows();
  345.     }
  346.  
  347.     /**
  348.      * Method to store a node to the database.  This method will accept either a branch or a node.
  349.      *
  350.      * @param   object  $item  The item to store.
  351.      *
  352.      * @return  boolean  True on success.
  353.      *
  354.      * @since   2.5
  355.      * @throws  Exception on database error.
  356.      */
  357.     protected static function storeNode($item)
  358.     {
  359.         $db = JFactory::getDbo();
  360.  
  361.         // Check if we are updating or inserting the item.
  362.         if (empty($item->id))
  363.         {
  364.             // Insert the item.
  365.             $db->insertObject('#__finder_taxonomy', $item, 'id');
  366.         }
  367.         else
  368.         {
  369.             // Update the item.
  370.             $db->updateObject('#__finder_taxonomy', $item, 'id');
  371.         }
  372.  
  373.         return true;
  374.     }
  375. }

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