eddydesigner/conservatorio-tomadini
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

primo commit

Browse Source
This commit is contained in:
Eddy Prosperi
2024-12-17 17:34:10 +01:00
commit e650f8df99
16435 changed files with 2451012 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

134
libraries/f0f/platform/filesystem/filesystem.php Normal file
View File

@ -0,0 +1,134 @@
<?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;
abstract class F0FPlatformFilesystem implements F0FPlatformFilesystemInterface
{
/**
* The list of paths where platform class files will be looked for
*
* @var array
*/
protected static $paths = array();
/**
* This method will crawl a starting directory and get all the valid files that will be analyzed by getInstance.
* Then it organizes them into an associative array.
*
* @param string $path Folder where we should start looking
* @param array $ignoreFolders Folder ignore list
* @param array $ignoreFiles File ignore list
*
* @return array Associative array, where the `fullpath` key contains the path to the file,
* and the `classname` key contains the name of the class
*/
protected static function getFiles($path, array $ignoreFolders = array(), array $ignoreFiles = array())
{
$return = array();
$files = self::scanDirectory($path, $ignoreFolders, $ignoreFiles);
// Ok, I got the files, now I have to organize them
foreach($files as $file)
{
$clean = str_replace($path, '', $file);
$clean = trim(str_replace('\\', '/', $clean), '/');
$parts = explode('/', $clean);
// If I have less than 3 fragments, it means that the file was inside the generic folder
// (interface + abstract) so I have to skip it
if(count($parts) < 3)
{
continue;
}
$return[] = array(
'fullpath' => $file,
'classname' => 'F0FPlatform'.ucfirst($parts[0]).ucfirst(basename($parts[1], '.php'))
);
}
return $return;
}
/**
* Recursive function that will scan every directory unless it's in the ignore list. Files that aren't in the
* ignore list are returned.
*
* @param string $path Folder where we should start looking
* @param array $ignoreFolders Folder ignore list
* @param array $ignoreFiles File ignore list
*
* @return array List of all the files
*/
protected static function scanDirectory($path, array $ignoreFolders = array(), array $ignoreFiles = array())
{
$return = array();
$handle = @opendir($path);
if(!$handle)
{
return $return;
}
while (($file = readdir($handle)) !== false)
{
if($file == '.' || $file == '..')
{
continue;
}
$fullpath = $path . '/' . $file;
if((is_dir($fullpath) && in_array($file, $ignoreFolders)) || (is_file($fullpath) && in_array($file, $ignoreFiles)))
{
continue;
}
if(is_dir($fullpath))
{
$return = array_merge(self::scanDirectory($fullpath, $ignoreFolders, $ignoreFiles), $return);
}
else
{
$return[] = $path . '/' . $file;
}
}
return $return;
}
/**
* Gets the extension of a file name
*
* @param string $file The file name
*
* @return string The file extension
*/
public function getExt($file)
{
$dot = strrpos($file, '.') + 1;
return substr($file, $dot);
}
/**
* Strips the last extension off of a file name
*
* @param string $file The file name
*
* @return string The file name without the extension
*/
public function stripExt($file)
{
return preg_replace('#\.[^.]*$#', '', $file);
}
}

134
libraries/f0f/platform/filesystem/interface.php Normal file
View File

