1 <?php
  2 /**
  3  * @package     Joomla.Libraries
  4  * @subpackage  Application
  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 use Joomla\Registry\Registry;
 13 
 14 /**
 15  * Joomla! Administrator Application class
 16  *
 17  * @since  3.2
 18  */
 19 class JApplicationAdministrator extends JApplicationCms
 20 {
 21     /**
 22      * Class constructor.
 23      *
 24      * @param   JInput                 $input   An optional argument to provide dependency injection for the application's
 25      *                                          input object.  If the argument is a JInput object that object will become
 26      *                                          the application's input object, otherwise a default input object is created.
 27      * @param   Registry               $config  An optional argument to provide dependency injection for the application's
 28      *                                          config object.  If the argument is a Registry object that object will become
 29      *                                          the application's config object, otherwise a default config object is created.
 30      * @param   JApplicationWebClient  $client  An optional argument to provide dependency injection for the application's
 31      *                                          client object.  If the argument is a JApplicationWebClient object that object will become
 32      *                                          the application's client object, otherwise a default client object is created.
 33      *
 34      * @since   3.2
 35      */
 36     public function __construct(JInput $input = null, Registry $config = null, JApplicationWebClient $client = null)
 37     {
 38         // Register the application name
 39         $this->_name = 'administrator';
 40 
 41         // Register the client ID
 42         $this->_clientId = 1;
 43 
 44         // Execute the parent constructor
 45         parent::__construct($input, $config, $client);
 46 
 47         // Set the root in the URI based on the application name
 48         JUri::root(null, rtrim(dirname(JUri::base(true)), '/\\'));
 49     }
 50 
 51     /**
 52      * Dispatch the application
 53      *
 54      * @param   string  $component  The component which is being rendered.
 55      *
 56      * @return  void
 57      *
 58      * @since   3.2
 59      */
 60     public function dispatch($component = null)
 61     {
 62         if ($component === null)
 63         {
 64             $component = JAdministratorHelper::findOption();
 65         }
 66 
 67         // Load the document to the API
 68         $this->loadDocument();
 69 
 70         // Set up the params
 71         $document = JFactory::getDocument();
 72 
 73         // Register the document object with JFactory
 74         JFactory::$document = $document;
 75 
 76         switch ($document->getType())
 77         {
 78             case 'html':
 79                 $document->setMetaData('keywords', $this->get('MetaKeys'));
 80 
 81                 // Get the template
 82                 $template = $this->getTemplate(true);
 83 
 84                 // Store the template and its params to the config
 85                 $this->set('theme', $template->template);
 86                 $this->set('themeParams', $template->params);
 87 
 88                 break;
 89 
 90             default:
 91                 break;
 92         }
 93 
 94         $document->setTitle($this->get('sitename') . ' - ' . JText::_('JADMINISTRATION'));
 95         $document->setDescription($this->get('MetaDesc'));
 96         $document->setGenerator('Joomla! - Open Source Content Management');
 97 
 98         $contents = JComponentHelper::renderComponent($component);
 99         $document->setBuffer($contents, 'component');
100 
101         // Trigger the onAfterDispatch event.
102         JPluginHelper::importPlugin('system');
103         $this->triggerEvent('onAfterDispatch');
104     }
105 
106     /**
107      * Method to run the Web application routines.
108      *
109      * @return  void
110      *
111      * @since   3.2
112      */
113     protected function doExecute()
114     {
115         // Get the language from the (login) form or user state
116         $login_lang = ($this->input->get('option') == 'com_login') ? $this->input->get('lang') : '';
117         $options    = array('language' => $login_lang ?: $this->getUserState('application.lang'));
118 
119         // Initialise the application
120         $this->initialiseApp($options);
121 
122         // Test for magic quotes
123         if (get_magic_quotes_gpc())
124         {
125             $lang = $this->getLanguage();
126 
127             if ($lang->hasKey('JERROR_MAGIC_QUOTES'))
128             {
129                 $this->enqueueMessage(JText::_('JERROR_MAGIC_QUOTES'), 'error');
130             }
131             else
132             {
133                 $this->enqueueMessage('Your host needs to disable magic_quotes_gpc to run this version of Joomla!', 'error');
134             }
135         }
136 
137         // Mark afterInitialise in the profiler.
138         JDEBUG ? $this->profiler->mark('afterInitialise') : null;
139 
140         // Route the application
141         $this->route();
142 
143         // Mark afterRoute in the profiler.
144         JDEBUG ? $this->profiler->mark('afterRoute') : null;
145 
146         /*
147          * Check if the user is required to reset their password
148          *
149          * Before $this->route(); "option" and "view" can't be safely read using:
150          * $this->input->getCmd('option'); or $this->input->getCmd('view');
151          * ex: due of the sef urls
152          */
153         $this->checkUserRequireReset('com_admin', 'profile', 'edit', 'com_admin/profile.save,com_admin/profile.apply,com_login/logout');
154 
155         // Dispatch the application
156         $this->dispatch();
157 
158         // Mark afterDispatch in the profiler.
159         JDEBUG ? $this->profiler->mark('afterDispatch') : null;
160     }
161 
162     /**
163      * Return a reference to the JRouter object.
164      *
165      * @param   string  $name     The name of the application.
166      * @param   array   $options  An optional associative array of configuration settings.
167      *
168      * @return  JRouter
169      *
170      * @since   3.2
171      */
172     public static function getRouter($name = 'administrator', array $options = array())
173     {
174         return parent::getRouter($name, $options);
175     }
176 
177     /**
178      * Gets the name of the current template.
179      *
180      * @param   boolean  $params  True to return the template parameters
181      *
182      * @return  string  The name of the template.
183      *
184      * @since   3.2
185      * @throws  InvalidArgumentException
186      */
187     public function getTemplate($params = false)
188     {
189         if (is_object($this->template))
190         {
191             if ($params)
192             {
193                 return $this->template;
194             }
195 
196             return $this->template->template;
197         }
198 
199         $admin_style = JFactory::getUser()->getParam('admin_style');
200 
201         // Load the template name from the database
202         $db = JFactory::getDbo();
203         $query = $db->getQuery(true)
204             ->select('template, s.params')
205             ->from('#__template_styles as s')
206             ->join('LEFT', '#__extensions as e ON e.type=' . $db->quote('template') . ' AND e.element=s.template AND e.client_id=s.client_id');
207 
208         if ($admin_style)
209         {
210             $query->where('s.client_id = 1 AND id = ' . (int) $admin_style . ' AND e.enabled = 1', 'OR');
211         }
212 
213         $query->where('s.client_id = 1 AND home = ' . $db->quote('1'), 'OR')
214             ->order('home');
215         $db->setQuery($query);
216         $template = $db->loadObject();
217 
218         $template->template = JFilterInput::getInstance()->clean($template->template, 'cmd');
219         $template->params = new Registry($template->params);
220 
221         if (!file_exists(JPATH_THEMES . '/' . $template->template . '/index.php'))
222         {
223             $this->enqueueMessage(JText::_('JERROR_ALERTNOTEMPLATE'), 'error');
224             $template->params = new Registry;
225             $template->template = 'isis';
226         }
227 
228         // Cache the result
229         $this->template = $template;
230 
231         if (!file_exists(JPATH_THEMES . '/' . $template->template . '/index.php'))
232         {
233             throw new InvalidArgumentException(JText::sprintf('JERROR_COULD_NOT_FIND_TEMPLATE', $template->template));
234         }
235 
236         if ($params)
237         {
238             return $template;
239         }
240 
241         return $template->template;
242     }
243 
244     /**
245      * Initialise the application.
246      *
247      * @param   array  $options  An optional associative array of configuration settings.
248      *
249      * @return  void
250      *
251      * @since   3.2
252      */
253     protected function initialiseApp($options = array())
254     {
255         $user = JFactory::getUser();
256 
257         // If the user is a guest we populate it with the guest user group.
258         if ($user->guest)
259         {
260             $guestUsergroup = JComponentHelper::getParams('com_users')->get('guest_usergroup', 1);
261             $user->groups = array($guestUsergroup);
262         }
263 
264         // If a language was specified it has priority, otherwise use user or default language settings
265         if (empty($options['language']))
266         {
267             $lang = $user->getParam('admin_language');
268 
269             // Make sure that the user's language exists
270             if ($lang && JLanguageHelper::exists($lang))
271             {
272                 $options['language'] = $lang;
273             }
274             else
275             {
276                 $params = JComponentHelper::getParams('com_languages');
277                 $options['language'] = $params->get('administrator', $this->get('language', 'en-GB'));
278             }
279         }
280 
281         // One last check to make sure we have something
282         if (!JLanguageHelper::exists($options['language']))
283         {
284             $lang = $this->get('language', 'en-GB');
285 
286             if (JLanguageHelper::exists($lang))
287             {
288                 $options['language'] = $lang;
289             }
290             else
291             {
292                 // As a last ditch fail to english
293                 $options['language'] = 'en-GB';
294             }
295         }
296 
297         // Finish initialisation
298         parent::initialiseApp($options);
299     }
300 
301     /**
302      * Login authentication function
303      *
304      * @param   array  $credentials  Array('username' => string, 'password' => string)
305      * @param   array  $options      Array('remember' => boolean)
306      *
307      * @return  boolean  True on success.
308      *
309      * @since   3.2
310      */
311     public function login($credentials, $options = array())
312     {
313         // The minimum group
314         $options['group'] = 'Public Backend';
315 
316         // Make sure users are not auto-registered
317         $options['autoregister'] = false;
318 
319         // Set the application login entry point
320         if (!array_key_exists('entry_url', $options))
321         {
322             $options['entry_url'] = JUri::base() . 'index.php?option=com_users&task=login';
323         }
324 
325         // Set the access control action to check.
326         $options['action'] = 'core.login.admin';
327 
328         $result = parent::login($credentials, $options);
329 
330         if (!($result instanceof Exception))
331         {
332             $lang = $this->input->getCmd('lang');
333             $lang = preg_replace('/[^A-Z-]/i', '', $lang);
334 
335             if ($lang)
336             {
337                 $this->setUserState('application.lang', $lang);
338             }
339 
340             static::purgeMessages();
341         }
342 
343         return $result;
344     }
345 
346     /**
347      * Purge the jos_messages table of old messages
348      *
349      * @return  void
350      *
351      * @since   3.2
352      */
353     public static function purgeMessages()
354     {
355         $user = JFactory::getUser();
356         $userid = $user->get('id');
357 
358         $db = JFactory::getDbo();
359         $query = $db->getQuery(true)
360             ->select('*')
361             ->from($db->quoteName('#__messages_cfg'))
362             ->where($db->quoteName('user_id') . ' = ' . (int) $userid, 'AND')
363             ->where($db->quoteName('cfg_name') . ' = ' . $db->quote('auto_purge'), 'AND');
364         $db->setQuery($query);
365         $config = $db->loadObject();
366 
367         // Check if auto_purge value set
368         if (is_object($config) && $config->cfg_name === 'auto_purge')
369         {
370             $purge = $config->cfg_value;
371         }
372         else
373         {
374             // If no value set, default is 7 days
375             $purge = 7;
376         }
377 
378         // If purge value is not 0, then allow purging of old messages
379         if ($purge > 0)
380         {
381             // Purge old messages at day set in message configuration
382             $past = JFactory::getDate(time() - $purge * 86400);
383             $pastStamp = $past->toSql();
384 
385             $query->clear()
386                 ->delete($db->quoteName('#__messages'))
387                 ->where($db->quoteName('date_time') . ' < ' . $db->quote($pastStamp), 'AND')
388                 ->where($db->quoteName('user_id_to') . ' = ' . (int) $userid, 'AND');
389             $db->setQuery($query);
390             $db->execute();
391         }
392     }
393 
394     /**
395      * Rendering is the process of pushing the document buffers into the template
396      * placeholders, retrieving data from the document and pushing it into
397      * the application response buffer.
398      *
399      * @return  void
400      *
401      * @since   3.2
402      */
403     protected function render()
404     {
405         // Get the JInput object
406         $input = $this->input;
407 
408         $component = $input->getCmd('option', 'com_login');
409         $file      = $input->getCmd('tmpl', 'index');
410 
411         if ($component === 'com_login')
412         {
413             $file = 'login';
414         }
415 
416         $this->set('themeFile', $file . '.php');
417 
418         // Safety check for when configuration.php root_user is in use.
419         $rootUser = $this->get('root_user');
420 
421         if (property_exists('JConfig', 'root_user')
422             && (JFactory::getUser()->get('username') === $rootUser || JFactory::getUser()->id === (string) $rootUser))
423         {
424             $this->enqueueMessage(
425                 JText::sprintf(
426                     'JWARNING_REMOVE_ROOT_USER',
427                     'index.php?option=com_config&task=config.removeroot&' . JSession::getFormToken() . '=1'
428                 ),
429                 'notice'
430             );
431         }
432 
433         parent::render();
434     }
435 
436     /**
437      * Route the application.
438      *
439      * Routing is the process of examining the request environment to determine which
440      * component should receive the request. The component optional parameters
441      * are then set in the request object to be processed when the application is being
442      * dispatched.
443      *
444      * @return  void
445      *
446      * @since   3.2
447      */
448     protected function route()
449     {
450         $uri = JUri::getInstance();
451 
452         if ($this->get('force_ssl') >= 1 && strtolower($uri->getScheme()) !== 'https')
453         {
454             // Forward to https
455             $uri->setScheme('https');
456             $this->redirect((string) $uri, 301);
457         }
458 
459         // Trigger the onAfterRoute event.
460         JPluginHelper::importPlugin('system');
461         $this->triggerEvent('onAfterRoute');
462     }
463 }
464 

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.