primo commit
This commit is contained in:
180
libraries/f0f/integration/joomla/filesystem/filesystem.php
Normal file
180
libraries/f0f/integration/joomla/filesystem/filesystem.php
Normal file
@ -0,0 +1,180 @@
|
||||
<?php
|
||||
/**
|
||||
* @package FrameworkOnFramework
|
||||
* @subpackage platformFilesystem
|
||||
* @copyright Copyright (C) 2010-2016 Nicholas K. Dionysopoulos / Akeeba Ltd. All rights reserved.
|
||||
* @license GNU General Public License version 2 or later; see LICENSE.txt
|
||||
*/
|
||||
// Protect from unauthorized access
|
||||
defined('F0F_INCLUDED') or die;
|
||||
|
||||
class F0FIntegrationJoomlaFilesystem extends F0FPlatformFilesystem implements F0FPlatformFilesystemInterface
|
||||
{
|
||||
public function __construct()
|
||||
{
|
||||
if (class_exists('JLoader'))
|
||||
{
|
||||
JLoader::import('joomla.filesystem.path');
|
||||
JLoader::import('joomla.filesystem.folder');
|
||||
JLoader::import('joomla.filesystem.file');
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Does the file exists?
|
||||
*
|
||||
* @param $path string Path to the file to test
|
||||
*
|
||||
* @return bool
|
||||
*/
|
||||
public function fileExists($path)
|
||||
{
|
||||
return JFile::exists($path);
|
||||
}
|
||||
|
||||
/**
|
||||
* Delete a file or array of files
|
||||
*
|
||||
* @param mixed $file The file name or an array of file names
|
||||
*
|
||||
* @return boolean True on success
|
||||
*
|
||||
*/
|
||||
public function fileDelete($file)
|
||||
{
|
||||
return JFile::delete($file);
|
||||
}
|
||||
|
||||
/**
|
||||
* Copies a file
|
||||
*
|
||||
* @param string $src The path to the source file
|
||||
* @param string $dest The path to the destination file
|
||||
* @param string $path An optional base path to prefix to the file names
|
||||
* @param boolean $use_streams True to use streams
|
||||
*
|
||||
* @return boolean True on success
|
||||
*/
|
||||
public function fileCopy($src, $dest, $path = null, $use_streams = false)
|
||||
{
|
||||
return JFile::copy($src, $dest, $path, $use_streams);
|
||||
}
|
||||
|
||||
/**
|
||||
* Write contents to a file
|
||||
*
|
||||
* @param string $file The full file path
|
||||
* @param string &$buffer The buffer to write
|
||||
* @param boolean $use_streams Use streams
|
||||
*
|
||||
* @return boolean True on success
|
||||
*/
|
||||
public function fileWrite($file, &$buffer, $use_streams = false)
|
||||
{
|
||||
return JFile::write($file, $buffer, $use_streams);
|
||||
}
|
||||
|
||||
/**
|
||||
* Checks for snooping outside of the file system root.
|
||||
*
|
||||
* @param string $path A file system path to check.
|
||||
*
|
||||
* @return string A cleaned version of the path or exit on error.
|
||||
*
|
||||
* @throws Exception
|
||||
*/
|
||||
public function pathCheck($path)
|
||||
{
|
||||
return JPath::check($path);
|
||||
}
|
||||
|
||||
/**
|
||||
* Function to strip additional / or \ in a path name.
|
||||
*
|
||||
* @param string $path The path to clean.
|
||||
* @param string $ds Directory separator (optional).
|
||||
*
|
||||
* @return string The cleaned path.
|
||||
*
|
||||
* @throws UnexpectedValueException
|
||||
*/
|
||||
public function pathClean($path, $ds = DIRECTORY_SEPARATOR)
|
||||
{
|
||||
return JPath::clean($path, $ds);
|
||||
}
|
||||
|
||||
/**
|
||||
* Searches the directory paths for a given file.
|
||||
*
|
||||
* @param mixed $paths An path string or array of path strings to search in
|
||||
* @param string $file The file name to look for.
|
||||
*
|
||||
* @return mixed The full path and file name for the target file, or boolean false if the file is not found in any of the paths.
|
||||
*/
|
||||
public function pathFind($paths, $file)
|
||||
{
|
||||
return JPath::find($paths, $file);
|
||||
}
|
||||
|
||||
/**
|
||||
* Wrapper for the standard file_exists function
|
||||
*
|
||||
* @param string $path Folder name relative to installation dir
|
||||
*
|
||||
* @return boolean True if path is a folder
|
||||
*/
|
||||
public function folderExists($path)
|
||||
{
|
||||
return JFolder::exists($path);
|
||||
}
|
||||
|
||||
/**
|
||||
* Utility function to read the files in a folder.
|
||||
*
|
||||
* @param string $path The path of the folder to read.
|
||||
* @param string $filter A filter for file names.
|
||||
* @param mixed $recurse True to recursively search into sub-folders, or an integer to specify the maximum depth.
|
||||
* @param boolean $full True to return the full path to the file.
|
||||
* @param array $exclude Array with names of files which should not be shown in the result.
|
||||
* @param array $excludefilter Array of filter to exclude
|
||||
* @param boolean $naturalSort False for asort, true for natsort
|
||||
*
|
||||
* @return array Files in the given folder.
|
||||
*/
|
||||
public function folderFiles($path, $filter = '.', $recurse = false, $full = false, $exclude = array('.svn', 'CVS', '.DS_Store', '__MACOSX'),
|
||||
$excludefilter = array('^\..*', '.*~'), $naturalSort = false)
|
||||
{
|
||||
return JFolder::files($path, $filter, $recurse, $full, $exclude, $excludefilter, $naturalSort);
|
||||
}
|
||||
|
||||
/**
|
||||
* Utility function to read the folders in a folder.
|
||||
*
|
||||
* @param string $path The path of the folder to read.
|
||||
* @param string $filter A filter for folder names.
|
||||
* @param mixed $recurse True to recursively search into sub-folders, or an integer to specify the maximum depth.
|
||||
* @param boolean $full True to return the full path to the folders.
|
||||
* @param array $exclude Array with names of folders which should not be shown in the result.
|
||||
* @param array $excludefilter Array with regular expressions matching folders which should not be shown in the result.
|
||||
*
|
||||
* @return array Folders in the given folder.
|
||||
*/
|
||||
public function folderFolders($path, $filter = '.', $recurse = false, $full = false, $exclude = array('.svn', 'CVS', '.DS_Store', '__MACOSX'),
|
||||
$excludefilter = array('^\..*'))
|
||||
{
|
||||
return JFolder::folders($path, $filter, $recurse, $full, $exclude, $excludefilter);
|
||||
}
|
||||
|
||||
/**
|
||||
* Create a folder -- and all necessary parent folders.
|
||||
*
|
||||
* @param string $path A path to create from the base path.
|
||||
* @param integer $mode Directory permissions to set for folders created. 0755 by default.
|
||||
*
|
||||
* @return boolean True if successful.
|
||||
*/
|
||||
public function folderCreate($path = '', $mode = 0755)
|
||||
{
|
||||
return JFolder::create($path, $mode);
|
||||
}
|
||||
}
|
||||
968
libraries/f0f/integration/joomla/platform.php
Normal file
968
libraries/f0f/integration/joomla/platform.php
Normal file
@ -0,0 +1,968 @@
|
||||
<?php
|
||||
/**
|
||||
* @package FrameworkOnFramework
|
||||
* @subpackage platform
|
||||
* @copyright Copyright (C) 2010-2016 Nicholas K. Dionysopoulos / Akeeba Ltd. All rights reserved.
|
||||
* @license GNU General Public License version 2 or later; see LICENSE.txt
|
||||
*/
|
||||
// Protect from unauthorized access
|
||||
defined('F0F_INCLUDED') or die;
|
||||
|
||||
/**
|
||||
* Part of the F0F Platform Abstraction Layer.
|
||||
*
|
||||
* This implements the platform class for Joomla! 2.5 or later
|
||||
*
|
||||
* @package FrameworkOnFramework
|
||||
* @since 2.1
|
||||
*/
|
||||
class F0FIntegrationJoomlaPlatform extends F0FPlatform implements F0FPlatformInterface
|
||||
{
|
||||
/**
|
||||
* The table and table field cache object, used to speed up database access
|
||||
*
|
||||
* @var JRegistry|null
|
||||
*/
|
||||
private $_cache = null;
|
||||
|
||||
/**
|
||||
* Public constructor
|
||||
*/
|
||||
public function __construct()
|
||||
{
|
||||
$this->name = 'joomla';
|
||||
$this->humanReadableName = 'Joomla!';
|
||||
$this->version = defined('JVERSION') ? JVERSION : '0.0';
|
||||
}
|
||||
|
||||
/**
|
||||
* Checks if the current script is run inside a valid CMS execution
|
||||
*
|
||||
* @see F0FPlatformInterface::checkExecution()
|
||||
*
|
||||
* @return bool
|
||||
*/
|
||||
public function checkExecution()
|
||||
{
|
||||
return defined('_JEXEC');
|
||||
}
|
||||
|
||||
public function raiseError($code, $message)
|
||||
{
|
||||
if (version_compare($this->version, '3.0', 'ge'))
|
||||
{
|
||||
throw new Exception($message, $code);
|
||||
}
|
||||
else
|
||||
{
|
||||
return JError::raiseError($code, $message);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Is this platform enabled?
|
||||
*
|
||||
* @see F0FPlatformInterface::isEnabled()
|
||||
*
|
||||
* @return boolean
|
||||
*/
|
||||
public function isEnabled()
|
||||
{
|
||||
if (is_null($this->isEnabled))
|
||||
{
|
||||
$this->isEnabled = true;
|
||||
|
||||
// Make sure _JEXEC is defined
|
||||
if (!defined('_JEXEC'))
|
||||
{
|
||||
$this->isEnabled = false;
|
||||
}
|
||||
|
||||
// We need JVERSION to be defined
|
||||
if ($this->isEnabled)
|
||||
{
|
||||
if (!defined('JVERSION'))
|
||||
{
|
||||
$this->isEnabled = false;
|
||||
}
|
||||
}
|
||||
|
||||
// Check if JFactory exists
|
||||
if ($this->isEnabled)
|
||||
{
|
||||
if (!class_exists('JFactory'))
|
||||
{
|
||||
$this->isEnabled = false;
|
||||
}
|
||||
}
|
||||
|
||||
// Check if JApplication exists
|
||||
if ($this->isEnabled)
|
||||
{
|
||||
$appExists = class_exists('JApplication');
|
||||
$appExists = $appExists || class_exists('JCli');
|
||||
$appExists = $appExists || class_exists('JApplicationCli');
|
||||
|
||||
if (!$appExists)
|
||||
{
|
||||
$this->isEnabled = false;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return $this->isEnabled;
|
||||
}
|
||||
|
||||
/**
|
||||
* Main function to detect if we're running in a CLI environment and we're admin
|
||||
*
|
||||
* @return array isCLI and isAdmin. It's not an associtive array, so we can use list.
|
||||
*/
|
||||
protected function isCliAdmin()
|
||||
{
|
||||
static $isCLI = null;
|
||||
static $isAdmin = null;
|
||||
|
||||
if (is_null($isCLI) && is_null($isAdmin))
|
||||
{
|
||||
try
|
||||
{
|
||||
if (is_null(JFactory::$application))
|
||||
{
|
||||
$isCLI = true;
|
||||
}
|
||||
else
|
||||
{
|
||||
$app = JFactory::getApplication();
|
||||
$isCLI = $app instanceof JException || $app instanceof JApplicationCli;
|
||||
}
|
||||
}
|
||||
catch (Exception $e)
|
||||
{
|
||||
$isCLI = true;
|
||||
}
|
||||
|
||||
if ($isCLI)
|
||||
{
|
||||
$isAdmin = false;
|
||||
}
|
||||
else
|
||||
{
|
||||
$isAdmin = !JFactory::$application ? false : JFactory::getApplication()->isAdmin();
|
||||
}
|
||||
}
|
||||
|
||||
return array($isCLI, $isAdmin);
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns absolute path to directories used by the CMS.
|
||||
*
|
||||
* @see F0FPlatformInterface::getPlatformBaseDirs()
|
||||
*
|
||||
* @return array A hash array with keys root, public, admin, tmp and log.
|
||||
*/
|
||||
public function getPlatformBaseDirs()
|
||||
{
|
||||
return array(
|
||||
'root' => JPATH_ROOT,
|
||||
'public' => JPATH_SITE,
|
||||
'admin' => JPATH_ADMINISTRATOR,
|
||||
'tmp' => JFactory::getConfig()->get('tmp_dir'),
|
||||
'log' => JFactory::getConfig()->get('log_dir')
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the base (root) directories for a given component.
|
||||
*
|
||||
* @param string $component The name of the component. For Joomla! this
|
||||
* is something like "com_example"
|
||||
*
|
||||
* @see F0FPlatformInterface::getComponentBaseDirs()
|
||||
*
|
||||
* @return array A hash array with keys main, alt, site and admin.
|
||||
*/
|
||||
public function getComponentBaseDirs($component)
|
||||
{
|
||||
if ($this->isFrontend())
|
||||
{
|
||||
$mainPath = JPATH_SITE . '/components/' . $component;
|
||||
$altPath = JPATH_ADMINISTRATOR . '/components/' . $component;
|
||||
}
|
||||
else
|
||||
{
|
||||
$mainPath = JPATH_ADMINISTRATOR . '/components/' . $component;
|
||||
$altPath = JPATH_SITE . '/components/' . $component;
|
||||
}
|
||||
|
||||
return array(
|
||||
'main' => $mainPath,
|
||||
'alt' => $altPath,
|
||||
'site' => JPATH_SITE . '/components/' . $component,
|
||||
'admin' => JPATH_ADMINISTRATOR . '/components/' . $component,
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
* Return a list of the view template paths for this component.
|
||||
*
|
||||
* @param string $component The name of the component. For Joomla! this
|
||||
* is something like "com_example"
|
||||
* @param string $view The name of the view you're looking a
|
||||
* template for
|
||||
* @param string $layout The layout name to load, e.g. 'default'
|
||||
* @param string $tpl The sub-template name to load (null by default)
|
||||
* @param boolean $strict If true, only the specified layout will be searched for.
|
||||
* Otherwise we'll fall back to the 'default' layout if the
|
||||
* specified layout is not found.
|
||||
*
|
||||
* @see F0FPlatformInterface::getViewTemplateDirs()
|
||||
*
|
||||
* @return array
|
||||
*/
|
||||
public function getViewTemplatePaths($component, $view, $layout = 'default', $tpl = null, $strict = false)
|
||||
{
|
||||
$isAdmin = $this->isBackend();
|
||||
|
||||
$basePath = $isAdmin ? 'admin:' : 'site:';
|
||||
$basePath .= $component . '/';
|
||||
$altBasePath = $basePath;
|
||||
$basePath .= $view . '/';
|
||||
$altBasePath .= (F0FInflector::isSingular($view) ? F0FInflector::pluralize($view) : F0FInflector::singularize($view)) . '/';
|
||||
|
||||
if ($strict)
|
||||
{
|
||||
$paths = array(
|
||||
$basePath . $layout . ($tpl ? "_$tpl" : ''),
|
||||
$altBasePath . $layout . ($tpl ? "_$tpl" : ''),
|
||||
);
|
||||
}
|
||||
else
|
||||
{
|
||||
$paths = array(
|
||||
$basePath . $layout . ($tpl ? "_$tpl" : ''),
|
||||
$basePath . $layout,
|
||||
$basePath . 'default' . ($tpl ? "_$tpl" : ''),
|
||||
$basePath . 'default',
|
||||
$altBasePath . $layout . ($tpl ? "_$tpl" : ''),
|
||||
$altBasePath . $layout,
|
||||
$altBasePath . 'default' . ($tpl ? "_$tpl" : ''),
|
||||
$altBasePath . 'default',
|
||||
);
|
||||
$paths = array_unique($paths);
|
||||
}
|
||||
|
||||
return $paths;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get application-specific suffixes to use with template paths. This allows
|
||||
* you to look for view template overrides based on the application version.
|
||||
*
|
||||
* @return array A plain array of suffixes to try in template names
|
||||
*/
|
||||
public function getTemplateSuffixes()
|
||||
{
|
||||
$jversion = new JVersion;
|
||||
$versionParts = explode('.', $jversion->RELEASE);
|
||||
$majorVersion = array_shift($versionParts);
|
||||
$suffixes = array(
|
||||
'.j' . str_replace('.', '', $jversion->getHelpVersion()),
|
||||
'.j' . $majorVersion,
|
||||
);
|
||||
|
||||
return $suffixes;
|
||||
}
|
||||
|
||||
/**
|
||||
* Return the absolute path to the application's template overrides
|
||||
* directory for a specific component. We will use it to look for template
|
||||
* files instead of the regular component directorues. If the application
|
||||
* does not have such a thing as template overrides return an empty string.
|
||||
*
|
||||
* @param string $component The name of the component for which to fetch the overrides
|
||||
* @param boolean $absolute Should I return an absolute or relative path?
|
||||
*
|
||||
* @return string The path to the template overrides directory
|
||||
*/
|
||||
public function getTemplateOverridePath($component, $absolute = true)
|
||||
{
|
||||
list($isCli, $isAdmin) = $this->isCliAdmin();
|
||||
|
||||
if (!$isCli)
|
||||
{
|
||||
if ($absolute)
|
||||
{
|
||||
$path = JPATH_THEMES . '/';
|
||||
}
|
||||
else
|
||||
{
|
||||
$path = $isAdmin ? 'administrator/templates/' : 'templates/';
|
||||
}
|
||||
|
||||
if (substr($component, 0, 7) == 'media:/')
|
||||
{
|
||||
$directory = 'media/' . substr($component, 7);
|
||||
}
|
||||
else
|
||||
{
|
||||
$directory = 'html/' . $component;
|
||||
}
|
||||
|
||||
$path .= JFactory::getApplication()->getTemplate() .
|
||||
'/' . $directory;
|
||||
}
|
||||
else
|
||||
{
|
||||
$path = '';
|
||||
}
|
||||
|
||||
return $path;
|
||||
}
|
||||
|
||||
/**
|
||||
* Load the translation files for a given component.
|
||||
*
|
||||
* @param string $component The name of the component. For Joomla! this
|
||||
* is something like "com_example"
|
||||
*
|
||||
* @see F0FPlatformInterface::loadTranslations()
|
||||
*
|
||||
* @return void
|
||||
*/
|
||||
public function loadTranslations($component)
|
||||
{
|
||||
if ($this->isBackend())
|
||||
{
|
||||
$paths = array(JPATH_ROOT, JPATH_ADMINISTRATOR);
|
||||
}
|
||||
else
|
||||
{
|
||||
$paths = array(JPATH_ADMINISTRATOR, JPATH_ROOT);
|
||||
}
|
||||
|
||||
$jlang = JFactory::getLanguage();
|
||||
$jlang->load($component, $paths[0], 'en-GB', true);
|
||||
$jlang->load($component, $paths[0], null, true);
|
||||
$jlang->load($component, $paths[1], 'en-GB', true);
|
||||
$jlang->load($component, $paths[1], null, true);
|
||||
}
|
||||
|
||||
/**
|
||||
* Authorise access to the component in the back-end.
|
||||
*
|
||||
* @param string $component The name of the component.
|
||||
*
|
||||
* @see F0FPlatformInterface::authorizeAdmin()
|
||||
*
|
||||
* @return boolean True to allow loading the component, false to halt loading
|
||||
*/
|
||||
public function authorizeAdmin($component)
|
||||
{
|
||||
if ($this->isBackend())
|
||||
{
|
||||
// Master access check for the back-end, Joomla! 1.6 style.
|
||||
$user = JFactory::getUser();
|
||||
|
||||
if (!$user->authorise('core.manage', $component)
|
||||
&& !$user->authorise('core.admin', $component))
|
||||
{
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
/**
|
||||
* Return a user object.
|
||||
*
|
||||
* @param integer $id The user ID to load. Skip or use null to retrieve
|
||||
* the object for the currently logged in user.
|
||||
*
|
||||
* @see F0FPlatformInterface::getUser()
|
||||
*
|
||||
* @return JUser The JUser object for the specified user
|
||||
*/
|
||||
public function getUser($id = null)
|
||||
{
|
||||
return JFactory::getUser($id);
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the JDocument object which handles this component's response.
|
||||
*
|
||||
* @see F0FPlatformInterface::getDocument()
|
||||
*
|
||||
* @return JDocument
|
||||
*/
|
||||
public function getDocument()
|
||||
{
|
||||
$document = null;
|
||||
|
||||
if (!$this->isCli())
|
||||
{
|
||||
try
|
||||
{
|
||||
$document = JFactory::getDocument();
|
||||
}
|
||||
catch (Exception $exc)
|
||||
{
|
||||
$document = null;
|
||||
}
|
||||
}
|
||||
|
||||
return $document;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns an object to handle dates
|
||||
*
|
||||
* @param mixed $time The initial time
|
||||
* @param null $tzOffest The timezone offset
|
||||
* @param bool $locale Should I try to load a specific class for current language?
|
||||
*
|
||||
* @return JDate object
|
||||
*/
|
||||
public function getDate($time = 'now', $tzOffest = null, $locale = true)
|
||||
{
|
||||
if($locale)
|
||||
{
|
||||
return JFactory::getDate($time, $tzOffest);
|
||||
}
|
||||
else
|
||||
{
|
||||
return new JDate($time, $tzOffest);
|
||||
}
|
||||
}
|
||||
|
||||
public function getLanguage()
|
||||
{
|
||||
return JFactory::getLanguage();
|
||||
}
|
||||
|
||||
public function getDbo()
|
||||
{
|
||||
return F0FDatabaseFactory::getInstance()->getDriver('joomla');
|
||||
}
|
||||
|
||||
/**
|
||||
* This method will try retrieving a variable from the request (input) data.
|
||||
*
|
||||
* @param string $key The user state key for the variable
|
||||
* @param string $request The request variable name for the variable
|
||||
* @param F0FInput $input The F0FInput object with the request (input) data
|
||||
* @param mixed $default The default value. Default: null
|
||||
* @param string $type The filter type for the variable data. Default: none (no filtering)
|
||||
* @param boolean $setUserState Should I set the user state with the fetched value?
|
||||
*
|
||||
* @see F0FPlatformInterface::getUserStateFromRequest()
|
||||
*
|
||||
* @return mixed The value of the variable
|
||||
*/
|
||||
public function getUserStateFromRequest($key, $request, $input, $default = null, $type = 'none', $setUserState = true)
|
||||
{
|
||||
list($isCLI, $isAdmin) = $this->isCliAdmin();
|
||||
|
||||
if ($isCLI)
|
||||
{
|
||||
return $input->get($request, $default, $type);
|
||||
}
|
||||
|
||||
$app = JFactory::getApplication();
|
||||
|
||||
if (method_exists($app, 'getUserState'))
|
||||
{
|
||||
$old_state = $app->getUserState($key, $default);
|
||||
}
|
||||
else
|
||||
{
|
||||
$old_state = null;
|
||||
}
|
||||
|
||||
$cur_state = (!is_null($old_state)) ? $old_state : $default;
|
||||
$new_state = $input->get($request, null, $type);
|
||||
|
||||
// Save the new value only if it was set in this request
|
||||
if ($setUserState)
|
||||
{
|
||||
if ($new_state !== null)
|
||||
{
|
||||
$app->setUserState($key, $new_state);
|
||||
}
|
||||
else
|
||||
{
|
||||
$new_state = $cur_state;
|
||||
}
|
||||
}
|
||||
elseif (is_null($new_state))
|
||||
{
|
||||
$new_state = $cur_state;
|
||||
}
|
||||
|
||||
return $new_state;
|
||||
}
|
||||
|
||||
/**
|
||||
* Load plugins of a specific type. Obviously this seems to only be required
|
||||
* in the Joomla! CMS.
|
||||
*
|
||||
* @param string $type The type of the plugins to be loaded
|
||||
*
|
||||
* @see F0FPlatformInterface::importPlugin()
|
||||
*
|
||||
* @return void
|
||||
*/
|
||||
public function importPlugin($type)
|
||||
{
|
||||
if (!$this->isCli())
|
||||
{
|
||||
JLoader::import('joomla.plugin.helper');
|
||||
JPluginHelper::importPlugin($type);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Execute plugins (system-level triggers) and fetch back an array with
|
||||
* their return values.
|
||||
*
|
||||
* @param string $event The event (trigger) name, e.g. onBeforeScratchMyEar
|
||||
* @param array $data A hash array of data sent to the plugins as part of the trigger
|
||||
*
|
||||
* @see F0FPlatformInterface::runPlugins()
|
||||
*
|
||||
* @return array A simple array containing the results of the plugins triggered
|
||||
*/
|
||||
public function runPlugins($event, $data)
|
||||
{
|
||||
if (!$this->isCli())
|
||||
{
|
||||
$app = JFactory::getApplication();
|
||||
|
||||
if (method_exists($app, 'triggerEvent'))
|
||||
{
|
||||
return $app->triggerEvent($event, $data);
|
||||
}
|
||||
|
||||
// IMPORTANT: DO NOT REPLACE THIS INSTANCE OF JDispatcher WITH ANYTHING ELSE. WE NEED JOOMLA!'S PLUGIN EVENT
|
||||
// DISPATCHER HERE, NOT OUR GENERIC EVENTS DISPATCHER
|
||||
if (class_exists('JEventDispatcher'))
|
||||
{
|
||||
$dispatcher = JEventDispatcher::getInstance();
|
||||
}
|
||||
else
|
||||
{
|
||||
$dispatcher = JDispatcher::getInstance();
|
||||
}
|
||||
|
||||
return $dispatcher->trigger($event, $data);
|
||||
}
|
||||
else
|
||||
{
|
||||
return array();
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Perform an ACL check.
|
||||
*
|
||||
* @param string $action The ACL privilege to check, e.g. core.edit
|
||||
* @param string $assetname The asset name to check, typically the component's name
|
||||
*
|
||||
* @see F0FPlatformInterface::authorise()
|
||||
*
|
||||
* @return boolean True if the user is allowed this action
|
||||
*/
|
||||
public function authorise($action, $assetname)
|
||||
{
|
||||
if ($this->isCli())
|
||||
{
|
||||
return true;
|
||||
}
|
||||
|
||||
return JFactory::getUser()->authorise($action, $assetname);
|
||||
}
|
||||
|
||||
/**
|
||||
* Is this the administrative section of the component?
|
||||
*
|
||||
* @see F0FPlatformInterface::isBackend()
|
||||
*
|
||||
* @return boolean
|
||||
*/
|
||||
public function isBackend()
|
||||
{
|
||||
list ($isCli, $isAdmin) = $this->isCliAdmin();
|
||||
|
||||
return $isAdmin && !$isCli;
|
||||
}
|
||||
|
||||
/**
|
||||
* Is this the public section of the component?
|
||||
*
|
||||
* @see F0FPlatformInterface::isFrontend()
|
||||
*
|
||||
* @return boolean
|
||||
*/
|
||||
public function isFrontend()
|
||||
{
|
||||
list ($isCli, $isAdmin) = $this->isCliAdmin();
|
||||
|
||||
return !$isAdmin && !$isCli;
|
||||
}
|
||||
|
||||
/**
|
||||
* Is this a component running in a CLI application?
|
||||
*
|
||||
* @see F0FPlatformInterface::isCli()
|
||||
*
|
||||
* @return boolean
|
||||
*/
|
||||
public function isCli()
|
||||
{
|
||||
list ($isCli, $isAdmin) = $this->isCliAdmin();
|
||||
|
||||
return !$isAdmin && $isCli;
|
||||
}
|
||||
|
||||
/**
|
||||
* Is AJAX re-ordering supported? This is 100% Joomla!-CMS specific. All
|
||||
* other platforms should return false and never ask why.
|
||||
*
|
||||
* @see F0FPlatformInterface::supportsAjaxOrdering()
|
||||
*
|
||||
* @return boolean
|
||||
*/
|
||||
public function supportsAjaxOrdering()
|
||||
{
|
||||
return version_compare(JVERSION, '3.0', 'ge');
|
||||
}
|
||||
|
||||
/**
|
||||
* Is the global F0F cache enabled?
|
||||
*
|
||||
* @return boolean
|
||||
*/
|
||||
public function isGlobalF0FCacheEnabled()
|
||||
{
|
||||
return !(defined('JDEBUG') && JDEBUG);
|
||||
}
|
||||
|
||||
/**
|
||||
* Saves something to the cache. This is supposed to be used for system-wide
|
||||
* F0F data, not application data.
|
||||
*
|
||||
* @param string $key The key of the data to save
|
||||
* @param string $content The actual data to save
|
||||
*
|
||||
* @return boolean True on success
|
||||
*/
|
||||
public function setCache($key, $content)
|
||||
{
|
||||
$registry = $this->getCacheObject();
|
||||
|
||||
$registry->set($key, $content);
|
||||
|
||||
return $this->saveCache();
|
||||
}
|
||||
|
||||
/**
|
||||
* Retrieves data from the cache. This is supposed to be used for system-side
|
||||
* F0F data, not application data.
|
||||
*
|
||||
* @param string $key The key of the data to retrieve
|
||||
* @param string $default The default value to return if the key is not found or the cache is not populated
|
||||
*
|
||||
* @return string The cached value
|
||||
*/
|
||||
public function getCache($key, $default = null)
|
||||
{
|
||||
$registry = $this->getCacheObject();
|
||||
|
||||
return $registry->get($key, $default);
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets a reference to the cache object, loading it from the disk if
|
||||
* needed.
|
||||
*
|
||||
* @param boolean $force Should I forcibly reload the registry?
|
||||
*
|
||||
* @return JRegistry
|
||||
*/
|
||||
private function &getCacheObject($force = false)
|
||||
{
|
||||
// Check if we have to load the cache file or we are forced to do that
|
||||
if (is_null($this->_cache) || $force)
|
||||
{
|
||||
// Create a new JRegistry object
|
||||
JLoader::import('joomla.registry.registry');
|
||||
$this->_cache = new JRegistry;
|
||||
|
||||
// Try to get data from Joomla!'s cache
|
||||
$cache = JFactory::getCache('fof', '');
|
||||
$data = $cache->get('cache', 'fof');
|
||||
|
||||
// If data is not found, fall back to the legacy (F0F 2.1.rc3 and earlier) method
|
||||
if ($data === false)
|
||||
{
|
||||
// Find the path to the file
|
||||
$cachePath = JPATH_CACHE . '/fof';
|
||||
$filename = $cachePath . '/cache.php';
|
||||
$filesystem = $this->getIntegrationObject('filesystem');
|
||||
|
||||
// Load the cache file if it exists. JRegistryFormatPHP fails
|
||||
// miserably, so I have to work around it.
|
||||
if ($filesystem->fileExists($filename))
|
||||
{
|
||||
@include_once $filename;
|
||||
|
||||
$filesystem->fileDelete($filename);
|
||||
|
||||
$className = 'F0FCacheStorage';
|
||||
|
||||
if (class_exists($className))
|
||||
{
|
||||
$object = new $className;
|
||||
$this->_cache->loadObject($object);
|
||||
|
||||
$options = array(
|
||||
'class' => 'F0FCacheStorage'
|
||||
);
|
||||
$cache->store($this->_cache, 'cache', 'fof');
|
||||
}
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
$this->_cache = $data;
|
||||
}
|
||||
}
|
||||
|
||||
return $this->_cache;
|
||||
}
|
||||
|
||||
/**
|
||||
* Save the cache object back to disk
|
||||
*
|
||||
* @return boolean True on success
|
||||
*/
|
||||
private function saveCache()
|
||||
{
|
||||
// Get the JRegistry object of our cached data
|
||||
$registry = $this->getCacheObject();
|
||||
|
||||
$cache = JFactory::getCache('fof', '');
|
||||
return $cache->store($registry, 'cache', 'fof');
|
||||
}
|
||||
|
||||
/**
|
||||
* Clears the cache of system-wide F0F data. You are supposed to call this in
|
||||
* your components' installation script post-installation and post-upgrade
|
||||
* methods or whenever you are modifying the structure of database tables
|
||||
* accessed by F0F. Please note that F0F's cache never expires and is not
|
||||
* purged by Joomla!. You MUST use this method to manually purge the cache.
|
||||
*
|
||||
* @return boolean True on success
|
||||
*/
|
||||
public function clearCache()
|
||||
{
|
||||
$false = false;
|
||||
$cache = JFactory::getCache('fof', '');
|
||||
$cache->store($false, 'cache', 'fof');
|
||||
}
|
||||
|
||||
public function getConfig()
|
||||
{
|
||||
return JFactory::getConfig();
|
||||
}
|
||||
|
||||
/**
|
||||
* logs in a user
|
||||
*
|
||||
* @param array $authInfo authentification information
|
||||
*
|
||||
* @return boolean True on success
|
||||
*/
|
||||
public function loginUser($authInfo)
|
||||
{
|
||||
JLoader::import('joomla.user.authentication');
|
||||
$options = array('remember' => false);
|
||||
$authenticate = JAuthentication::getInstance();
|
||||
$response = $authenticate->authenticate($authInfo, $options);
|
||||
|
||||
// User failed to authenticate: maybe he enabled two factor authentication?
|
||||
// Let's try again "manually", skipping the check vs two factor auth
|
||||
// Due the big mess with encryption algorithms and libraries, we are doing this extra check only
|
||||
// if we're in Joomla 2.5.18+ or 3.2.1+
|
||||
if($response->status != JAuthentication::STATUS_SUCCESS && method_exists('JUserHelper', 'verifyPassword'))
|
||||
{
|
||||
$db = $this->getDbo();
|
||||
$query = $db->getQuery(true)
|
||||
->select('id, password')
|
||||
->from('#__users')
|
||||
->where('username=' . $db->quote($authInfo['username']));
|
||||
$result = $db->setQuery($query)->loadObject();
|
||||
|
||||
if ($result)
|
||||
{
|
||||
|
||||
$match = JUserHelper::verifyPassword($authInfo['password'], $result->password, $result->id);
|
||||
|
||||
if ($match === true)
|
||||
{
|
||||
// Bring this in line with the rest of the system
|
||||
$user = JUser::getInstance($result->id);
|
||||
$response->email = $user->email;
|
||||
$response->fullname = $user->name;
|
||||
|
||||
if (JFactory::getApplication()->isAdmin())
|
||||
{
|
||||
$response->language = $user->getParam('admin_language');
|
||||
}
|
||||
else
|
||||
{
|
||||
$response->language = $user->getParam('language');
|
||||
}
|
||||
|
||||
$response->status = JAuthentication::STATUS_SUCCESS;
|
||||
$response->error_message = '';
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if ($response->status == JAuthentication::STATUS_SUCCESS)
|
||||
{
|
||||
$this->importPlugin('user');
|
||||
$results = $this->runPlugins('onLoginUser', array((array) $response, $options));
|
||||
|
||||
JLoader::import('joomla.user.helper');
|
||||
$userid = JUserHelper::getUserId($response->username);
|
||||
$user = $this->getUser($userid);
|
||||
|
||||
$session = JFactory::getSession();
|
||||
$session->set('user', $user);
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
/**
|
||||
* logs out a user
|
||||
*
|
||||
* @return boolean True on success
|
||||
*/
|
||||
public function logoutUser()
|
||||
{
|
||||
JLoader::import('joomla.user.authentication');
|
||||
$app = JFactory::getApplication();
|
||||
$options = array('remember' => false);
|
||||
$parameters = array('username' => $this->getUser()->username);
|
||||
|
||||
return $app->triggerEvent('onLogoutUser', array($parameters, $options));
|
||||
}
|
||||
|
||||
public function logAddLogger($file)
|
||||
{
|
||||
if (!class_exists('JLog'))
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
JLog::addLogger(array('text_file' => $file), JLog::ALL, array('fof'));
|
||||
}
|
||||
|
||||
/**
|
||||
* Logs a deprecated practice. In Joomla! this results in the $message being output in the
|
||||
* deprecated log file, found in your site's log directory.
|
||||
*
|
||||
* @param string $message The deprecated practice log message
|
||||
*
|
||||
* @return void
|
||||
*/
|
||||
public function logDeprecated($message)
|
||||
{
|
||||
if (!class_exists('JLog'))
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
JLog::add($message, JLog::WARNING, 'deprecated');
|
||||
}
|
||||
|
||||
public function logDebug($message)
|
||||
{
|
||||
if (!class_exists('JLog'))
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
JLog::add($message, JLog::DEBUG, 'fof');
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the root URI for the request.
|
||||
*
|
||||
* @param boolean $pathonly If false, prepend the scheme, host and port information. Default is false.
|
||||
* @param string $path The path
|
||||
*
|
||||
* @return string The root URI string.
|
||||
*/
|
||||
public function URIroot($pathonly = false, $path = null)
|
||||
{
|
||||
JLoader::import('joomla.environment.uri');
|
||||
|
||||
return JUri::root($pathonly, $path);
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the base URI for the request.
|
||||
*
|
||||
* @param boolean $pathonly If false, prepend the scheme, host and port information. Default is false.
|
||||
* |
|
||||
* @return string The base URI string
|
||||
*/
|
||||
public function URIbase($pathonly = false)
|
||||
{
|
||||
JLoader::import('joomla.environment.uri');
|
||||
|
||||
return JUri::base($pathonly);
|
||||
}
|
||||
|
||||
/**
|
||||
* Method to set a response header. If the replace flag is set then all headers
|
||||
* with the given name will be replaced by the new one (only if the current platform supports header caching)
|
||||
*
|
||||
* @param string $name The name of the header to set.
|
||||
* @param string $value The value of the header to set.
|
||||
* @param boolean $replace True to replace any headers with the same name.
|
||||
*
|
||||
* @return void
|
||||
*/
|
||||
public function setHeader($name, $value, $replace = false)
|
||||
{
|
||||
if (version_compare($this->version, '3.2', 'ge'))
|
||||
{
|
||||
JFactory::getApplication()->setHeader($name, $value, $replace);
|
||||
}
|
||||
else
|
||||
{
|
||||
JResponse::setHeader($name, $value, $replace);
|
||||
}
|
||||
}
|
||||
|
||||
public function sendHeaders()
|
||||
{
|
||||
if (version_compare($this->version, '3.2', 'ge'))
|
||||
{
|
||||
JFactory::getApplication()->sendHeaders();
|
||||
}
|
||||
else
|
||||
{
|
||||
JResponse::sendHeaders();
|
||||
}
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user