@ -0,0 +1,134 @@
<?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;
interface F0FPlatformFilesystemInterface
{
/**
* Does the file exists?
*
* @param $path string Path to the file to test
*
* @return bool
*/
public function fileExists($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);
/**
* Copies a file
*
* @param string $src The path to the source file
* @param string $dest The path to the destination file
*
* @return boolean True on success
*/
public function fileCopy($src, $dest);
/**
* Write contents to a file
*
* @param string $file The full file path
* @param string &$buffer The buffer to write
*
* @return boolean True on success
*/
public function fileWrite($file, &$buffer);
/**
* 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);
/**
* 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);
/**
* 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);
/**
* 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);
/**
* 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
*
* @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('^\..*', '.*~'));
/**
* 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('^\..*'));
/**
* 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);
}

490
libraries/f0f/platform/interface.php Normal file
View File

@ -0,0 +1,490 @@
<?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. It implements everything that
* depends on the platform F0F is running under, e.g. the Joomla! CMS front-end,
* the Joomla! CMS back-end, a CLI Joomla! Platform app, a bespoke Joomla!
* Platform / Framework web application and so on.
*
* This is the abstract class implementing some basic housekeeping functionality
* and provides the static interface to get the appropriate Platform object for
* use in the rest of the framework.
*
* @package FrameworkOnFramework
* @since 2.1
*/
interface F0FPlatformInterface
{
/**
* Checks if the current script is run inside a valid CMS execution
*
* @return bool
*/
public function checkExecution();
/**
* Set the error Handling, if possible
*
* @param integer $level PHP error level (E_ALL)
* @param string $log_level What to do with the error (ignore, callback)
* @param array $options Options for the error handler
*
* @return void
*/
public function setErrorHandling($level, $log_level, $options = array());
/**
* Raises an error, using the logic requested by the CMS (PHP Exception or dedicated class)
*
* @param integer $code
* @param string $message
*
* @return mixed
*/
public function raiseError($code, $message);
/**
* Returns the ordering of the platform class. Files with a lower ordering
* number will be loaded first.
*
* @return integer
*/
public function getOrdering();
/**
* Returns a platform integration object
*
* @param string $key The key name of the platform integration object, e.g. 'filesystem'
*
* @return object
*
* @since 2.1.2
*/
public function getIntegrationObject($key);
/**
* Forces a platform integration object instance
*
* @param string $key The key name of the platform integration object, e.g. 'filesystem'
* @param object $object The object to force for this key
*
* @return object
*
* @since 2.1.2
*/
public function setIntegrationObject($key, $object);
/**
* Is this platform enabled? This is used for automatic platform detection.
* If the environment we're currently running in doesn't seem to be your
* platform return false. If many classes return true, the one with the
* lowest order will be picked by F0FPlatform.
*
* @return boolean
*/
public function isEnabled();
/**
* Returns the (internal) name of the platform implementation, e.g.
* "joomla", "foobar123" etc. This MUST be the last part of the platform
* class name. For example, if you have a plaform implementation class
* F0FPlatformFoobar you MUST return "foobar" (all lowercase).
*
* @return string
*
* @since 2.1.2
*/
public function getPlatformName();
/**
* Returns the version number string of the platform, e.g. "4.5.6". If
* implementation integrates with a CMS or a versioned foundation (e.g.
* a framework) it is advisable to return that version.
*
* @return string
*
* @since 2.1.2
*/
public function getPlatformVersion();
/**
* Returns the human readable platform name, e.g. "Joomla!", "Joomla!
* Framework", "Something Something Something Framework" etc.
*
* @return string
*
* @since 2.1.2
*/
public function getPlatformHumanName();
/**
* Returns absolute path to directories used by the CMS.
*
* The return is a table with the following key:
* * root Path to the site root
* * public Path to the public area of the site
* * admin Path to the administrative area of the site
* * tmp Path to the temp directory
* * log Path to the log directory
*
* @return array A hash array with keys root, public, admin, tmp and log.
*/
public function getPlatformBaseDirs();
/**
* Returns the base (root) directories for a given component. The
* "component" is used in the sense of what we call "component" in Joomla!,
* "plugin" in WordPress and "module" in Drupal, i.e. an application which
* is running inside our main application (CMS).
*
* The return is a table with the following keys:
* * main The normal location of component files. For a back-end Joomla!
* component this is the administrator/components/com_example
* directory.
* * alt The alternate location of component files. For a back-end
* Joomla! component this is the front-end directory, e.g.
* components/com_example
* * site The location of the component files serving the public part of
* the application.
* * admin The location of the component files serving the administrative
* part of the application.
*
* All paths MUST be absolute. All four paths MAY be the same if the
* platform doesn't make a distinction between public and private parts,
* or when the component does not provide both a public and private part.
* All of the directories MUST be defined and non-empty.
*
* @param string $component The name of the component. For Joomla! this
* is something like "com_example"
*
* @return array A hash array with keys main, alt, site and admin.
*/
public function getComponentBaseDirs($component);
/**
* Return a list of the view template paths for this component. The paths
* are in the format site:/component_name/view_name/layout_name or
* admin:/component_name/view_name/layout_name
*
* The list of paths returned is a prioritised list. If a file is
* found in the first path the other paths will not be scanned.
*
* @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.
*
* @return array
*/
public function getViewTemplatePaths($component, $view, $layout = 'default', $tpl = null, $strict = false);
/**
* 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();
/**
* 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);
/**
* Load the translation files for a given component. The
* "component" is used in the sense of what we call "component" in Joomla!,
* "plugin" in WordPress and "module" in Drupal, i.e. an application which
* is running inside our main application (CMS).
*
* @param string $component The name of the component. For Joomla! this
* is something like "com_example"
*
* @return void
*/
public function loadTranslations($component);
/**
* By default F0F will only use the Controller's onBefore* methods to
* perform user authorisation. In some cases, like the Joomla! back-end,
* you alos need to perform component-wide user authorisation in the
* Dispatcher. This method MUST implement this authorisation check. If you
* do not need this in your platform, please always return true.
*
* @param string $component The name of the component.
*
* @return boolean True to allow loading the component, false to halt loading
*/
public function authorizeAdmin($component);
/**
* This method will try retrieving a variable from the request (input) data.
* If it doesn't exist it will be loaded from the user state, typically
* stored in the session. If it doesn't exist there either, the $default
* value will be used. If $setUserState is set to true, the retrieved
* variable will be stored in the user session.
*
* @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?
*
* @return mixed The value of the variable
*/
public function getUserStateFromRequest($key, $request, $input, $default = null, $type = 'none', $setUserState = true);
/**
* 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
*
* @return void
*/
public function 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
*
* @return array A simple array containing the resutls of the plugins triggered
*/
public function runPlugins($event, $data);
/**
* Perform an ACL check. Please note that F0F uses by default the Joomla!
* CMS convention for ACL privileges, e.g core.edit for the edit privilege.
* If your platform uses different conventions you'll have to override the
* F0F defaults using fof.xml or by specialising the controller.
*
* @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
*
* @return boolean True if the user is allowed this action
*/
public function authorise($action, $assetname);
/**
* Returns 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.
*
* @return JUser The JUser object for the specified user
*/
public function getUser($id = null);
/**
* Returns the JDocument object which handles this component's response. You
* may also return null and F0F will a. try to figure out the output type by
* examining the "format" input parameter (or fall back to "html") and b.
* F0F will not attempt to load CSS and Javascript files (as it doesn't make
* sense if there's no JDocument to handle them).
*
* @return JDocument
*/
public function getDocument();
/**
* 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);
public function getLanguage();
/**
* @return F0FDatabaseDriver
*/
public function getDbo();
/**
* Is this the administrative section of the component?
*
* @return boolean
*/
public function isBackend();
/**
* Is this the public section of the component?
*
* @return boolean
*/
public function isFrontend();
/**
* Is this a component running in a CLI application?
*
* @return boolean
*/
public function isCli();
/**
* Is AJAX re-ordering supported? This is 100% Joomla!-CMS specific. All
* other platforms should return false and never ask why.
*
* @return boolean
*/
public function supportsAjaxOrdering();
/**
* Performs a check between two versions. Use this function instead of PHP version_compare
* so we can mock it while testing
*
* @param string $version1 First version number
* @param string $version2 Second version number
* @param string $operator Operator (see version_compare for valid operators)
*
* @deprecated Use PHP's version_compare against JVERSION in your code. This method is scheduled for removal in F0F 3.0
*
* @return boolean
*/
public function checkVersion($version1, $version2, $operator);
/**
* 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);
/**
* 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);
/**
* 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();
/**
* Returns an object that holds the configuration of the current site.
*
* @return mixed
*/
public function getConfig();
/**
* Is the global F0F cache enabled?
*
* @return boolean
*/
public function isGlobalF0FCacheEnabled();
/**
* logs in a user
*
* @param array $authInfo authentification information
*
* @return boolean True on success
*/
public function loginUser($authInfo);
/**
* logs out a user
*
* @return boolean True on success
*/
public function logoutUser();
public function logAddLogger($file);
/**
* 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);
public function logDebug($message);
/**
* 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);
/**
* 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);
/**
* 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);
/**
* In platforms that perform header caching, send all headers.
*
* @return void
*/
public function sendHeaders();
}

744
libraries/f0f/platform/platform.php Normal file
View File

@ -0,0 +1,744 @@
<?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. It implements everything that
* depends on the platform F0F is running under, e.g. the Joomla! CMS front-end,
* the Joomla! CMS back-end, a CLI Joomla! Platform app, a bespoke Joomla!
* Platform / Framework web application and so on.
*
* This is the abstract class implementing some basic housekeeping functionality
* and provides the static interface to get the appropriate Platform object for
* use in the rest of the framework.
*
* @package FrameworkOnFramework
* @since 2.1
*/
abstract class F0FPlatform implements F0FPlatformInterface
{
/**
* The ordering for this platform class. The lower this number is, the more
* important this class becomes. Most important enabled class ends up being
* used.
*
* @var integer
*/
public $ordering = 100;
/**
* The internal name of this platform implementation. It must match the
* last part of the platform class name and be in all lowercase letters,
* e.g. "foobar" for F0FPlatformFoobar
*
* @var string
*
* @since 2.1.2
*/
public $name = '';
/**
* The human readable platform name
*
* @var string
*
* @since 2.1.2
*/
public $humanReadableName = 'Unknown Platform';
/**
* The platform version string
*
* @var string
*
* @since 2.1.2
*/
public $version = '';
/**
* Caches the enabled status of this platform class.
*
* @var boolean
*/
protected $isEnabled = null;
/**
* Filesystem integration objects cache
*
* @var object
*
* @since 2.1.2
*/
protected $objectCache = array();
/**
* The list of paths where platform class files will be looked for
*
* @var array
*/
protected static $paths = array();
/**
* The platform class instance which will be returned by getInstance
*
* @var F0FPlatformInterface
*/
protected static $instance = null;
// ========================================================================
// Public API for platform integration handling
// ========================================================================
/**
* Register a path where platform files will be looked for. These take
* precedence over the built-in platform files.
*
* @param string $path The path to add
*
* @return void
*/
public static function registerPlatformPath($path)
{
if (!in_array($path, self::$paths))
{
self::$paths[] = $path;
self::$instance = null;
}
}
/**
* Unregister a path where platform files will be looked for.
*
* @param string $path The path to remove
*
* @return void
*/
public static function unregisterPlatformPath($path)
{
$pos = array_search($path, self::$paths);
if ($pos !== false)
{
unset(self::$paths[$pos]);
self::$instance = null;
}
}
/**
* Force a specific platform object to be used. If null, nukes the cache
*
* @param F0FPlatformInterface|null $instance The Platform object to be used
*
* @return void
*/
public static function forceInstance($instance)
{
if ($instance instanceof F0FPlatformInterface || is_null($instance))
{
self::$instance = $instance;
}
}
/**
* Find and return the most relevant platform object
*
* @return F0FPlatformInterface
*/
public static function getInstance()
{
if (!is_object(self::$instance))
{
// Where to look for platform integrations
$paths = array(__DIR__ . '/../integration');
if (is_array(self::$paths))
{
$paths = array_merge($paths, self::$paths);
}
// Get a list of folders inside this directory
$integrations = array();
foreach ($paths as $path)
{
if (!is_dir($path))
{
continue;
}
$di = new DirectoryIterator($path);
$temp = array();
foreach ($di as $fileSpec)
{
if (!$fileSpec->isDir())
{
continue;
}
$fileName = $fileSpec->getFilename();
if (substr($fileName, 0, 1) == '.')
{
continue;
}
$platformFilename = $path . '/' . $fileName . '/platform.php';
if (!file_exists($platformFilename))
{
continue;
}
$temp[] = array(
'classname' => 'F0FIntegration' . ucfirst($fileName) . 'Platform',
'fullpath' => $path . '/' . $fileName . '/platform.php',
);
}
$integrations = array_merge($integrations, $temp);
}
// Loop all paths
foreach ($integrations as $integration)
{
// Get the class name for this platform class
$class_name = $integration['classname'];
// Load the file if the class doesn't exist
if (!class_exists($class_name, false))
{
@include_once $integration['fullpath'];
}
// If the class still doesn't exist this file didn't
// actually contain a platform class; skip it
if (!class_exists($class_name, false))
{
continue;
}
// If it doesn't implement F0FPlatformInterface, skip it
if (!class_implements($class_name, 'F0FPlatformInterface'))
{
continue;
}
// Get an object of this platform
$o = new $class_name;
// If it's not enabled, skip it
if (!$o->isEnabled())
{
continue;
}
if (is_object(self::$instance))
{
// Replace self::$instance if this object has a
// lower order number
$current_order = self::$instance->getOrdering();
$new_order = $o->getOrdering();
if ($new_order < $current_order)
{
self::$instance = null;
self::$instance = $o;
}
}
else
{
// There is no self::$instance already, so use the
// object we just created.
self::$instance = $o;
}
}
}
return self::$instance;
}
/**
* Returns the ordering of the platform class.
*
* @see F0FPlatformInterface::getOrdering()
*
* @return integer
*/
public function getOrdering()
{
return $this->ordering;
}
/**
* Is this platform enabled?
*
* @see F0FPlatformInterface::isEnabled()
*
* @return boolean
*/
public function isEnabled()
{
if (is_null($this->isEnabled))
{
$this->isEnabled = false;
}
return $this->isEnabled;
}
/**
* Returns a platform integration object
*
* @param string $key The key name of the platform integration object, e.g. 'filesystem'
*
* @return object
*
* @since 2.1.2
*/
public function getIntegrationObject($key)
{
$hasObject = false;
if (array_key_exists($key, $this->objectCache))
{
if (is_object($this->objectCache[$key]))
{
$hasObject = true;
}
}
if (!$hasObject)
{
// Instantiate a new platform integration object
$className = 'F0FIntegration' . ucfirst($this->getPlatformName()) . ucfirst($key);
$this->objectCache[$key] = new $className;
}
return $this->objectCache[$key];
}
/**
* Forces a platform integration object instance
*
* @param string $key The key name of the platform integration object, e.g. 'filesystem'
* @param object $object The object to force for this key
*
* @return object
*
* @since 2.1.2
*/
public function setIntegrationObject($key, $object)
{
$this->objectCache[$key] = $object;
}
// ========================================================================
// Default implementation
// ========================================================================
/**
* Set the error Handling, if possible
*
* @param integer $level PHP error level (E_ALL)
* @param string $log_level What to do with the error (ignore, callback)
* @param array $options Options for the error handler
*
* @return void
*/
public function setErrorHandling($level, $log_level, $options = array())
{
if (version_compare(JVERSION, '3.0', 'lt') )
{
return JError::setErrorHandling($level, $log_level, $options);
}
}
/**
* 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)
{
return array(
'main' => '',
'alt' => '',
'site' => '',
'admin' => '',
);
}
/**
* Return a list of the view template directories 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)
{
return array();
}
/**
* 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()
{
return array();
}
/**
* 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)
{
return '';
}
/**
* 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)
{
return null;
}
/**
* 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)
{
return true;
}
/**
* Returns the JUser object for the current user
*
* @param integer $id The ID of the user to fetch
*
* @see F0FPlatformInterface::getUser()
*
* @return JDocument
*/
public function getUser($id = null)
{
return null;
}
/**
* Returns the JDocument object which handles this component's response.
*
* @see F0FPlatformInterface::getDocument()
*
* @return JDocument
*/
public function getDocument()
{
return null;
}
/**
* 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)
{
return $input->get($request, $default, $type);
}
/**
* 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)
{
}
/**
* 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)
{
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)
{
return true;
}
/**
* Is this the administrative section of the component?
*
* @see F0FPlatformInterface::isBackend()
*
* @return boolean
*/
public function isBackend()
{
return true;
}
/**
* Is this the public section of the component?
*
* @see F0FPlatformInterface::isFrontend()
*
* @return boolean
*/
public function isFrontend()
{
return true;
}
/**
* Is this a component running in a CLI application?
*
* @see F0FPlatformInterface::isCli()
*
* @return boolean
*/
public function isCli()
{
return true;
}
/**
* 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 true;
}
/**
* Performs a check between two versions. Use this function instead of PHP version_compare
* so we can mock it while testing
*
* @param string $version1 First version number
* @param string $version2 Second version number
* @param string $operator Operator (see version_compare for valid operators)
*
* @return boolean
*/
public function checkVersion($version1, $version2, $operator)
{
return version_compare($version1, $version2, $operator);
}
/**
* 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)
{
return false;
}
/**
* 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)
{
return false;
}
/**
* Is the global F0F cache enabled?
*
* @return boolean
*/
public function isGlobalF0FCacheEnabled()
{
return true;
}
/**
* 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()
{
return false;
}
/**
* logs in a user
*
* @param array $authInfo authentification information
*
* @return boolean True on success
*/
public function loginUser($authInfo)
{
return true;
}
/**
* logs out a user
*
* @return boolean True on success
*/
public function logoutUser()
{
return true;
}
/**
* 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 $message The deprecated practice log message
*
* @return void
*/
public function logDeprecated($message)
{
// The default implementation does nothing. Override this in your platform classes.
}
/**
* Returns the (internal) name of the platform implementation, e.g.
* "joomla", "foobar123" etc. This MUST be the last part of the platform
* class name. For example, if you have a plaform implementation class
* F0FPlatformFoobar you MUST return "foobar" (all lowercase).
*
* @return string
*
* @since 2.1.2
*/
public function getPlatformName()
{
return $this->name;
}
/**
* Returns the version number string of the platform, e.g. "4.5.6". If
* implementation integrates with a CMS or a versioned foundation (e.g.
* a framework) it is advisable to return that version.
*
* @return string
*
* @since 2.1.2
*/
public function getPlatformVersion()
{
return $this->version;
}
/**
* Returns the human readable platform name, e.g. "Joomla!", "Joomla!
* Framework", "Something Something Something Framework" etc.
*
* @return string
*
* @since 2.1.2
*/
public function getPlatformHumanName()
{
return $this->humanReadableName;
}
}