1 <?php
  2 /**
  3  * @package     Joomla.Libraries
  4  * @subpackage  Helper
  5  *
  6  * @copyright   Copyright (C) 2005 - 2017 Open Source Matters, Inc. All rights reserved.
  7  * @license     GNU General Public License version 2 or later; see LICENSE.txt
  8  */
  9 
 10 defined('JPATH_PLATFORM') or die;
 11 
 12 /**
 13  * Route Helper
 14  *
 15  * A class providing basic routing for urls that are for content types found in
 16  * the #__content_types table and rows found in the #__ucm_content table.
 17  *
 18  * @since  3.1
 19  */
 20 class JHelperRoute
 21 {
 22     /**
 23      * @var    array  Holds the reverse lookup
 24      * @since  3.1
 25      */
 26     protected static $lookup;
 27 
 28     /**
 29      * @var    string  Option for the extension (such as com_content)
 30      * @since  3.1
 31      */
 32     protected $extension;
 33 
 34     /**
 35      * @var    string  Value of the primary key in the content type table
 36      * @since  3.1
 37      */
 38     protected $id;
 39 
 40     /**
 41      * @var    string  Name of the view for the url
 42      * @since  3.1
 43      */
 44     protected $view;
 45 
 46     /**
 47      * A method to get the route for a specific item
 48      *
 49      * @param   integer  $id         Value of the primary key for the item in its content table
 50      * @param   string   $typealias  The type_alias for the item being routed. Of the form extension.view.
 51      * @param   string   $link       The link to be routed
 52      * @param   string   $language   The language of the content for multilingual sites
 53      * @param   integer  $catid      Optional category id
 54      *
 55      * @return  string  The route of the item
 56      *
 57      * @since   3.1
 58      */
 59     public function getRoute($id, $typealias, $link = '', $language = null, $catid = null)
 60     {
 61         $typeExploded = explode('.', $typealias);
 62 
 63         if (isset($typeExploded[1]))
 64         {
 65             $this->view = $typeExploded[1];
 66             $this->extension = $typeExploded[0];
 67         }
 68         else
 69         {
 70             $this->view = JFactory::getApplication()->input->getString('view');
 71             $this->extension = JFactory::getApplication()->input->getCmd('option');
 72         }
 73 
 74         $name = ucfirst(substr_replace($this->extension, '', 0, 4));
 75 
 76         $needles = array();
 77 
 78         if (isset($this->view))
 79         {
 80             $needles[$this->view] = array((int) $id);
 81         }
 82 
 83         if (empty($link))
 84         {
 85             // Create the link
 86             $link = 'index.php?option=' . $this->extension . '&view=' . $this->view . '&id=' . $id;
 87         }
 88 
 89         if ($catid > 1)
 90         {
 91             $categories = JCategories::getInstance($name);
 92 
 93             if ($categories)
 94             {
 95                 $category = $categories->get((int) $catid);
 96 
 97                 if ($category)
 98                 {
 99                     $needles['category'] = array_reverse($category->getPath());
100                     $needles['categories'] = $needles['category'];
101                     $link .= '&catid=' . $catid;
102                 }
103             }
104         }
105 
106         // Deal with languages only if needed
107         if (!empty($language) && $language !== '*' && JLanguageMultilang::isEnabled())
108         {
109             $link .= '&lang=' . $language;
110             $needles['language'] = $language;
111         }
112 
113         if ($item = $this->findItem($needles))
114         {
115             $link .= '&Itemid=' . $item;
116         }
117 
118         return $link;
119     }
120 
121     /**
122      * Method to find the item in the menu structure
123      *
124      * @param   array  $needles  Array of lookup values
125      *
126      * @return  mixed
127      *
128      * @since   3.1
129      */
130     protected function findItem($needles = array())
131     {
132         $app      = JFactory::getApplication();
133         $menus    = $app->getMenu('site');
134         $language = isset($needles['language']) ? $needles['language'] : '*';
135 
136         // $this->extension may not be set if coming from a static method, check it
137         if ($this->extension === null)
138         {
139             $this->extension = $app->input->getCmd('option');
140         }
141 
142         // Prepare the reverse lookup array.
143         if (!isset(static::$lookup[$language]))
144         {
145             static::$lookup[$language] = array();
146 
147             $component = JComponentHelper::getComponent($this->extension);
148 
149             $attributes = array('component_id');
150             $values     = array($component->id);
151 
152             if ($language !== '*')
153             {
154                 $attributes[] = 'language';
155                 $values[]     = array($needles['language'], '*');
156             }
157 
158             $items = $menus->getItems($attributes, $values);
159 
160             foreach ($items as $item)
161             {
162                 if (isset($item->query) && isset($item->query['view']))
163                 {
164                     $view = $item->query['view'];
165 
166                     if (!isset(static::$lookup[$language][$view]))
167                     {
168                         static::$lookup[$language][$view] = array();
169                     }
170 
171                     if (isset($item->query['id']))
172                     {
173                         if (is_array($item->query['id']))
174                         {
175                             $item->query['id'] = $item->query['id'][0];
176                         }
177 
178                         /*
179                          * Here it will become a bit tricky
180                          * $language != * can override existing entries
181                          * $language == * cannot override existing entries
182                          */
183                         if ($item->language !== '*' || !isset(static::$lookup[$language][$view][$item->query['id']]))
184                         {
185                             static::$lookup[$language][$view][$item->query['id']] = $item->id;
186                         }
187                     }
188                 }
189             }
190         }
191 
192         if ($needles)
193         {
194             foreach ($needles as $view => $ids)
195             {
196                 if (isset(static::$lookup[$language][$view]))
197                 {
198                     foreach ($ids as $id)
199                     {
200                         if (isset(static::$lookup[$language][$view][(int) $id]))
201                         {
202                             return static::$lookup[$language][$view][(int) $id];
203                         }
204                     }
205                 }
206             }
207         }
208 
209         $active = $menus->getActive();
210 
211         if ($active && $active->component === $this->extension && ($active->language === '*' || !JLanguageMultilang::isEnabled()))
212         {
213             return $active->id;
214         }
215 
216         // If not found, return language specific home link
217         $default = $menus->getDefault($language);
218 
219         return !empty($default->id) ? $default->id : null;
220     }
221 
222     /**
223      * Fetches the category route
224      *
225      * @param   mixed   $catid      Category ID or JCategoryNode instance
226      * @param   mixed   $language   Language code
227      * @param   string  $extension  Extension to lookup
228      *
229      * @return  string
230      *
231      * @since   3.2
232      *
233      * @throws  InvalidArgumentException
234      */
235     public static function getCategoryRoute($catid, $language = 0, $extension = '')
236     {
237         // Note: $extension is required but has to be an optional argument in the function call due to argument order
238         if (empty($extension))
239         {
240             throw new InvalidArgumentException('$extension is a required argument in JHelperRoute::getCategoryRoute');
241         }
242 
243         if ($catid instanceof JCategoryNode)
244         {
245             $id       = $catid->id;
246             $category = $catid;
247         }
248         else
249         {
250             $extensionName = ucfirst(substr($extension, 4));
251             $id            = (int) $catid;
252             $category      = JCategories::getInstance($extensionName)->get($id);
253         }
254 
255         if ($id < 1)
256         {
257             $link = '';
258         }
259         else
260         {
261             $link = 'index.php?option=' . $extension . '&view=category&id=' . $id;
262 
263             $needles = array(
264                 'category' => array($id),
265             );
266 
267             if ($language && $language !== '*' && JLanguageMultilang::isEnabled())
268             {
269                 $link .= '&lang=' . $language;
270                 $needles['language'] = $language;
271             }
272 
273             // Create the link
274             if ($category)
275             {
276                 $catids                = array_reverse($category->getPath());
277                 $needles['category']   = $catids;
278                 $needles['categories'] = $catids;
279 
280             }
281 
282             if ($item = static::lookupItem($needles))
283             {
284                 $link .= '&Itemid=' . $item;
285             }
286         }
287 
288         return $link;
289     }
290 
291     /**
292      * Static alias to findItem() used to find the item in the menu structure
293      *
294      * @param   array  $needles  Array of lookup values
295      *
296      * @return  mixed
297      *
298      * @since   3.2
299      */
300     protected static function lookupItem($needles = array())
301     {
302         $instance = new static;
303 
304         return $instance->findItem($needles);
305     }
306 }
307 

Joomla! Framework TM API documentation generated by ApiGen 2.8.0
Joomla!® and Joomla! Framework™ are trademarks of Open Source Matters, Inc. in the United States and other countries.