factory.php filled new, but still bug out how to solve this problem?
help please
factory.php 719 stringes
Code: Select all
<?php
/**
* @version $Id: factory.php 19176 2010-10-21 03:06:39Z ian $
* @package Joomla.Framework
* @copyright Copyright (C) 2005 - 2010 Open Source Matters. All rights reserved.
* @license GNU/GPL, see LICENSE.php
* Joomla! is free software. This version may have been modified pursuant
* to the GNU General Public License, and as distributed it includes or
* is derivative of works licensed under the GNU General Public License or
* other free or open source software licenses.
* See COPYRIGHT.php for copyright notices and details.
*/
defined('JPATH_BASE') or die();
/**
* Joomla Framework Factory class
*
* @static
* @package Joomla.Framework
* @since 1.5
*/
class JFactory
{
/**
* Get a application object
*
* Returns a reference to the global {@link JApplication} object, only creating it
* if it doesn't already exist.
*
* @access public
* @param mixed $id A client identifier or name.
* @param array $config An optional associative array of configuration settings.
* @return object JApplication
*/
function &getApplication($id = null, $config = array(), $prefix='J')
{
static $instance;
if (!is_object($instance))
{
jimport( 'joomla.application.application' );
if (!$id) {
JError::raiseError(500, 'Application Instantiation Error');
}
$instance = JApplication::getInstance($id, $config, $prefix);
}
return $instance;
}
/**
* Get a configuration object
*
* Returns a reference to the global {@link JRegistry} object, only creating it
* if it doesn't already exist.
*
* @access public
* @param string The path to the configuration file
* @param string The type of the configuration file
* @return object JRegistry
*/
function &getConfig($file = null, $type = 'PHP')
{
static $instance;
if (!is_object($instance))
{
if ($file === null) {
$file = dirname(__FILE__).DS.'config.php';
}
$instance = JFactory::_createConfig($file, $type);
}
return $instance;
}
/**
* Get a session object
*
* Returns a reference to the global {@link JSession} object, only creating it
* if it doesn't already exist.
*
* @access public
* @param array An array containing session options
* @return object JSession
*/
function &getSession($options = array())
{
static $instance;
if (!is_object($instance)) {
$instance = JFactory::_createSession($options);
}
return $instance;
}
/**
* Get a language object
*
* Returns a reference to the global {@link JLanguage} object, only creating it
* if it doesn't already exist.
*
* @access public
* @return object JLanguage
*/
function &getLanguage()
{
static $instance;
if (!is_object($instance))
{
//get the debug configuration setting
$conf =& JFactory::getConfig();
$debug = $conf->getValue('config.debug_lang');
$instance = JFactory::_createLanguage();
$instance->setDebug($debug);
}
return $instance;
}
/**
* Get a document object
*
* Returns a reference to the global {@link JDocument} object, only creating it
* if it doesn't already exist.
*
* @access public
* @return object JDocument
*/
function &getDocument()
{
static $instance;
if (!is_object( $instance )) {
$instance = JFactory::_createDocument();
}
return $instance;
}
/**
* Get an user object
*
* Returns a reference to the global {@link JUser} object, only creating it
* if it doesn't already exist.
*
* @param int $id The user to load - Can be an integer or string - If string, it is converted to ID automatically.
*
* @access public
* @return object JUser
*/
function &getUser($id = null)
{
jimport('joomla.user.user');
if(is_null($id))
{
$session =& JFactory::getSession();
$instance =& $session->get('user');
if (!is_a($instance, 'JUser')) {
$instance =& JUser::getInstance();
}
}
else
{
$instance =& JUser::getInstance($id);
}
return $instance;
}
/**
* Get a cache object
*
* Returns a reference to the global {@link JCache} object
*
* @access public
* @param string The cache group name
* @param string The handler to use
* @param string The storage method
* @return object JCache
*/
function &getCache($group = '', $handler = 'callback', $storage = null)
{
$handler = ($handler == 'function') ? 'callback' : $handler;
$conf =& JFactory::getConfig();
if(!isset($storage)) {
$storage = $conf->getValue('config.cache_handler', 'file');
}
$options = array(
'defaultgroup' => $group,
'cachebase' => $conf->getValue('config.cache_path'),
'lifetime' => $conf->getValue('config.cachetime') * 60, // minutes to seconds
'language' => $conf->getValue('config.language'),
'storage' => $storage
);
jimport('joomla.cache.cache');
$cache =& JCache::getInstance( $handler, $options );
$cache->setCaching($conf->getValue('config.caching'));
return $cache;
}
/**
* Get an authorization object
*
* Returns a reference to the global {@link JAuthorization} object, only creating it
* if it doesn't already exist.
*
* @access public
* @return object JAuthorization
*/
function &getACL( )
{
static $instance;
if (!is_object($instance)) {
$instance = JFactory::_createACL();
}
return $instance;
}
/**
* Get a template object
*
* Returns a reference to the global {@link JTemplate} object, only creating it
* if it doesn't already exist.
*
* @access public
* @return object JTemplate
*/
function &getTemplate( )
{
static $instance;
if (!is_object($instance)) {
$instance = JFactory::_createTemplate();
}
return $instance;
}
/**
* Get a database object
*
* Returns a reference to the global {@link JDatabase} object, only creating it
* if it doesn't already exist.
*
* @return object JDatabase
*/
function &getDBO()
{
static $instance;
if (!is_object($instance))
{
//get the debug configuration setting
$conf =& JFactory::getConfig();
$debug = $conf->getValue('config.debug');
$instance = JFactory::_createDBO();
$instance->debug($debug);
}
return $instance;
}
/**
* Get a mailer object
*
* Returns a reference to the global {@link JMail} object, only creating it
* if it doesn't already exist
*
* @access public
* @return object JMail
*/
function &getMailer( )
{
static $instance;
if ( ! is_object($instance) ) {
$instance = JFactory::_createMailer();
}
// Create a copy of this object - do not return the original because it may be used several times
// PHP4 copies objects by value whereas PHP5 copies by reference
$copy = (PHP_VERSION < 5) ? $instance : clone($instance);
return $copy;
}
/**
* Get an XML document
*
* @access public
* @param string The type of xml parser needed 'DOM', 'RSS' or 'Simple'
* @param array:
* boolean ['lite'] When using 'DOM' if true or not defined then domit_lite is used
* string ['rssUrl'] the rss url to parse when using "RSS"
* string ['cache_time'] with 'RSS' - feed cache time. If not defined defaults to 3600 sec
* @return object Parsed XML document object
*/
function &getXMLParser( $type = 'DOM', $options = array())
{
$doc = null;
switch (strtolower( $type ))
{
case 'rss' :
case 'atom' :
{
if (!is_null( $options['rssUrl'] ))
{
jimport ('simplepie.simplepie');
if(!is_writable(JPATH_BASE.DS.'cache')) {
$options['cache_time'] = 0;
}
$simplepie = new SimplePie(
$options['rssUrl'],
JPATH_BASE.DS.'cache',
isset( $options['cache_time'] ) ? $options['cache_time'] : 0
);
$simplepie->force_feed(true);
$simplepie->handle_content_type();
if ($simplepie->init()) {
$doc = $simplepie;
} else {
JError::raiseWarning( 'SOME_ERROR_CODE', JText::_('ERROR LOADING FEED DATA') );
}
}
} break;
case 'simple' :
{
jimport('joomla.utilities.simplexml');
$doc = new JSimpleXML();
} break;
case 'dom' :
default :
{
if (!isset($options['lite']) || $options['lite'])
{
jimport('domit.xml_domit_lite_include');
$doc = new DOMIT_Lite_Document();
}
else
{
jimport('domit.xml_domit_include');
$doc = new DOMIT_Document();
}
}
}
return $doc;
}
/**
* Get an editor object
*
* @access public
* @param string $editor The editor to load, depends on the editor plugins that are installed
* @return object JEditor
*/
function &getEditor($editor = null)
{
jimport( 'joomla.html.editor' );
//get the editor configuration setting
if(is_null($editor))
{
$conf =& JFactory::getConfig();
$editor = $conf->getValue('config.editor');
}
$instance =& JEditor::getInstance($editor);
return $instance;
}
/**
* Return a reference to the {@link JURI} object
*
* @access public
* @return object JURI
* @since 1.5
*/
function &getURI($uri = 'SERVER')
{
jimport('joomla.environment.uri');
$instance =& JURI::getInstance($uri);
return $instance;
}
/**
* Return a reference to the {@link JDate} object
*
* @access public
* @param mixed $time The initial time for the JDate object
* @param int $tzOffset The timezone offset.
* @return object JDate
* @since 1.5
*/
function &getDate($time = 'now', $tzOffset = 0)
{
jimport('joomla.utilities.date');
static $instances;
static $classname;
static $mainLocale;
if(!isset($instances)) {
$instances = array();
}
$language =& JFactory::getLanguage();
$locale = $language->getTag();
if(!isset($classname) || $locale != $mainLocale) {
//Store the locale for future reference
$mainLocale = $locale;
$localePath = JPATH_ROOT . DS . 'language' . DS . $mainLocale . DS . $mainLocale . '.date.php';
if($mainLocale !== false && file_exists($localePath)) {
$classname = 'JDate'.str_replace('-', '_', $mainLocale);
JLoader::register( $classname, $localePath);
if(!class_exists($classname)) {
//Something went wrong. The file exists, but the class does not, default to JDate
$classname = 'JDate';
}
} else {
//No file, so default to JDate
$classname = 'JDate';
}
}
$key = $time . '-' . $tzOffset;
if(!isset($instances[$classname][$key])) {
$tmp = new $classname($time, $tzOffset);
//We need to serialize to break the reference
$instances[$classname][$key] = serialize($tmp);
unset($tmp);
}
$date = unserialize($instances[$classname][$key]);
return $date;
}
/**
* Create a configuration object
*
* @access private
* @param string The path to the configuration file
* @param string The type of the configuration file
* @return object JRegistry
* @since 1.5
*/
function &_createConfig($file, $type = 'PHP')
{
jimport('joomla.registry.registry');
require_once $file;
// Create the registry with a default namespace of config
$registry = new JRegistry('config');
// Create the JConfig object
$config = new JFrameworkConfig();
// Load the configuration values into the registry
$registry->loadObject($config);
return $registry;
}
/**
* Create a session object
*
* @access private
* @param array $options An array containing session options
* @return object JSession
* @since 1.5
*/
function &_createSession( $options = array())
{
jimport('joomla.session.session');
//get the editor configuration setting
$conf =& JFactory::getConfig();
$handler = $conf->getValue('config.session_handler', 'none');
// config time is in minutes
$options['expire'] = ($conf->getValue('config.lifetime')) ? $conf->getValue('config.lifetime') * 60 : 900;
$session = JSession::getInstance($handler, $options);
if ($session->getState() == 'expired') {
$session->restart();
}
return $session;
}
/**
* Create an ACL object
*
* @access private
* @return object JAuthorization
* @since 1.5
*/
function &_createACL()
{
//TODO :: take the authorization class out of the application package
jimport( 'joomla.user.authorization' );
$db =& JFactory::getDBO();
$options = array(
'db' => &$db,
'db_table_prefix' => $db->getPrefix() . 'core_acl_',
'debug' => 0
);
$acl = new JAuthorization( $options );
return $acl;
}
/**
* Create an database object
*
* @access private
* @return object JDatabase
* @since 1.5
*/
function &_createDBO()
{
jimport('joomla.database.database');
jimport( 'joomla.database.table' );
$conf =& JFactory::getConfig();
$host = $conf->getValue('config.host');
$user = $conf->getValue('config.user');
$password = $conf->getValue('config.password');
$database = $conf->getValue('config.db');
$prefix = $conf->getValue('config.dbprefix');
$driver = $conf->getValue('config.dbtype');
$debug = $conf->getValue('config.debug');
$options = array ( 'driver' => $driver, 'host' => $host, 'user' => $user, 'password' => $password, 'database' => $database, 'prefix' => $prefix );
$db =& JDatabase::getInstance( $options );
if ( JError::isError($db) ) {
header('HTTP/1.1 500 Internal Server Error');
jexit('Database Error: ' . $db->toString() );
}
if ($db->getErrorNum() > 0) {
JError::raiseError(500 , 'JDatabase::getInstance: Could not connect to database <br />' . 'joomla.library:'.$db->getErrorNum().' - '.$db->getErrorMsg() );
}
$db->debug( $debug );
return $db;
}
/**
* Create a mailer object
*
* @access private
* @return object JMail
* @since 1.5
*/
function &_createMailer()
{
jimport('joomla.mail.mail');
$conf =& JFactory::getConfig();
$sendmail = $conf->getValue('config.sendmail');
$smtpauth = $conf->getValue('config.smtpauth');
$smtpuser = $conf->getValue('config.smtpuser');
$smtppass = $conf->getValue('config.smtppass');
$smtphost = $conf->getValue('config.smtphost');
$smtpsecure = $conf->getValue('config.smtpsecure');
$smtpport = $conf->getValue('config.smtpport');
$mailfrom = $conf->getValue('config.mailfrom');
$fromname = $conf->getValue('config.fromname');
$mailer = $conf->getValue('config.mailer');
// Create a JMail object
$mail =& JMail::getInstance();
// Set default sender
$mail->setSender(array ($mailfrom, $fromname));
// Default mailer is to use PHP's mail function
switch ($mailer)
{
case 'smtp' :
$mail->useSMTP($smtpauth, $smtphost, $smtpuser, $smtppass, $smtpsecure, $smtpport);
break;
case 'sendmail' :
$mail->useSendmail($sendmail);
break;
default :
$mail->IsMail();
break;
}
return $mail;
}
/**
* Create a template object
*
* @access private
* @param array An array of support template files to load
* @return object JTemplate
* @since 1.5
*/
function &_createTemplate($files = array())
{
jimport('joomla.template.template');
$conf =& JFactory::getConfig();
$tmpl = new JTemplate;
// patTemplate
if ($conf->getValue('config.caching')) {
$tmpl->enableTemplateCache( 'File', JPATH_BASE.DS.'cache'.DS);
}
$tmpl->setNamespace( 'jtmpl' );
// load the wrapper and common templates
$tmpl->readTemplatesFromFile( 'page.html' );
$tmpl->applyInputFilter('ShortModifiers');
// load the stock templates
if (is_array( $files ))
{
foreach ($files as $file) {
$tmpl->readTemplatesFromInput( $file );
}
}
$tmpl->addGlobalVar( 'option', $GLOBALS['option'] );
$tmpl->addGlobalVar( 'self', str_replace(array('"', '<', '>', "'"), '', $_SERVER["PHP_SELF"]) );
$tmpl->addGlobalVar( 'uri_query', $_SERVER['QUERY_STRING'] );
$tmpl->addGlobalVar( 'REQUEST_URI', JRequest::getURI() );
if (isset($GLOBALS['Itemid'])) {
$tmpl->addGlobalVar( 'itemid', $GLOBALS['Itemid'] );
}
return $tmpl;
}
/**
* Create a language object
*
* @access private
* @return object JLanguage
* @since 1.5
*/
function &_createLanguage()
{
jimport('joomla.language.language');
$conf =& JFactory::getConfig();
$locale = $conf->getValue('config.language');
$lang =& JLanguage::getInstance($locale);
$lang->setDebug($conf->getValue('config.debug_lang'));
return $lang;
}
/**
* Create a document object
*
* @access private
* @return object JDocument
* @since 1.5
*/
function &_createDocument()
{
jimport('joomla.document.document');
$lang =& JFactory::getLanguage();
//Keep backwards compatibility with Joomla! 1.0
$raw = JRequest::getBool('no_html');
$type = JRequest::getWord('format', $raw ? 'raw' : 'html');
$attributes = array (
'charset' => 'utf-8',
'lineend' => 'unix',
'tab' => ' ',
'language' => $lang->getTag(),
'direction' => $lang->isRTL() ? 'rtl' : 'ltr'
);
$doc =& JDocument::getInstance($type, $attributes);
return $doc;
}
}
