/** * Constructor * * @param DispatcherInterface $dispatcher The event dispatcher we're going to use * * @since 11.1 */ public function __construct(DispatcherInterface $dispatcher = null) { // Set the dispatcher if (!is_object($dispatcher)) { $dispatcher = JFactory::getContainer()->get('dispatcher'); } $this->setDispatcher($dispatcher); $isLoaded = JPluginHelper::importPlugin('authentication'); if (!$isLoaded) { JLog::add(JText::_('JLIB_USER_ERROR_AUTHENTICATION_LIBRARIES'), JLog::WARNING, 'jerror'); } }
/** * Get a renderer instance for the given type * * @param string $type The type of renderer to fetch * * @return static * * @since 4.0 * @throws \InvalidArgumentException */ public static function getRenderer($type) { // Build the class name $class = __NAMESPACE__ . '\\Renderer\\' . ucfirst(strtolower($type)) . 'Renderer'; // First check if an object may exist in the container and prefer that over everything else if (\JFactory::getContainer()->exists($class)) { return \JFactory::getContainer()->get($class); } // Next check if a local class exists and use that if (class_exists($class)) { return new $class(); } // 404 Resource Not Found throw new \InvalidArgumentException(sprintf('There is not a error renderer for the "%s" format.', $type)); }
/** * Returns a JPathway object * * @param string $client The name of the client * @param array $options An associative array of options * * @return JPathway A JPathway object. * * @since 1.5 * @throws RuntimeException */ public static function getInstance($client, $options = array()) { if (empty(self::$instances[$client])) { // Create a JPathway object $classname = 'JPathway' . ucfirst($client); if (!class_exists($classname)) { throw new RuntimeException(JText::sprintf('JLIB_APPLICATION_ERROR_PATHWAY_LOAD', $client), 500); } // Check for a possible service from the container otherwise manually instantiate the class if (JFactory::getContainer()->exists($classname)) { self::$instances[$client] = JFactory::getContainer()->get($classname); } else { self::$instances[$client] = new $classname($options); } } return self::$instances[$client]; }
/** * Static method to get an instance of a JTable class if it can be found in the table include paths. * * To add include paths for searching for JTable classes see JTable::addIncludePath(). * * @param string $type The type (name) of the JTable class to get an instance of. * @param string $prefix An optional prefix for the table class name. * @param array $config An optional array of configuration values for the JTable object. * * @return JTable|boolean A JTable object if found or boolean false on failure. * * @since 11.1 */ public static function getInstance($type, $prefix = 'JTable', $config = array()) { // Sanitize and prepare the table class name. $type = preg_replace('/[^A-Z0-9_\\.-]/i', '', $type); $tableClass = $prefix . ucfirst($type); // Only try to load the class if it doesn't already exist. if (!class_exists($tableClass)) { // Search for the class file in the JTable include paths. jimport('joomla.filesystem.path'); $paths = self::addIncludePath(); $pathIndex = 0; while (!class_exists($tableClass) && $pathIndex < count($paths)) { if ($tryThis = JPath::find($paths[$pathIndex++], strtolower($type) . '.php')) { // Import the class file. include_once $tryThis; } } if (!class_exists($tableClass)) { /* * If unable to find the class file in the JTable include paths. Return false. * The warning JLIB_DATABASE_ERROR_NOT_SUPPORTED_FILE_NOT_FOUND has been removed in 3.6.3. * In 4.0 an Exception (type to be determined) will be thrown. * For more info see https://github.com/joomla/joomla-cms/issues/11570 */ return false; } } // If a database object was passed in the configuration array use it, otherwise get the global one from JFactory. $db = isset($config['dbo']) ? $config['dbo'] : JFactory::getDbo(); // Check for a possible service from the container otherwise manually instantiate the class if (JFactory::getContainer()->exists($tableClass)) { return JFactory::getContainer()->get($tableClass); } // Instantiate a new table class and return it. return new $tableClass($db); }
/** * Returns a Model object, always creating it * * @param string $type The model type to instantiate * @param string $prefix Prefix for the model class name. Optional. * @param array $config Configuration array for model. Optional. * * @return JModelLegacy|boolean A JModelLegacy instance or false on failure * * @since 12.2 */ public static function getInstance($type, $prefix = '', $config = array()) { $type = preg_replace('/[^A-Z0-9_\\.-]/i', '', $type); $modelClass = $prefix . ucfirst($type); if (!class_exists($modelClass)) { jimport('joomla.filesystem.path'); $path = JPath::find(self::addIncludePath(null, $prefix), self::_createFileName('model', array('name' => $type))); if (!$path) { $path = JPath::find(self::addIncludePath(null, ''), self::_createFileName('model', array('name' => $type))); } if (!$path) { return false; } require_once $path; if (!class_exists($modelClass)) { JLog::add(JText::sprintf('JLIB_APPLICATION_ERROR_MODELCLASS_NOT_FOUND', $modelClass), JLog::WARNING, 'jerror'); return false; } } // Check for a possible service from the container otherwise manually instantiate the class if (JFactory::getContainer()->exists($modelClass)) { return JFactory::getContainer()->get($modelClass); } return new $modelClass($config); }
/** * Method to load and return a view object. This method first looks in the * current template directory for a match and, failing that, uses a default * set path to load the view class file. * * Note the "name, prefix, type" order of parameters, which differs from the * "name, type, prefix" order used in related public methods. * * @param string $name The name of the view. * @param string $prefix Optional prefix for the view class name. * @param string $type The type of view. * @param array $config Configuration array for the view. Optional. * * @return JViewLegacy|null View object on success; null or error result on failure. * * @since 12.2 * @throws Exception */ protected function createView($name, $prefix = '', $type = '', $config = array()) { // Clean the view name $viewName = preg_replace('/[^A-Z0-9_]/i', '', $name); $classPrefix = preg_replace('/[^A-Z0-9_]/i', '', $prefix); $viewType = preg_replace('/[^A-Z0-9_]/i', '', $type); // Build the view class name $viewClass = $classPrefix . $viewName; if (!class_exists($viewClass)) { jimport('joomla.filesystem.path'); $path = JPath::find($this->paths['view'], $this->createFileName('view', array('name' => $viewName, 'type' => $viewType))); if (!$path) { return null; } require_once $path; if (!class_exists($viewClass)) { throw new Exception(JText::sprintf('JLIB_APPLICATION_ERROR_VIEW_CLASS_NOT_FOUND', $viewClass, $path), 500); } } // Check for a possible service from the container otherwise manually instantiate the class if (JFactory::getContainer()->exists($viewClass)) { return JFactory::getContainer()->get($viewClass); } return new $viewClass($config); }
/** * Returns a reference to a JCategories object * * @param string $extension Name of the categories extension * @param array $options An array of options * * @return JCategories|false JCategories object * * @since 11.1 */ public static function getInstance($extension, $options = array()) { $hash = md5($extension . serialize($options)); if (isset(self::$instances[$hash])) { return self::$instances[$hash]; } $parts = explode('.', $extension); $component = 'com_' . strtolower($parts[0]); $section = count($parts) > 1 ? $parts[1] : ''; $classname = ucfirst(substr($component, 4)) . ucfirst($section) . 'Categories'; if (!class_exists($classname)) { $path = JPATH_SITE . '/components/' . $component . '/helpers/category.php'; if (!is_file($path)) { return false; } include_once $path; } // Check for a possible service from the container otherwise manually instantiate the class if (JFactory::getContainer()->exists($classname)) { self::$instances[$hash] = JFactory::getContainer()->get($classname); } else { self::$instances[$hash] = new $classname($options); } return self::$instances[$hash]; }
/** * Returns the global JDocument object, only creating it * if it doesn't already exist. * * @param string $type The document type to instantiate * @param array $attributes Array of attributes * * @return object The document object. * * @since 11.1 * @todo This should allow custom class prefixes to be configured somehow */ public static function getInstance($type = 'html', $attributes = array()) { $signature = serialize(array($type, $attributes)); if (empty(self::$instances[$signature])) { $type = preg_replace('/[^A-Z0-9_\\.-]/i', '', $type); $ntype = null; // Determine the path and class $class = 'JDocument' . ucfirst($type); if (!class_exists($class)) { // @deprecated 4.0 - JDocument objects should be autoloaded instead $path = __DIR__ . '/' . $type . '/' . $type . '.php'; if (file_exists($path)) { JLog::add('Non-autoloadable JDocument subclasses are deprecated, support will be removed in 4.0.', JLog::WARNING, 'deprecated'); require_once $path; } else { $ntype = $type; $class = 'JDocumentRaw'; } } // Check for a possible service from the container otherwise manually instantiate the class if (JFactory::getContainer()->exists($class)) { $instance = JFactory::getContainer()->get($class); } else { $instance = new $class($attributes); } self::$instances[$signature] = $instance; if (!is_null($ntype)) { // Set the type to the Document type originally requested $instance->setType($ntype); } } return self::$instances[$signature]; }
/** * Get a file compression adapter. * * @param string $type The type of adapter (bzip2|gzip|tar|zip). * * @return JArchiveExtractable Adapter for the requested type * * @since 11.1 * @throws UnexpectedValueException * @todo This should allow custom class prefixes to be configured somehow */ public static function getAdapter($type) { if (!isset(self::$adapters[$type])) { // Try to load the adapter object $class = 'JArchive' . ucfirst($type); if (!class_exists($class)) { throw new UnexpectedValueException('Unable to load archive', 500); } // Check for a possible service from the container otherwise manually instantiate the class if (JFactory::getContainer()->exists($class)) { self::$adapters[$type] = JFactory::getContainer()->get($class); } else { self::$adapters[$type] = new $class(); } } return self::$adapters[$type]; }
/** * Loads a button type. * * @param string $type Button Type * @param boolean $new False by default * * @return boolean * * @since 1.5 */ public function loadButtonType($type, $new = false) { $signature = md5($type); if (isset($this->_buttons[$signature]) && $new === false) { return $this->_buttons[$signature]; } if (!class_exists('JToolbarButton')) { JLog::add(JText::_('JLIB_HTML_BUTTON_BASE_CLASS'), JLog::WARNING, 'jerror'); return false; } $buttonClass = 'JToolbarButton' . ucfirst($type); if (!class_exists($buttonClass)) { if (isset($this->_buttonPath)) { $dirs = $this->_buttonPath; } else { $dirs = array(); } $file = JFilterInput::getInstance()->clean(str_replace('_', DIRECTORY_SEPARATOR, strtolower($type)) . '.php', 'path'); jimport('joomla.filesystem.path'); if ($buttonFile = JPath::find($dirs, $file)) { include_once $buttonFile; } else { JLog::add(JText::sprintf('JLIB_HTML_BUTTON_NO_LOAD', $buttonClass, $buttonFile), JLog::WARNING, 'jerror'); return false; } } if (!class_exists($buttonClass)) { // @todo remove code: return JError::raiseError('SOME_ERROR_CODE', "Module file $buttonFile does not contain class $buttonClass."); return false; } // Check for a possible service from the container otherwise manually instantiate the class if (JFactory::getContainer()->exists($buttonClass)) { $this->_buttons[$signature] = JFactory::getContainer()->get($buttonClass); } else { $this->_buttons[$signature] = new $buttonClass($this); } return $this->_buttons[$signature]; }
/** * Returns a reference to a cache adapter object, always creating it * * @param string $type The cache object type to instantiate; default is output. * @param array $options Array of options * * @return JCacheController * * @since 11.1 * @throws RuntimeException */ public static function getInstance($type = 'output', $options = array()) { self::addIncludePath(JPATH_PLATFORM . '/joomla/cache/controller'); $type = strtolower(preg_replace('/[^A-Z0-9_\\.-]/i', '', $type)); $class = 'JCacheController' . ucfirst($type); if (!class_exists($class)) { // Search for the class file in the JCache include paths. jimport('joomla.filesystem.path'); $path = JPath::find(self::addIncludePath(), strtolower($type) . '.php'); if ($path === false) { throw new RuntimeException('Unable to load Cache Controller: ' . $type, 500); } include_once $path; // The class should now be loaded if (!class_exists($class)) { throw new RuntimeException('Unable to load Cache Controller: ' . $type, 500); } } // Check for a possible service from the container otherwise manually instantiate the class if (JFactory::getContainer()->exists($class)) { return JFactory::getContainer()->get($class); } return new $class($options); }
/** * Method to load an adapter instance * * @param string $adapter Adapter name * @param array $options Adapter options * * @return JInstallerAdapter * * @since 3.4 * @throws InvalidArgumentException */ public function loadAdapter($adapter, $options = array()) { $class = $this->_classprefix . ucfirst($adapter); if (!class_exists($class)) { throw new InvalidArgumentException(sprintf('The %s install adapter does not exist.', $adapter)); } // Ensure the adapter type is part of the options array $options['type'] = $adapter; // Check for a possible service from the container otherwise manually instantiate the class if (JFactory::getContainer()->exists($class)) { return JFactory::getContainer()->get($class); } return new $class($this, $this->getDbo(), $options); }
/** * Set an adapter by name * * @param string $name Adapter name * @param object &$adapter Adapter object * @param array $options Adapter options * * @return boolean True if successful * * @since 11.1 */ public function setAdapter($name, &$adapter = null, $options = array()) { if (is_object($adapter)) { $this->_adapters[$name] =& $adapter; return true; } // Assemble the class name for the requested adapter $class = $this->_classprefix . ucfirst($name); if (!class_exists($class)) { $fullpath = $this->_basepath . '/' . $this->_adapterfolder . '/' . strtolower($name) . '.php'; if (!file_exists($fullpath)) { return false; } // Try to load the adapter object require_once $fullpath; // The class should now be loaded if (!class_exists($class)) { return false; } } // Check for a possible service from the container otherwise manually instantiate the class if (JFactory::getContainer()->exists($class)) { $this->_adapters[$name] = JFactory::getContainer()->get($class); } else { $this->_adapters[$name] = new $class($this, $this->_db, $options); } return true; }