Joomla! 1.7.3接口- 获取代码 -ET采集官方网站-自在工坊 EditorTools全自动无人值守采集软件

Joomla! 1.7.3接口

前往检查接口

前往发布接口

前往发布规则

检查接口说明

4、发布配置-文章检查网址处，可以如下填写：
　　http://您的网站/administrator/etchk.php?catid=&title=<%title%>
　　注：使用大小写敏感的服务器的用户请注意网址大小写和网站文件一致

5、接口文件无须任何改动即可使用，如果你希望增加校验或其他功能，请仔细修改；

下载GBK检查接口文件

下载UTF-8检查接口文件

检查接口代码

<?php

$vercode=''; //此处取值请自行修改
if(isset($_POST['vercode'])){
    if ($_POST['vercode']!=$vercode){
     echo("[err]invalid vercode[/err]");
     exit();
    }
}


define('_JEXEC', 1);
define('DS', DIRECTORY_SEPARATOR);

if (file_exists(dirname(__FILE__) . '/defines.php')) {
    include_once dirname(__FILE__) . '/defines.php';
}

if (!defined('_JDEFINES')) {
    define('JPATH_BASE', dirname(__FILE__));
    require_once JPATH_BASE.'/includes/defines.php';
}

require_once JPATH_BASE.'/includes/framework.php';


  //global $mainframe, $option;
  $db =& JFactory::getDBO();
    $catid= (isset($_POST['catid']) && $_POST['catid']!== null) ? $_POST['catid'] : 0;
    $search= (isset($_POST['title']) && $_POST['title']!== null) ? $_POST['title'] : '';
  $search = strtolower($search);
  $where = array();
  if ($search) {
   $where[] = 'LOWER( title ) = '.$db->Quote( $db->getEscaped( $search, true ), false );
  }else{
   echo('[err]标题不能为空[/err]');
   exit;
  }

  if ($catid>0) {
   $where[] = ' catid  = '.$catid;
  }


  $where   = ( count( $where ) ? ' WHERE ' . implode( ' AND ', $where ) : '' );

  // get the total number of records
  $query = 'SELECT COUNT(*)'
  . ' FROM #__content'
  . $where;
  $db->setQuery( $query );
  $total = $db->loadResult();
  if($total>0){
   echo('[yes]');
  }else{
   echo('[no]');
  }

  exit;


?>

发布接口说明

注：以下参数名后“=”号为示范取值而用，参数名本身不含“=”号；
　　固定取值的参数，可以在发布规则-参数取值中设置；
　　采集取值的参数项，请在发布规则-发布项中添加；

3、主要参数
　　Username 会员名参数名
passwd 密码参数名
title
主题标题参数名

articletext
内容参数名（若要进行分页请在数据整理中将ET2正文分隔标记“#-0-#”替换为Joomla分页标记 <hr class="system-pagebreak" /> ）

etattachs 文件列表参数名；

4、附加参数
catid
分类ID，请对照管理中心查看；

vercode 安全校验码，请自行设定，本项用以防止接口被他人利用，如果需要进行更多校验，请自行填加相关代码；

state=1
发布选项，0为不发布，1为发布，2为已存档；

access=1
访问权限，1为Public，2为Registered，3为Special，4为Customer Access Level；

5、可选参数
featured=0
精选，1为是，0为否；

language=*
语种，*为所有，en-GB为English (UK)；
created_by_alias
作者别名；

Alias
标题别名；

created
创建时间，若采集非标准格式时间，请在数据整理调整为标准格式时间，如2010-6-26 或 2010-06-26 12:30:42，留空则使用当前时间；

metakey
meta关键词，用于HTML页面head区meta部分显示；

metadesc
meta简介，用于HTML页面head区meta部分显示；

attribs[show_title]=
是否显示标题，留空遵循后台，0否，1是；

attribs[link_titles]=
是否显示可链接标题，留空遵循后台，0否，1是；

attribs[show_intro]=
是否显示引言，留空遵循后台，0否，1是；

attribs[show_category]=
是否显示文章分类名称，留空遵循后台，0否，1是；

attribs[link_category]=
是否显示可链接的文章分类名称，留空遵循后台，0否，1是；

attribs[show_author]=
是否显示作者姓名，留空遵循后台，0否，1是；

attribs[link_author]=
是否链接作者到资料页，留空遵循后台，0否，1是；

attribs[show_create_date]=
是否显示创建时间，留空遵循后台，0否，1是；

attribs[show_modify_date]=
是否显示修改时间，留空遵循后台，0否，1是；

attribs[show_publish_date]=
是否显示发布时间，留空遵循后台，0否，1是；

attribs[show_item_navigation]=
是否显示导航::如果设置为显示，将在文章中显示一组导航链接（上一篇，下一篇）。留空遵循后台，0否，1是；

attribs[show_icons]=
是否显示图标::打印和email使用图标还是文字，留空遵循后台，0否，1是；

attribs[show_print_icon]=
是否显示打印图标，留空遵循后台，0否，1是；

attribs[show_email_icon]=
是否显示E-mail图标，留空遵循后台，0否，1是；

attribs[show_vote]=
是否查看投票::如果设置为显示，将显示文章评级系统，留空遵循后台，0否，1是；

attribs[show_hits]=
是否显示浏览量，留空遵循后台，0否，1是；

attribs[show_noauth]=
显示未经许可链接::如果设置为是，在没有登陆的情况下，需已注册用户访问的内容，将会显示一个链接。您需要登陆才能浏览全文，留空遵循后台，0否，1是；

attribs[alternative_readmore]=
替代“阅读更多”的文字，可留空；

attribs[article_layout]=
备用布局，留空遵循后台

6、引言摘要
在正文中使用joomla标记 <hr id="system-readmore" /> ，可以分离引言与正文，也就是插入“阅读更多”；

7、发布配置-文章检查网址处，可以如下填写：
　　http://您的网站/administrator/etpost.php
　　注：使用大小写敏感的服务器的用户请注意网址大小写和网站文件一致

8、接口文件无须任何改动即可使用，如果你希望增加校验或其他功能，请仔细修改；

下载GBK发布接口文件

下载UTF-8发布接口文件

发布接口代码

<?php
/**
* @version  $Id: index.php 14401 2010-01-26 14:10:00Z louis $
* @package  Joomla
* @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.
*/
$vercode=''; //此处取值请自行修改
if(isset($_POST['vercode'])){
    if ($_POST['vercode']!=$vercode){
     echo("[err]invalid vercode[/err]");
     exit();
    }
}

// Set flag that this is a parent file
$_REQUEST['task']='article.save';
$_REQUEST['option']='com_content';
if (!isset($_POST['title']) || trim($_POST['title'])==''){
    echo('[err]标题不能为空[/err]');
    exit;
}
if(isset($_POST['created'])){
    $_POST['created']=str_replace(array('年', '月'), '-',$_POST['created']);
    $_POST['created']=str_replace(array('日'), '',$_POST['created']);
    if ($_POST['created'] && strlen(trim( $_POST['created'] )) <= 10) {
     $_POST['created'] .= date('H:i:s');
    }
    if (strtotime($_POST['created'])==false||strtotime($_POST['created'])==-1){
     echo("[err]文章发布时间格式错误[/err]");
     exit();
    }
}
foreach($_POST as $key=>$value){
    if($key<>'username' && $key<>'passwd')
        $_POST['jform'][$key]=$value;
}
$_POST['id']=0;

define( '_JEXEC', 1 );
define('DS', DIRECTORY_SEPARATOR);

if (file_exists(dirname(__FILE__) . '/defines.php')) {
    include_once dirname(__FILE__) . '/defines.php';
}

if (!defined('_JDEFINES')) {
    define('JPATH_BASE', dirname(__FILE__));
    require_once JPATH_BASE.'/includes/defines.php';
}
//require_once( JPATH_BASE .DS.'includes'.DS.'framework.php' );
 
// No direct access.
defined('_JEXEC') or die;
 
 /*
 * Joomla! system checks.
  */
 
@ini_set('magic_quotes_runtime', 0);
@ini_set('zend.ze1_compatibility_mode', '0');
 
 /*
  * Installation check, and check on removal of the install directory.
  */
/*
if (!file_exists(JPATH_CONFIGURATION.'/configuration.php') || (filesize(JPATH_CONFIGURATION.'/configuration.php') < 10) || file_exists(JPATH_INSTALLATION.'/index.php')) {
  header( 'Location: ../installation/index.php' );
  exit();
 }
*/ 
 /*
  * Joomla! system startup
  */
 
// Import the cms version library if necessary.
if (!class_exists('JVersion')) {
    require JPATH_ROOT.'/includes/version.php';
}
// System includes.
//require_once JPATH_LIBRARIES.'/import.php';
    defined('_JEXEC') or die;  
    // Set the platform root path as a constant if necessary.
    if (!defined('JPATH_PLATFORM')) {
        //define('JPATH_PLATFORM', dirname(__FILE__));
        define('JPATH_PLATFORM', JPATH_ROOT . '/libraries'); //zzcity modi
    }
    
    // Set the directory separator define if necessary.
    if (!defined('DS')) {
        define('DS', DIRECTORY_SEPARATOR);
    }
    
    // Detect the native operating system type.
    $os = strtoupper(substr(PHP_OS, 0, 3));
    if (!defined('IS_WIN')) {
        define('IS_WIN', ($os === 'WIN') ? true : false);
    }
    if (!defined('IS_MAC')) {
        define('IS_MAC', ($os === 'MAC') ? true : false);
    }
    if (!defined('IS_UNIX')) {
        define('IS_UNIX', (($os !== 'MAC') && ($os !== 'WIN')) ? true : false);
    }
    
    // Import the platform version library if necessary.
    if (!class_exists('JPlatform')) {
        require_once JPATH_PLATFORM.'/platform.php';
    }
    
    // Import the library loader if necessary.
    if (!class_exists('JLoader')) {
        require_once JPATH_PLATFORM.'/loader.php';
    }
    
    /**
     * Import the base Joomla Platform libraries.
     */
    
    //zzcity add 从jfactory中提出来定义的类文件joomla.application.application
        jimport('joomla.application.input');
        jimport('joomla.event.dispatcher');
        jimport('joomla.environment.response');
        jimport('joomla.log.log');
        
        
            //zzcity add 从japplication提上来定义的类文件/administrator/includes/application.php
                
                //jimport('joomla.application.component.helper');  //zzcity modi 此处替换该类定义源码
                    class JComponentHelper
                    {
                        /**
                         * The component list cache
                         *
                         * @var    array
                         * @since  11.1
                         */
                        protected static $_components = array();
                    
                        /**
                         * Get the component information.
                         *
                         * @param   string   $option  The component option.
                         * @param   boolean  $strict  If set and the component does not exist, the enabled attribue will be set to false.
                         *
                         * @return  object   An object with the information for the component.
                         * @since   11.1
                         */
                        public static function getComponent($option, $strict = false)
                        {
                            if (!isset(self::$_components[$option])) {
                                if (self::_load($option)){
                                    $result = self::$_components[$option];
                                } else {
                                    $result                = new stdClass;
                                    $result->enabled    = $strict ? false : true;
                                    $result->params        = new JRegistry;
                                }
                            } else {
                                $result = self::$_components[$option];
                            }
                    
                            return $result;
                        }
                    
                        /**
                         * Checks if the component is enabled
                         *
                         * @param   string   $option  The component option.
                         * @param   boolean  $strict  If set and the component does not exist, false will be returned.
                         *
                         * @return  boolean
                         * @since   11.1
                         */
                        public static function isEnabled($option, $strict = false)
                        {
                            $result = self::getComponent($option, $strict);
                    
                            return ($result->enabled | JFactory::getApplication()->isAdmin());
                        }
                    
                        /**
                         * Gets the parameter object for the component
                         *
                         * @param   string   $option  The option for the component.
                         * @param   boolean  $strict  If set and the component does not exist, false will be returned
                         *
                         * @return  JRegistry  A JRegistry object.
                         *
                         * @see     JRegistry
                         * @since   11.1
                         */
                        public static function getParams($option, $strict = false)
                        {
                            $component = self::getComponent($option, $strict);
                    
                            return $component->params;
                        }
                    
                        /**
                         * Render the component.
                         *
                         * @param   string  $option  The component option.
                         * @param   array   $params  The component parameters
                         *
                         * @return  void
                         * @since   11.1
                         */
                        public static function renderComponent($option, $params = array())
                        {
                            // Initialise variables.
                            $app    = JFactory::getApplication();
                            
                            // Load template language files.
                            $template    = $app->getTemplate(true)->template;
                            $lang = JFactory::getLanguage();
                            $lang->load('tpl_'.$template, JPATH_BASE, null, false, false)
                                ||    $lang->load('tpl_'.$template, JPATH_THEMES."/$template", null, false, false)
                                ||    $lang->load('tpl_'.$template, JPATH_BASE, $lang->getDefault(), false, false)
                                ||    $lang->load('tpl_'.$template, JPATH_THEMES."/$template", $lang->getDefault(), false, false);
                    
                            if (empty($option)) {
                                // Throw 404 if no component
                                JError::raiseError(404, JText::_('JLIB_APPLICATION_ERROR_COMPONENT_NOT_FOUND'));
                                return;
                            }
                    
                            // Record the scope
                            $scope = $app->scope;
                            // Set scope to component name
                            $app->scope = $option;
                    
                            // Build the component path.
                            $option    = preg_replace('/[^A-Z0-9_\.-]/i', '', $option);
                            $file    = substr($option, 4);
                    
                            // Define component path.
                            define('JPATH_COMPONENT',                JPATH_BASE . '/components/' . $option);
                            define('JPATH_COMPONENT_SITE',            JPATH_SITE . '/components/' . $option);
                            define('JPATH_COMPONENT_ADMINISTRATOR',    JPATH_ADMINISTRATOR . '/components/' . $option);
                    
                            // Get component path
                            if ($app->isAdmin() && file_exists(JPATH_COMPONENT . '/admin.'.$file.'.php')) {
                                $path = JPATH_COMPONENT . '/admin.'.$file.'.php';
                            } else {
                                $path = JPATH_COMPONENT . '/' . $file.'.php';
                            }
                    
                            // If component is disabled throw error
                            if (!self::isEnabled($option) || !file_exists($path)) {
                                JError::raiseError(404, JText::_('JLIB_APPLICATION_ERROR_COMPONENT_NOT_FOUND'));
                            }
                    
                            $task = JRequest::getString('task');
                    
                            // Load common and local language files.
                            $lang->load($option, JPATH_BASE, null, false, false)
                                ||    $lang->load($option, JPATH_COMPONENT, null, false, false)
                                ||    $lang->load($option, JPATH_BASE, $lang->getDefault(), false, false)
                                ||    $lang->load($option, JPATH_COMPONENT, $lang->getDefault(), false, false);
                    
                            // Handle template preview outlining.
                            $contents = null;
                    
                            // Execute the component.
                            ob_start();
                            //require_once $path; 此处替换为该文件源码/administrator/components/com_content/content.php
                                // Access check.
                                if (!JFactory::getUser()->authorise('core.manage', 'com_content')) {
                                    return JError::raiseWarning(404, JText::_('JERROR_ALERTNOAUTHOR'));
                                }
                                
                                // Include dependencies
                                jimport('joomla.application.component.controller');
                                
                                $controller = JController::getInstance('Content');
                                
                                $controller->execute(JRequest::getCmd('task'));  //zzcity \administrator\components\com_content\models\articel.php 中的save                                
                                
                                $controller->redirect();
                            //-------------require_once结束                            
                            exit;//zzcity add
                            
                            $contents = ob_get_contents();
                            ob_end_clean();
                    
                            // Build the component toolbar
                            jimport('joomla.application.helper');
                    
                            if (($path = JApplicationHelper::getPath('toolbar')) && $app->isAdmin()) {
                                // Get the task again, in case it has changed
                                $task = JRequest::getString('task');
                    
                                // Make the toolbar
                                include_once $path;
                            }
                    
                            // Revert the scope
                            $app->scope = $scope;
                    
                            return $contents;
                        }
                    
                        /**
                         * Load the installed components into the _components property.
                         *
                         * @param   string  $option  The element value for the extension
                         *
                         * @return  boolean  True on success
                         * @since   11.1
                         */
                        protected static function _load($option)
                        {
                            $db        = JFactory::getDbo();
                            $query    = $db->getQuery(true);
                            $query->select('extension_id AS "id", element AS "option", params, enabled');
                            $query->from('#__extensions');
                            $query->where($query->qn('type').' = '.$db->quote('component'));
                            $query->where($query->qn('element').' = '.$db->quote($option));
                            $db->setQuery($query);
                    
                            $cache = JFactory::getCache('_system', 'callback');
                    
                            self::$_components[$option] =  $cache->get(array($db, 'loadObject'), null, $option, false);
                    
                            if ($error = $db->getErrorMsg() || empty(self::$_components[$option])) {
                                // Fatal error.
                                JError::raiseWarning(500, JText::sprintf('JLIB_APPLICATION_ERROR_COMPONENT_NOT_LOADING', $option, $error));
                                return false;
                            }
                    
                            // Convert the params to an object.
                            if (is_string(self::$_components[$option]->params)) {
                                $temp = new JRegistry;
                                $temp->loadString(self::$_components[$option]->params);
                                self::$_components[$option]->params = $temp;
                            }
                    
                            return true;
                        }
                    }
                                    //--------------jimport('joomla.application.component.helper');结束
                
                // Import the base object library.
                JLoader::import('joomla.base.object');      //zzcity 从下面移动到这里定义（import.php文件）
                
                
                /**
                 * Base class for a Joomla! application.
                 *
                 * Acts as a Factory class for application specific objects and provides many
                 * supporting API functions. Derived clases should supply the route(), dispatch()
                 * and render() functions.
                 *
                 * @package     Joomla.Platform
                 * @subpackage  Application
                 * @since       11.1
                 */
                
                class JApplication extends JObject
                {
                    /**
                     * The client identifier.
                     *
                     * @var    integer
                     * @since  11.1
                     */
                    protected $_clientId = null;
                
                    /**
                     * The application message queue.
                     *
                     * @var    array
                     * @since  11.1
                     */
                    protected $_messageQueue = array();
                
                    /**
                     * The name of the application.
                     *
                     * @var    array
                     * @since  11.1
                     */
                    protected $_name = null;
                
                    /**
                     * The scope of the application.
                     *
                     * @var    string
                     * @since  11.1
                     */
                    public $scope = null;
                
                    /**
                     * The time the request was made.
                     *
                     * @var    date
                     * @since  11.1
                     */
                    public $requestTime = null;
                
                    /**
                     * The time the request was made as Unix timestamp.
                     *
                     * @var    integer
                     * @since  11.1
                     */
                    public $startTime = null;
                
                    /**
                     * The application input object.
                     *
                     * @var    JInput
                     * @since  11.2
                     */
                    public $input = null;
                
                    /**
                     * Class constructor.
                     *
                     * @param   array  $config  A configuration array including optional elements such as session
                     *                          session_name, clientId and others. This is not exhaustive.
                     *
                     * @since   11.1
                     */
                    public function __construct($config = array())
                    {
                        jimport('joomla.utilities.utility');
                        jimport('joomla.error.profiler');
                
                        // Set the view name.
                        $this->_name = $this->getName();
                
                        // Only set the clientId if available.
                        if (isset($config['clientId'])) {
                            $this->_clientId = $config['clientId'];
                        }
                
                        // Enable sessions by default.
                        if (!isset($config['session'])) {
                            $config['session'] = true;
                        }
                
                        // Create the input object
                        if (class_exists('JInput')) {
                            $this->input = new JInput;
                        }
                
                        // Set the session default name.
                        if (!isset($config['session_name'])) {
                            $config['session_name'] = $this->_name;
                        }
                
                        // Set the default configuration file.
                        if (!isset($config['config_file'])) {
                            $config['config_file'] = 'configuration.php';
                        }
                
                        // Create the configuration object.
                        if (file_exists(JPATH_CONFIGURATION . '/' . $config['config_file'])) {
                            $this->_createConfiguration(JPATH_CONFIGURATION . '/' . $config['config_file']);
                        }
                
                        // Create the session if a session name is passed.
                        if ($config['session'] !== false) {
                            $this->_createSession(JUtility::getHash($config['session_name']));
                        }
                
                        $this->set('requestTime', gmdate('Y-m-d H:i'));
                
                        // Used by task system to ensure that the system doesn't go over time.
                        $this->set('startTime', JProfiler::getmicrotime());
                    }
                
                    /**
                     * Returns the global JApplication object, only creating it if it
                     * doesn't already exist.
                     *
                     * @param   mixed   $client  A client identifier or name.
                     * @param   array   $config  An optional associative array of configuration settings.
                     * @param   strong  $prefx   A prefix for class names
                     *
                     * @return  JApplication A JApplication object.
                     *
                     * @since   11.1
                     */
                    public static function getInstance($client, $config = array(), $prefix = 'J')
                    {
                        static $instances;
                
                        if (!isset($instances)) {
                            $instances = array();
                        }
                
                        if (empty($instances[$client])) {
                            // Load the router object.
                            jimport('joomla.application.helper');
                            $info = JApplicationHelper::getClientInfo($client, true);
                
                            $path = $info->path . '/includes/application.php';
                            if (file_exists($path)) {
                                //require_once $path;      //zzcity modi 类文件/administrator/includes/application.php移到上面定义以便修改
                
                                // Create a JRouter object.
                                $classname = $prefix.ucfirst($client);
                                $instance = new $classname($config);
                            }
                            else {
                                $error = JError::raiseError(500, JText::sprintf('JLIB_APPLICATION_ERROR_APPLICATION_LOAD', $client));
                                return $error;
                            }
                
                            $instances[$client] = &$instance;
                        }
                
                        return $instances[$client];
                    }
                
                    /**
                     * Initialise the application.
                     *
                     * @param   array  $options  An optional associative array of configuration settings.
                     *
                     * @since   11.1
                     */
                    public function initialise($options = array())
                    {
                        jimport('joomla.plugin.helper');
                
                        // Set the language in the class.
                        $config = JFactory::getConfig();
                
                        // Check that we were given a language in the array (since by default may be blank).
                        if (isset($options['language'])) {
                            $config->set('language', $options['language']);
                        }
                
                        // Set user specific editor.
                        $user    = JFactory::getUser();
                        $editor    = $user->getParam('editor', $this->getCfg('editor'));
                        if (!JPluginHelper::isEnabled('editors', $editor)) {
                            $editor    = $this->getCfg('editor');
                            if (!JPluginHelper::isEnabled('editors', $editor)) {
                                $editor    = 'none';
                            }
                        }
                
                        $config->set('editor', $editor);
                
                        // Trigger the onAfterInitialise event.
                        JPluginHelper::importPlugin('system');
                        $this->triggerEvent('onAfterInitialise');
                    }
                
                    /**
                     * Route the application.
                     *
                     * Routing is the process of examining the request environment to determine which
                     * component should receive the request. The component optional parameters
                     * are then set in the request object to be processed when the application is being
                     * dispatched.
                     *
                     * @return  void;
                     *
                     * @since   11.1
                     */
                    public function route()
                    {
                        // Get the full request URI.
                        $uri    = clone JURI::getInstance();
                
                        $router = $this->getRouter();
                        $result = $router->parse($uri);
                
                        JRequest::set($result, 'get', false);
                
                        // Trigger the onAfterRoute event.
                        JPluginHelper::importPlugin('system');
                        $this->triggerEvent('onAfterRoute');
                    }
                
                    /**
                     * Dispatch the applicaiton.
                     *
                     * Dispatching is the process of pulling the option from the request object and
                     * mapping them to a component. If the component does not exist, it handles
                     * determining a default component to dispatch.
                     *
                     * @param   string  $component  The component to dispatch.
                     *
                     * @return  void
                     *
                     * @since   11.1
                     */
                    public function dispatch($component = null)
                    {
                        $document = JFactory::getDocument();
                
                        $document->setTitle($this->getCfg('sitename'). ' - ' .JText::_('JADMINISTRATION'));
                        $document->setDescription($this->getCfg('MetaDesc'));
                
                        $contents = JComponentHelper::renderComponent($component);
                        $document->setBuffer($contents, 'component');
                
                        // Trigger the onAfterDispatch event.
                        JPluginHelper::importPlugin('system');
                        $this->triggerEvent('onAfterDispatch');
                    }
                
                    /**
                     * Render the application.
                     *
                     * Rendering is the process of pushing the document buffers into the template
                     * placeholders, retrieving data from the document and pushing it into
                     * the JResponse buffer.
                     *
                     * @return  void
                     *
                     * @since   11.1
                     */
                    public function render()
                    {
                        $params = array(
                            'template'    => $this->getTemplate(),
                            'file'        => 'index.php',
                            'directory'    => JPATH_THEMES,
                            'params'    => $template->params
                        );
                
                        // Parse the document.
                        $document = JFactory::getDocument();
                        $document->parse($params);
                
                        // Trigger the onBeforeRender event.
                        JPluginHelper::importPlugin('system');
                        $this->triggerEvent('onBeforeRender');
                
                        // Render the document.
                        $caching = ($this->getCfg('caching') >= 2) ? true : false;
                        JResponse::setBody($document->render($caching, $params));
                
                        // Trigger the onAfterRender event.
                        $this->triggerEvent('onAfterRender');
                    }
                
                    /**
                     * Exit the application.
                     *
                     * @param    integer  $code  Exit code
                     *
                     * @return   void     Exits the application.
                     *
                     * @since    11.1
                     */
                    public function close($code = 0)
                    {
                        exit($code);
                    }
                
                    /**
                     * Redirect to another URL.
                     *
                     * Optionally enqueues a message in the system message queue (which will be displayed
                     * the next time a page is loaded) using the enqueueMessage method. If the headers have
                     * not been sent the redirect will be accomplished using a "301 Moved Permanently"
                     * code in the header pointing to the new location. If the headers have already been
                     * sent this will be accomplished using a JavaScript statement.
                     *
                     * @param   string   $url      The URL to redirect to. Can only be http/https URL
                     * @param   string   $msg      An optional message to display on redirect.
                     * @param   string   $msgType  An optional message type. Defaults to message.
                     * @param   boolean  $moved    True if the page is 301 Permanently Moved, otherwise 303 See Other is assumed.
                     *
                     * @return  void  Calls exit().
                     *
                     * @since   11.1
                     *
                     * @see     JApplication::enqueueMessage()
                     */
                    public function redirect($url, $msg='', $msgType='message', $moved = false)
                    {
                        
                        //zzcity add
                        if($msgType=='error'){
                            echo('[err]'.$msg.'[/err]');
                        }else{
                            echo('[ok]'.$msg);
                        }
                        exit;
                        //--------zzcity
                        // Check for relative internal links.
                        if (preg_match('#^index2?\.php#', $url)) {
                            $url = JURI::base() . $url;
                        }
                
                        // Strip out any line breaks.
                        $url = preg_split("/[\r\n]/", $url);
                        $url = $url[0];
                
                        // If we don't start with a http we need to fix this before we proceed.
                        // We could validly start with something else (e.g. ftp), though this would
                        // be unlikely and isn't supported by this API.
                        if (!preg_match('#^http#i', $url)) {
                            $uri = JURI::getInstance();
                            $prefix = $uri->toString(array('scheme', 'user', 'pass', 'host', 'port'));
                
                            if ($url[0] == '/') {
                                // We just need the prefix since we have a path relative to the root.
                                $url = $prefix . $url;
                            }
                            else {
                                // It's relative to where we are now, so lets add that.
                                $parts = explode('/', $uri->toString(array('path')));
                                array_pop($parts);
                                $path = implode('/', $parts).'/';
                                $url = $prefix . $path . $url;
                            }
                        }
                
                
                        // If the message exists, enqueue it.
                        if (trim($msg)) {
                            $this->enqueueMessage($msg, $msgType);
                        }
                
                        // Persist messages if they exist.
                        if (count($this->_messageQueue)) {
                            $session = JFactory::getSession();
                            $session->set('application.queue', $this->_messageQueue);
                        }
                
                        // If the headers have been sent, then we cannot send an additional location header
                        // so we will output a javascript redirect statement.
                        if (headers_sent()) {
                            echo "<script>document.location.href='".htmlspecialchars($url)."';</script>\n";
                        }
                        else {
                            $document = JFactory::getDocument();
                            jimport('joomla.environment.browser');
                            $navigator = JBrowser::getInstance();
                            jimport('phputf8.utils.ascii');
                            if ($navigator->isBrowser('msie') && !utf8_is_ascii($url)) {
                                // MSIE type browser and/or server cause issues when url contains utf8 character,so use a javascript redirect method
                                echo '<html><head><meta http-equiv="content-type" content="text/html; charset='.$document->getCharset().'" /><script>document.location.href=\''.htmlspecialchars($url).'\';</script></head></html>';
                            } elseif (!$moved and $navigator->isBrowser('konqueror')) {
                                // WebKit browser (identified as konqueror by Joomla!) - Do not use 303, as it causes subresources reload (https://bugs.webkit.org/show_bug.cgi?id=38690)
                                echo '<html><head><meta http-equiv="content-type" content="text/html; charset='.$document->getCharset().'" /><meta http-equiv="refresh" content="0; url='.htmlspecialchars($url).'" /></head></html>';
                            } else {
                                // All other browsers, use the more efficient HTTP header method
                                header($moved ? 'HTTP/1.1 301 Moved Permanently' : 'HTTP/1.1 303 See other');
                                header('Location: '.$url);
                                header('Content-Type: text/html; charset='.$document->getCharset());
                            }
                        }
                        $this->close();
                    }
                
                    /**
                     * Enqueue a system message.
                     *
                     * @param   string   $msg   The message to enqueue.
                     * @param   string   $type  The message type. Default is message.
                     *
                     * @return  void
                     *
                     * @since   11.1
                     */
                    public function enqueueMessage($msg, $type = 'message')
                    {
                        // For empty queue, if messages exists in the session, enqueue them first.
                        if (!count($this->_messageQueue)) {
                            $session = JFactory::getSession();
                            $sessionQueue = $session->get('application.queue');
                
                            if (count($sessionQueue)) {
                                $this->_messageQueue = $sessionQueue;
                                $session->set('application.queue', null);
                            }
                        }
                
                        // Enqueue the message.
                        $this->_messageQueue[] = array('message' => $msg, 'type' => strtolower($type));
                    }
                
                    /**
                     * Get the system message queue.
                     *
                     * @return  array  The system message queue.
                     *
                     * @since   11.1
                     */
                    public function getMessageQueue()
                    {
                        // For empty queue, if messages exists in the session, enqueue them.
                        if (!count($this->_messageQueue)) {
                            $session = JFactory::getSession();
                            $sessionQueue = $session->get('application.queue');
                
                            if (count($sessionQueue)) {
                                $this->_messageQueue = $sessionQueue;
                                $session->set('application.queue', null);
                            }
                        }
                
                        return $this->_messageQueue;
                    }
                
                    /**
                     * Gets a configuration value.
                     *
                     * An example is in application/japplication-getcfg.php Getting a configuration
                     *
                     * @param   string   The name of the value to get.
                     * @param   string   Default value to return
                     *
                     * @return  mixed    The user state.
                     *
                     * @since   11.1
                     */
                    public function getCfg($varname, $default=null)
                    {
                        $config = JFactory::getConfig();
                        return $config->get('' . $varname, $default);
                    }
                
                    /**
                     * Method to get the application name.
                     *
                     * The dispatcher name is by default parsed using the classname, or it can be set
                     * by passing a $config['name'] in the class constructor.
                     *
                     * @return  string  The name of the dispatcher.
                     *
                     * @since   11.1
                     */
                    public function getName()
                    {
                        $name = $this->_name;
                
                        if (empty($name)) {
                            $r = null;
                            if (!preg_match('/J(.*)/i', get_class($this), $r)) {
                                JError::raiseError(500, JText::_('JLIB_APPLICATION_ERROR_APPLICATION_GET_NAME'));
                            }
                            $name = strtolower($r[1]);
                        }
                
                        return $name;
                    }
                
                    /**
                     * Gets a user state.
                     *
                     * @param   string  The path of the state.
                     * @param   mixed   Optional default value, returned if the internal value is null.
                     *
                     * @return  mixed  The user state or null.
                     *
                     * @since   11.1
                     */
                    public function getUserState($key, $default = null)
                    {
                        $session    = JFactory::getSession();
                        $registry    = $session->get('registry');
                
                        if (!is_null($registry)) {
                            return $registry->get($key, $default);
                        }
                
                        return $default;
                    }
                
                    /**
                     * Sets the value of a user state variable.
                     *
                     * @param   string  The path of the state.
                     * @param   string  The value of the variable.
                     *
                     * @return  mixed   The previous state, if one existed.
                     *
                     * @since   11.1
                     */
                    public function setUserState($key, $value)
                    {
                        $session    = JFactory::getSession();
                        $registry    = $session->get('registry');
                
                        if (!is_null($registry)) {
                            return $registry->set($key, $value);
                        }
                
                        return null;
                    }
                
                    /**
                     * Gets the value of a user state variable.
                     *
                     * @param   string   $key      The key of the user state variable.
                     * @param   string   $request  The name of the variable passed in a request.
                     * @param   string   $default  The default value for the variable if not found. Optional.
                     * @param   string   $type     Filter for the variable, for valid values see {@link JFilterInput::clean()}. Optional.
                     *
                     * @return  The request user state.
                     *
                     * @since   11.1
                     */
                    public function getUserStateFromRequest($key, $request, $default = null, $type = 'none')
                    {
                        $cur_state = $this->getUserState($key, $default);
                        $new_state = JRequest::getVar($request, null, 'default', $type);
                
                        // Save the new value only if it was set in this request.
                        if ($new_state !== null) {
                            $this->setUserState($key, $new_state);
                        }
                        else {
                            $new_state = $cur_state;
                        }
                
                        return $new_state;
                    }
                
                    /**
                     * Registers a handler to a particular event group.
                     *
                     * @param   string  $event    The event name.
                     * @param   mixed   $handler  The handler, a function or an instance of a event object.
                     *
                     * @return  void
                     *
                     * @since   11.1
                     */
                    public static function registerEvent($event, $handler)
                    {
                        $dispatcher = JDispatcher::getInstance();
                        $dispatcher->register($event, $handler);
                    }
                
                    /**
                     * Calls all handlers associated with an event group.
                     *
                     * @param   string  $event  The event name.
                     * @param   array   $args   An array of arguments.
                     *
                     * @return  array  An array of results from each function call.
                     *
                     * @since   11.1
                     */
                    function triggerEvent($event, $args=null)
                    {
                        $dispatcher = JDispatcher::getInstance();
                
                        return $dispatcher->trigger($event, $args);
                    }
                
                    /**
                     * Login authentication function.
                     *
                     * Username and encoded password are passed the onUserLogin event which
                     * is responsible for the user validation. A successful validation updates
                     * the current session record with the user's details.
                     *
                     * Username and encoded password are sent as credentials (along with other
                     * possibilities) to each observer (authentication plugin) for user
                     * validation.  Successful validation will update the current session with
                     * the user details.
                     *
                     * @param   array  $credentials  Array('username' => string, 'password' => string)
                     * @param   array  $options      Array('remember' => boolean)
                     *
                     * @return  boolean  True on success.
                     *
                     * @since   11.1
                     */
                    public function login($credentials, $options = array())
                    {
                        // Get the global JAuthentication object.
                        jimport('joomla.user.authentication');
                
                        $authenticate = JAuthentication::getInstance();
                        $response    = $authenticate->authenticate($credentials, $options);
                
                        if ($response->status === JAuthentication::STATUS_SUCCESS) {
                            // validate that the user should be able to login (different to being authenticated)
                            // this permits authentication plugins blocking the user
                            $authorisations = $authenticate->authorise($response, $options);            
                            foreach ($authorisations as $authorisation)
                            {
                                $denied_states = array(JAuthentication::STATUS_EXPIRED, JAuthentication::STATUS_DENIED);
                                if(in_array($authorisation->status, $denied_states))
                                {
                                    // Trigger onUserAuthorisationFailure Event.
                                    $this->triggerEvent('onUserAuthorisationFailure', array((array)$authorisation));
                
                                    // If silent is set, just return false.
                                    if (isset($options['silent']) && $options['silent']) {
                                        return false;
                                    }
                
                                    // Return the error.
                                    switch($authorisation->status)
                                    {
                                        case JAuthentication::STATUS_EXPIRED:
                                            return JError::raiseWarning('102002', JText::_('JLIB_LOGIN_EXPIRED'));
                                            break;
                                        case JAuthentication::STATUS_DENIED:
                                            return JError::raiseWarning('102003', JText::_('JLIB_LOGIN_DENIED'));
                                            break;
                                        default:
                                            return JError::raiseWarning('102004', JText::_('JLIB_LOGIN_AUTHORISATION'));
                                            break;
                                    }
                                }
                            }
                
                            // Import the user plugin group.
                            JPluginHelper::importPlugin('user');
                
                            // OK, the credentials are authenticated and user is authorised.  Lets fire the onLogin event.
                            $results = $this->triggerEvent('onUserLogin', array((array)$response, $options));
                
                            /*
                             * If any of the user plugins did not successfully complete the login routine
                             * then the whole method fails.
                             *
                             * Any errors raised should be done in the plugin as this provides the ability
                             * to provide much more information about why the routine may have failed.
                             */
                
                            if (!in_array(false, $results, true)) {
                                // Set the remember me cookie if enabled.
                                if (isset($options['remember']) && $options['remember']) {
                                    jimport('joomla.utilities.simplecrypt');
                                    jimport('joomla.utilities.utility');
                
                                    // Create the encryption key, apply extra hardening using the user agent string.
                                    $agent = @$_SERVER['HTTP_USER_AGENT'];
                                    // Ignore empty and crackish user agents
                                    if ($agent != '' && $agent != 'JLOGIN_REMEMBER') {
                                        $key = JUtility::getHash($agent);
                                        $crypt = new JSimpleCrypt($key);
                                        $rcookie = $crypt->encrypt(serialize($credentials));
                                        $lifetime = time() + 365*24*60*60;
                                        // Use domain and path set in config for cookie if it exists.
                                        $cookie_domain = $this->getCfg('cookie_domain', '');
                                        $cookie_path = $this->getCfg('cookie_path', '/');
                                        setcookie(
                                            JUtility::getHash('JLOGIN_REMEMBER'), $rcookie, $lifetime,
                                            $cookie_path, $cookie_domain
                                        );
                                    }
                                }
                
                                return true;
                            }
                        }
                
                        // Trigger onUserLoginFailure Event.
                        $this->triggerEvent('onUserLoginFailure', array((array)$response));
                
                        // If silent is set, just return false.
                        if (isset($options['silent']) && $options['silent']) {
                            return false;
                        }
                
                        // If status is success, any error will have been raised by the user plugin
                        if ($response->status !== JAuthentication::STATUS_SUCCESS) {
                            JError::raiseWarning('102001', JText::_('JLIB_LOGIN_AUTHENTICATE'));
                        }
                
                        return false;
                    }
                
                    /**
                     * Logout authentication function.
                     *
                     * Passed the current user information to the onUserLogout event and reverts the current
                     * session record back to 'anonymous' parameters.
                     * If any of the authentication plugins did not successfully complete
                     * the logout routine then the whole method fails. Any errors raised
                     * should be done in the plugin as this provides the ability to give
                     * much more information about why the routine may have failed.
                     *
                     * @param   integer  $userid   The user to load - Can be an integer or string - If string, it is converted to ID automatically
                     * @param   array    $options  Array('clientid' => array of client id's)
                     *
                     * @return  boolean  True on success
                     *
                     * @since   11.1
                     */
                    public function logout($userid = null, $options = array())
                    {
                        // Initialise variables.
                        $retval = false;
                
                        // Get a user object from the JApplication.
                        $user = JFactory::getUser($userid);
                
                        // Build the credentials array.
                        $parameters['username']    = $user->get('username');
                        $parameters['id']        = $user->get('id');
                
                        // Set clientid in the options array if it hasn't been set already.
                        if (!isset($options['clientid'])) {
                            $options['clientid']= $this->getClientId();
                        }
                
                        // Import the user plugin group.
                        JPluginHelper::importPlugin('user');
                
                        // OK, the credentials are built. Lets fire the onLogout event.
                        $results = $this->triggerEvent('onUserLogout', array($parameters, $options));
                
                        // Check if any of the plugins failed. If none did, success.
                
                        if (!in_array(false, $results, true)) {
                            // Use domain and path set in config for cookie if it exists.
                            $cookie_domain = $this->getCfg('cookie_domain', '');
                            $cookie_path = $this->getCfg('cookie_path', '/');
                            setcookie(JUtility::getHash('JLOGIN_REMEMBER'), false, time() - 86400, $cookie_path, $cookie_domain);
                
                            return true;
                        }
                
                        // Trigger onUserLoginFailure Event.
                        $this->triggerEvent('onUserLogoutFailure', array($parameters));
                
                        return false;
                    }
                
                    /**
                     * Gets the name of the current template.
                     *
                     * @param   array    $params  An optional associative array of configuration settings
                     *
                     * @return  string   System is the fallback.
                     *
                     * @since   11.1
                     */
                    public function getTemplate($params = false)
                    {
                        return 'system';
                    }
                
                    /**
                     * Returns the application JRouter object.
                     *
                     * @param   string  $name     The name of the application.
                     * @param   array   $options  An optional associative array of configuration settings.
                     *
                     * @return  JRouter  A JRouter object
                     *
                     * @since   11.1
                     */
                    static public function getRouter($name = null, array $options = array())
                    {
                        if (!isset($name)) {
                            $app = JFactory::getApplication();
                            $name = $app->getName();
                        }
                
                        jimport('joomla.application.router');
                        $router = JRouter::getInstance($name, $options);
                
                        if (JError::isError($router)) {
                            return null;
                        }
                
                        return $router;
                    }
                
                    /**
                     * This method transliterates a string into an URL
                     * safe string or returns a URL safe UTF-8 string
                     * based on the global configuration
                     *
                     * @param   string  $string  String to process
                     *
                     * @return  string  Processed string
                     *
                     * @since   11.1
                     */
                    static public function stringURLSafe($string)
                    {
                        if (JFactory::getConfig()->get('unicodeslugs') == 1) {
                            $output = JFilterOutput::stringURLUnicodeSlug($string);
                        }
                        else {
                            $output = JFilterOutput::stringURLSafe($string);
                        }
                
                        return $output;
                    }
                
                    /**
                     * Returns the application JPathway object.
                     *
                     * @param   string    $name     The name of the application.
                     * @param   array     $options  An optional associative array of configuration settings.
                     *
                     * @return  JPathway  A JPathway object
                     *
                     * @since   11.1
                     */
                    public function getPathway($name = null, $options = array())
                    {
                        if (!isset($name)) {
                            $name = $this->_name;
                        }
                
                        jimport('joomla.application.pathway');
                        $pathway = JPathway::getInstance($name, $options);
                
                        if (JError::isError($pathway)) {
                            return null;
                        }
                
                        return $pathway;
                    }
                
                    /**
                     * Returns the application JPathway object.
                     *
                     * @param   string  $name     The name of the application/client.
                     * @param   array   $options  An optional associative array of configuration settings.
                     *
                     * @return  JMenu  JMenu object.
                     *
                     * @since   11.1
                     */
                    public function getMenu($name = null, $options = array())
                    {
                        if (!isset($name)) {
                            $name = $this->_name;
                        }
                
                        jimport('joomla.application.menu');
                        $menu = JMenu::getInstance($name, $options);
                
                        if (JError::isError($menu)) {
                            return null;
                        }
                
                        return $menu;
                    }
                
                    /**
                     * Provides a secure hash based on a seed
                     *
                     * @param   string   $seed  Seed string.
                     *
                     * @return  string   A secure hash
                     *
                     * @since   11.1
                     */
                    public static function getHash($seed)
                    {
                        $conf = JFactory::getConfig();
                
                        return md5($conf->get('secret').$seed);
                    }
                
                    /**
                     * Create the configuration registry.
                     *
                     * @param   string  $file  The path to the configuration file
                     *
                     * @return   object  A JConfig object
                     *
                     * @since   11.1
                     */
                    protected function _createConfiguration($file)
                    {
                        jimport('joomla.registry.registry');
                
                        require_once $file;
                
                        // Create the JConfig object.
                        $config = new JConfig;
                
                        // Get the global configuration object.
                        $registry = JFactory::getConfig();
                
                        // Load the configuration values into the registry.
                        $registry->loadObject($config);
                
                        return $config;
                    }
                
                    /**
                     * Create the user session.
                     *
                     * Old sessions are flushed based on the configuration value for the cookie
                     * lifetime. If an existing session, then the last access time is updated.
                     * If a new session, a session id is generated and a record is created in
                     * the #__sessions table.
                     *
                     * @param   string    $name  The sessions name.
                     *
                     * @return  JSession  JSession on success. May call exit() on database error.
                     *
                     * @since   11.1
                     */
                    protected function _createSession($name)
                    {
                        $options = array();
                        $options['name'] = $name;
                
                        switch($this->_clientId)
                        {
                            case 0:
                                if ($this->getCfg('force_ssl') == 2) {
                                    $options['force_ssl'] = true;
                                }
                                break;
                
                            case 1:
                                if ($this->getCfg('force_ssl') >= 1) {
                                    $options['force_ssl'] = true;
                                }
                                break;
                        }
                
                        $session = JFactory::getSession($options);
                
                        //TODO: At some point we need to get away from having session data always in the db.
                
                        $db = JFactory::getDBO();
                
                        // Remove expired sessions from the database.
                        $time = time();
                        if ($time % 2) {
                            // The modulus introduces a little entropy, making the flushing less accurate
                            // but fires the query less than half the time.
                            $query = $db->getQuery(true);
                            $db->setQuery(
                                'DELETE FROM '.$query->qn('#__session') .
                                ' WHERE '.$query->qn('time').' < '.(int) ($time - $session->getExpire())
                            );
                            $db->query();
                        }
                
                        // Check to see the the session already exists.
                        if (($this->getCfg('session_handler') != 'database' && ($time % 2 || $session->isNew()))
                            ||
                            ($this->getCfg('session_handler') == 'database' && $session->isNew())
                        )
                        {
                            $this->checkSession();
                        }
                
                        return $session;
                    }
                
                    /**
                     * Checks the user session.
                     *
                     * If the session record doesn't exist, initialise it.
                     * If session is new, create session variables
                     *
                     * @return  void
                     *
                     * @since   11.1
                     */
                    public function checkSession()
                    {
                        $db         = JFactory::getDBO();
                        $session     = JFactory::getSession();
                        $user        = JFactory::getUser();
                
                        $query = $db->getQuery(true);
                        $db->setQuery(
                            'SELECT '.$query->qn('session_id') .
                            ' FROM '.$query->qn('#__session') .
                            ' WHERE '.$query->qn('session_id').' = '.$query->q($session->getId()), 0, 1
                        );
                        $exists = $db->loadResult();
                
                        // If the session record doesn't exist initialise it.
                        if (!$exists) {
                            if ($session->isNew()) {
                                $db->setQuery(
                                    'INSERT INTO '.$query->qn('#__session').' ('.$query->qn('session_id').', '.$query->qn('client_id').', '.$query->qn('time').')' .
                                    ' VALUES ('.$query->q($session->getId()).', '.(int) $this->getClientId().', '.(int) time().')'
                                );
                            }
                            else {
                                $db->setQuery(
                                    'INSERT INTO `#__session` (`session_id`, `client_id`, `guest`, `time`, `userid`, `username`)' .
                                    ' VALUES ('.$db->quote($session->getId()).', '.(int) $this->getClientId().', '.(int) $user->get('guest').', '.(int) $session->get('session.timer.start').', '.(int) $user->get('id').', '.$db->quote($user->get('username')).')'
                                );
                            }
                
                            // If the insert failed, exit the application.
                            if (!$db->query()) {
                                jexit($db->getErrorMSG());
                            }
                
                            // Session doesn't exist yet, so create session variables
                            if ($session->isNew()) {
                                $session->set('registry',    new JRegistry('session'));
                                $session->set('user',        new JUser());
                            }
                        }
                    }
                
                    /**
                     * Gets the client id of the current running application.
                     *
                     * @return  integer  A client identifier.
                     *
                     * @since   11.1
                     */
                    public function getClientId()
                    {
                        return $this->_clientId;
                    }
                
                    /**
                     * Is admin interface?
                     *
                     * @return  boolean  True if this application is administrator.
                     *
                     * @since   11.1
                     */
                    public function isAdmin()
                    {
                        return ($this->_clientId == 1);
                    }
                
                    /**
                     * Is site interface?
                     *
                     * @return  boolean  True if this application is site.
                     *
                     * @since   11.1
                     */
                    public function isSite()
                    {
                        return ($this->_clientId == 0);
                    }
                
                    /**
                     * Method to determine if the host OS is  Windows
                     *
                     * @return  boolean  True if Windows OS
                     *
                     * @since   11.1
                     */
                    static function isWinOS()
                    {
                        return strtoupper(substr(PHP_OS, 0, 3)) === 'WIN';
                    }
                
                    /**
                     * Returns the response as a string.
                     *
                     * @return  string  The response
                     *
                     * @since   11.1
                     */
                    public function __toString()
                    {
                        $compress = $this->getCfg('gzip', false);
                
                        return JResponse::toString($compress);
                    }
                }
                //----------------------class JApplication 结束                
                
                /**
                 * Joomla! Application class
                 *
                 * Provide many supporting API functions
                 *
                 * @package        Joomla.Administrator
                 * @final
                 * @since        1.5
                 */
                class JAdministrator extends JApplication
                {
                    /**
                     * Class constructor
                     *
                     * @param    array    An optional associative array of configuration settings.
                     * Recognized key values include 'clientId' (this list is not meant to be comprehensive).
                     *
                     * @since    1.5
                     */
                    public function __construct($config = array())
                    {
                        $config['clientId'] = 1;
                        parent::__construct($config);
                
                        //Set the root in the URI based on the application name
                        JURI::root(null, str_ireplace('/'.$this->getName(), '', JURI::base(true)));
                    }
                
                    /**
                     * Initialise the application.
                     *
                     * @param    array    $options    An optional associative array of configuration settings.
                     *
                     * @return    void
                     * @since    1.5
                     */
                    function initialise($options = array())
                    {
                        $config = JFactory::getConfig();
                
                        // if a language was specified it has priority
                        // otherwise use user or default language settings
                        if (empty($options['language']))
                        {
                            $user    = JFactory::getUser();
                            $lang    = $user->getParam('admin_language');
                
                            // Make sure that the user's language exists
                            if ($lang && JLanguage::exists($lang)) {
                                $options['language'] = $lang;
                            } else {
                                $params = JComponentHelper::getParams('com_languages');
                                $client    = JApplicationHelper::getClientInfo($this->getClientId());
                                $options['language'] = $params->get($client->name, $config->get('language','en-GB'));
                            }
                        }
                
                        // One last check to make sure we have something
                        if (!JLanguage::exists($options['language'])) {
                            $lang = $config->get('language','en-GB');
                            if (JLanguage::exists($lang)) {
                                $options['language'] = $lang;
                            } else {
                                $options['language'] = 'en-GB'; // as a last ditch fail to english
                            }
                        }
                
                        // Execute the parent initialise method.
                        parent::initialise($options);
                
                        // Load Library language
                        $lang = JFactory::getLanguage();
                        $lang->load('lib_joomla', JPATH_ADMINISTRATOR);
                    }
                
                    /**
                     * Route the application
                     *
                     * @return    void
                     * @since    1.5
                     */
                    public function route()
                    {
                        $uri = JURI::getInstance();
                
                        if ($this->getCfg('force_ssl') >= 1 && strtolower($uri->getScheme()) != 'https') {
                            //forward to https
                            $uri->setScheme('https');
                            $this->redirect((string)$uri);
                        }
                
                        // Trigger the onAfterRoute event.
                        JPluginHelper::importPlugin('system');
                        $this->triggerEvent('onAfterRoute');
                    }
                
                    /**
                     * Return a reference to the JRouter object.
                     *
                     * @return    JRouter
                     * @since    1.5
                     */
                    static public function getRouter($name = null, array $options = array())
                    {
                        $router = parent::getRouter('administrator');
                        return $router;
                    }
                
                    /**
                     * Dispatch the application
                     *
                     * @param    string    $component    The component to dispatch.
                     *
                     * @return    void
                     * @since    1.5
                     */
                    public function dispatch($component = null)
                    {
                        try
                        {
                            if ($component === null) {
                                $component = JAdministratorHelper::findOption();
                            }
                
                            $document    = JFactory::getDocument();
                            $user        = JFactory::getUser();
                
                            switch ($document->getType()) {
                                case 'html':
                                    $document->setMetaData('keywords', $this->getCfg('MetaKeys'));
                                    break;
                
                                default:
                                    break;
                            }
                            $document->setTitle($this->getCfg('sitename'). ' - ' .JText::_('JADMINISTRATION'));
                            $document->setDescription($this->getCfg('MetaDesc'));
                
                            $contents = JComponentHelper::renderComponent($component);
                            $document->setBuffer($contents, 'component');                            
                
                            // Trigger the onAfterDispatch event.
                            JPluginHelper::importPlugin('system');
                            $this->triggerEvent('onAfterDispatch');
                        }
                        // Mop up any uncaught exceptions.
                        catch (Exception $e)
                        {
                            $code = $e->getCode();
                            JError::raiseError($code ? $code : 500, $e->getMessage());
                        }
                    }
                
                    /**
                     * Display the application.
                     *
                     * @return    void
                     * @since    1.5
                     */
                    public function render()
                    {
                        $component    = JRequest::getCmd('option', 'com_login');
                        $template    = $this->getTemplate(true);
                        $file        = JRequest::getCmd('tmpl', 'index');
                
                        if ($component == 'com_login') {
                            $file = 'login';
                        }
                
                        // Safety check for when configuration.php root_user is in use.
                        $config        = JFactory::getConfig();
                        $rootUser    = $config->get('root_user');
                        if (property_exists('JConfig', 'root_user') &&
                            (JFactory::getUser()->get('username') == $rootUser || JFactory::getUser()->id === (string) $rootUser)) {
                            JError::raiseNotice(200, JText::sprintf('JWARNING_REMOVE_ROOT_USER', 'index.php?option=com_config&task=application.removeroot&'. JUtility::getToken() .'=1'));
                        }
                
                        $params = array(
                            'template'    => $template->template,
                            'file'        => $file.'.php',
                            'directory'    => JPATH_THEMES,
                            'params'    => $template->params
                        );
                
                        $document = JFactory::getDocument();
                        $document->parse($params);
                        $this->triggerEvent('onBeforeRender');
                        $data = $document->render(false, $params);
                        JResponse::setBody($data);
                        $this->triggerEvent('onAfterRender');
                
                    }
                
                    /**
                     * Login authentication function
                     *
                     * @param    array    Array('username' => string, 'password' => string)
                     * @param    array    Array('remember' => boolean)
                     *
                     * @return    boolean True on success.
                     * @see        JApplication::login
                     * @since    1.5
                     */
                    public function login($credentials, $options = array())
                    {
                        //The minimum group
                        $options['group'] = 'Public Backend';
                
                        //Make sure users are not autoregistered
                        $options['autoregister'] = false;
                
                        //Set the application login entry point
                        if (!array_key_exists('entry_url', $options)) {
                            $options['entry_url'] = JURI::base().'index.php?option=com_users&task=login';
                        }
                
                        // Set the access control action to check.
                        $options['action'] = 'core.login.admin';
                
                        $result = parent::login($credentials, $options);
                        
                        
                        if (!JError::isError($result))
                        {
                                
                            $lang = JRequest::getCmd('lang');
                            $lang = preg_replace('/[^A-Z-]/i', '', $lang);
                            $this->setUserState('application.lang', $lang );
                
                            JAdministrator::purgeMessages();
                        }
                        
                        return $result;
                    }
                
                    /**
                     * Get the template
                     *
                     * @return    string    The template name
                     * @since    1.0
                     */
                    public function getTemplate($params = false)
                    {
                        static $template;
                
                        if (!isset($template))
                        {
                            $admin_style = JFactory::getUser()->getParam('admin_style');
                            // Load the template name from the database
                            $db = JFactory::getDbo();
                            $query = $db->getQuery(true);
                            $query->select('template, s.params');
                            $query->from('#__template_styles as s');
                            $query->leftJoin('#__extensions as e ON e.type='.$db->quote('template').' AND e.element=s.template AND e.client_id=s.client_id');
                            if ($admin_style)
                            {
                                $query->where('s.client_id = 1 AND id = '.(int)$admin_style. ' AND e.enabled = 1','OR');
                            }
                            $query->where('s.client_id = 1 AND home = 1','OR');
                            $query->order('home');
                            $db->setQuery($query);
                            $template = $db->loadObject();
                
                            $template->template = JFilterInput::getInstance()->clean($template->template, 'cmd');
                            $template->params = new JRegistry($template->params);
                
                            if (!file_exists(JPATH_THEMES . '/' . $template->template . '/index.php'))
                            {
                                $template->params = new JRegistry();
                                $template->template = 'bluestork';
                            }
                        }
                        if ($params) {
                            return $template;
                        }
                
                        return $template->template;
                    }
                
                    /**
                     * Purge the jos_messages table of old messages
                     *
                     * @return    void
                     * @since    1.5
                     */
                    public static function purgeMessages()
                    {
                        $db        = JFactory::getDbo();
                        $user    = JFactory::getUser();
                
                        $userid = $user->get('id');
                
                        $query = 'SELECT *'
                        . ' FROM #__messages_cfg'
                        . ' WHERE user_id = ' . (int) $userid
                        . ' AND cfg_name = "auto_purge"'
                        ;
                        $db->setQuery($query);
                        $config = $db->loadObject();
                
                        // check if auto_purge value set
                        if (is_object($config) and $config->cfg_name == 'auto_purge') {
                            $purge    = $config->cfg_value;
                        } else {
                            // if no value set, default is 7 days
                            $purge    = 7;
                        }
                        // calculation of past date
                
                        // if purge value is not 0, then allow purging of old messages
                        if ($purge > 0) {
                            // purge old messages at day set in message configuration
                            $past = JFactory::getDate(time() - $purge * 86400);
                            $pastStamp = $past->toMySQL();
                
                            $query = 'DELETE FROM #__messages'
                            . ' WHERE date_time < ' . $db->Quote($pastStamp)
                            . ' AND user_id_to = ' . (int) $userid
                            ;
                            $db->setQuery($query);
                            $db->query();
                        }
                    }
                }
                            //-------------------/administrator/includes/application.php结束

            
    //----------------joomla.application.application结束
    
    // Import the factory library.
  //JLoader::import( 'joomla.factory'     );
            abstract class JFactory
            {
                public static $application = null;
                public static $cache = null;
                public static $config = null;
                public static $session = null;
                public static $language = null;
                public static $document = null;
                public static $acl = null;
                public static $database = null;
                public static $mailer = null;
            
                /**
                 * Get a application object
                 *
                 * Returns the global {@link JApplication} object, only creating it
                 * if it doesn't already exist.
                 *
                 * @param   mixed   $id      A client identifier or name.
                 * @param   array   $config  An optional associative array of configuration settings.
                 * @param   string  $prefix  Application prefix
                 *
                 * @return  JApplication object
                 * @since   11.1
                 *
                 * @see    JApplication
                 */
                public static function getApplication($id = null, $config = array(), $prefix='J')
                {
                    if (!self::$application) {
                        //jimport('joomla.application.application'); //zzcity 库文件需要修改，提到本类外面
            
                        if (!$id) {
                            JError::raiseError(500, 'Application Instantiation Error');
                        }
            
                        self::$application = JApplication::getInstance($id, $config, $prefix);
                    }
            
                    return self::$application;
                }
            
                /**
                 * Get a configuration object
                 *
                 * Returns the global {@link JRegistry} object, only creating it
                 * if it doesn't already exist.
                 *
                 * @param   string   $file   The path to the configuration file
                 * @param   string   $type   The type of the configuration file
                 *
                 * @return  JRegistry object
                 * @since   11.1
                 *
                 *  @see JRegistry
                 */
                public static function getConfig($file = null, $type = 'PHP')
                {
                    if (!self::$config) {
                        if ($file === null) {
                            $file = JPATH_PLATFORM.'/config.php';
                        }
            
                        self::$config = self::_createConfig($file, $type);
                    }
            
                    return self::$config;
                }
            
                /**
                 * Get a session object
                 *
                 * Returns the global {@link JSession} object, only creating it
                 * if it doesn't already exist.
                 *
                 * @param   array  $options  An array containing session options
                 *
                 * @see JSession
                 *
                 * @return JSession object
                 * @since   11.1
                 *
                 */
                public static function getSession($options = array())
                {
                    if (!self::$session) {
                        self::$session = self::_createSession($options);
                    }
            
                    return self::$session;
                }
            
                /**
                 * Get a language object
                 *
                 * Returns the global {@link JLanguage} object, only creating it
                 * if it doesn't already exist.
                 *
                 * @return JLanguage object
                 * @since   11.1
                 *
                 * @see JLanguage
                 */
                public static function getLanguage()
                {
                    if (!self::$language) {
                        self::$language = self::_createLanguage();
                    }
            
                    return self::$language;
                }
            
                /**
                 * Get a document object
                 *
                 * Returns the global {@link JDocument} object, only creating it
                 * if it doesn't already exist.
                 *
                 * @return  JDocument object
                 * @since   11.1
                 *
                 * @see     JDocument
                 */
                public static function getDocument()
                {
                    if (!self::$document) {
                        self::$document = self::_createDocument();
                    }
            
                    return self::$document;
                }
            
                /**
                 * Get an user object
                 *
                 * Returns the global {@link JUser} object, only creating it
                 * if it doesn't already exist.
                 *
                 * @param   integer  $id  The user to load - Can be an integer or string - If string, it is converted to ID automatically.
                 *
                 * @return  JUser object
                 * @since   11.1
                 *
                 * @see    JUser
                 */
                public static function getUser($id = null)
                {
                    jimport('joomla.user.user');
            
                    if (is_null($id)) {
                        $instance = self::getSession()->get('user');
                        if (!($instance instanceof JUser)) {
                            $instance = JUser::getInstance();
                        }
                    }
                    else {
                        $instance = JUser::getInstance($id);
                    }
            
                    return $instance;
                }
            
                /**
                 * Get a cache object
                 *
                 * Returns the global {@link JCache} object
                 *
                 * @param   string  $group    The cache group name
                 * @param   string  $handler  The handler to use
                 * @param   string  $storage  The storage method
                 *
                 * @return  JCache object
                 *
                 * @see     JCache
                 */
                public static function getCache($group = '', $handler = 'callback', $storage = null)
                {
                    $hash = md5($group.$handler.$storage);
                    if (isset(self::$cache[$hash])) {
                        return self::$cache[$hash];
                    }
                    $handler = ($handler == 'function') ? 'callback' : $handler;
            
                    $conf = self::getConfig();
            
                    $options = array('defaultgroup'    => $group );
            
                    if (isset($storage)) {
                        $options['storage'] = $storage;
                    }
            
                    jimport('joomla.cache.cache');
            
                    $cache = JCache::getInstance($handler, $options);
            
                    self::$cache[$hash] = $cache;
            
                    return self::$cache[$hash];
                }
            
                /**
                 * Get an authorization object
                 *
                 * Returns the global {@link JACL} object, only creating it
                 * if it doesn't already exist.
                 *
                 * @return JACL object
                 */
                public static function getACL()
                {
                    if (!self::$acl) {
                        jimport('joomla.access.access');
                        self::$acl = new JAccess;
                    }
            
                    return self::$acl;
                }
            
                /**
                 * Get a database object
                 *
                 * Returns the global {@link JDatabase} object, only creating it
                 * if it doesn't already exist.
                 *
                 * @return JDatabase object
                 * @since  11.1
                 *
                 * @see    JDatabase
                 */
                public static function getDbo()
                {
                    if (!self::$database) {
                        //get the debug configuration setting
                        $conf    = self::getConfig();
                        $debug    = $conf->get('debug');
            
                        self::$database = self::_createDbo();
                        self::$database->debug($debug);
                    }
            
                    return self::$database;
                }
            
                /**
                 * Get a mailer object
                 *
                 * Returns the global {@link JMail} object, only creating it
                 * if it doesn't already exist
                 *
                 * @return JMail object
                 * @since  11.1
                 *
                 * @see JMail
                 */
                public static function getMailer()
                {
                    if (!self::$mailer) {
                        self::$mailer = self::_createMailer();
                    }
                    $copy    = clone self::$mailer;
            
                    return $copy;
                }
            
                /**
                 * Get a parsed XML Feed Source
                 *
                 * @param   string   $url         url for feed source
                 * @param   integer  $cache_time  time to cache feed for (using internal cache mechanism)
                 *
                 * @return  mixed    SimplePie parsed object on success, false on failure
                 * @since   11.1
                 */
                public static function getFeedParser($url, $cache_time = 0)
                {
                    jimport('simplepie.simplepie');
            
                    $cache = self::getCache('feed_parser', 'callback');
            
                    if ($cache_time > 0) {
                        $cache->setLifeTime($cache_time);
                    }
            
                    $simplepie = new SimplePie(null, null, 0);
            
                    $simplepie->enable_cache(false);
                    $simplepie->set_feed_url($url);
                    $simplepie->force_feed(true);
            
                    $contents =  $cache->get(array($simplepie, 'init'), null, false, false);
            
                    if ($contents) {
                        return $simplepie;
                    }
                    else {
                        JError::raiseWarning('SOME_ERROR_CODE', JText::_('JLIB_UTIL_ERROR_LOADING_FEED_DATA'));
                    }
            
                    return false;
                }
            
                /**
                 * Get an XML document
                 *
                 * @param   string  $type     The type of XML parser needed 'DOM', 'RSS' or 'Simple'
                 * @param   array   $options  ['rssUrl'] the rss url to parse when using "RSS", ['cache_time'] with '
                 *                             RSS' - feed cache time. If not defined defaults to 3600 sec
                 *
                 * @return  object  Parsed XML document object
                 * @since   11.1
                 *
                 * @deprecated    12.1
                 */
                public static function getXMLParser($type = '', $options = array())
                {
                    $doc = null;
            
                    switch (strtolower($type))
                    {
                        case 'rss' :
                        case 'atom' :
                            $cache_time = isset($options['cache_time']) ? $options['cache_time'] : 0;
                            $doc = self::getFeedParser($options['rssUrl'], $cache_time);
                            break;
            
                        case 'simple':
                            // JError::raiseWarning('SOME_ERROR_CODE', 'JSimpleXML is deprecated. Use self::getXML instead');
                            jimport('joomla.utilities.simplexml');
                            $doc = new JSimpleXML;
                            break;
            
                        case 'dom':
                            JError::raiseWarning('SOME_ERROR_CODE', JText::_('JLIB_UTIL_ERROR_DOMIT'));
                            $doc = null;
                            break;
            
                        default :
                            $doc = null;
                    }
            
                    return $doc;
                }
            
                /**
                 * Reads a XML file.
                 *
                 * @param   string   $data    Full path and file name.
                 * @param   boolean  $isFile  true to load a file or false to load a string.
                 *
                 * @return  mixed    JXMLElement on success or false on error.
                 * @since   11.1
                 *
                 * @todo This may go in a separate class - error reporting may be improved.
                 * @see     JXMLElement
                 */
                public static function getXML($data, $isFile = true)
                {
                    jimport('joomla.utilities.xmlelement');
            
                    // Disable libxml errors and allow to fetch error information as needed
                    libxml_use_internal_errors(true);
            
                    if ($isFile) {
                        // Try to load the XML file
                        $xml = simplexml_load_file($data, 'JXMLElement');
                    }
                    else {
                        // Try to load the XML string
                        $xml = simplexml_load_string($data, 'JXMLElement');
                    }
            
                    if (empty($xml)) {
                        // There was an error
                        JError::raiseWarning(100, JText::_('JLIB_UTIL_ERROR_XML_LOAD'));
            
                        if ($isFile) {
                            JError::raiseWarning(100, $data);
                        }
            
                        foreach (libxml_get_errors() as $error)
                        {
                            JError::raiseWarning(100, 'XML: '.$error->message);
                        }
                    }
            
                    return $xml ;
                }
            
                /**
                 * Get an editor object
                 *
                 * @param   string  $editor The editor to load, depends on the editor plugins that are installed
                 *
                 * @return JEditor object
                 */
                public static function getEditor($editor = null)
                {
                    jimport('joomla.html.editor');
            
                    //get the editor configuration setting
                    if (is_null($editor)) {
                        $conf    = self::getConfig();
                        $editor    = $conf->get('editor');
                    }
            
                    return JEditor::getInstance($editor);
                }
            
                /**
                 * Return a reference to the {@link JURI} object
                 *
                 * @param   string  $uri   uri name
                 *
                 * @return  JURI object
                 * @since   11.1
                 *
                 * @see JURI
                 */
                public static function getURI($uri = 'SERVER')
                {
                    jimport('joomla.environment.uri');
            
                    return JURI::getInstance($uri);
                }
            
                /**
                 * Return the {@link JDate} object
                 *
                 * @param   mixed  $time      The initial time for the JDate object
                 * @param   mixed  $tzOffset  The timezone offset.
                 *
                 * @return  JDate object
                 * @since   11.1
                 *
                 * @see JDate
                 */
                public static function getDate($time = 'now', $tzOffset = null)
                {
                    jimport('joomla.utilities.date');
                    static $instances;
                    static $classname;
                    static $mainLocale;
            
                    if (!isset($instances)) {
                        $instances = array();
                    }
            
                    $language    = self::getLanguage();
                    $locale        = $language->getTag();
            
                    if (!isset($classname) || $locale != $mainLocale) {
                        //Store the locale for future reference
                        $mainLocale = $locale;
            
                        if ($mainLocale !== false) {
                            $classname = str_replace('-', '_', $mainLocale).'Date';
            
                            if (!class_exists($classname)) {
                                //The class does not exist, default to JDate
                                $classname = 'JDate';
                            }
                        }
                        else {
                            //No tag, 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;
                    return $tmp;
                }
            
            
                /**
                 * Create a configuration object
                 *
                 * @param   string  $file       The path to the configuration file.
                 * @param   string  $type       The type of the configuration file.
                 * @param   string  $namespace  The namespace of the configuration file.
                 *
                 * @return  JRegistry
                 * @since   11.1
                 *
                 * @see JRegistry
                 */
                protected static function _createConfig($file, $type = 'PHP', $namespace = '')
                {
                    jimport('joomla.registry.registry');
            
                    if (is_file($file)) {
                        include_once $file;
                    }
            
                    // Create the registry with a default namespace of config
                    $registry = new JRegistry;
            
                    // Sanitize the namespace.
                    $namespace = ucfirst((string) preg_replace('/[^A-Z_]/i', '', $namespace));
            
                    // Build the config name.
                    $name = 'JConfig'.$namespace;
            
                    // Handle the PHP configuration type.
                    if ($type == 'PHP' && class_exists($name)) {
                        // Create the JConfig object
                        $config = new $name;
            
                        // Load the configuration values into the registry
                        $registry->loadObject($config);
                    }
            
                    return $registry;
                }
            
                /**
                 * Create a session object
                 *
                 * @param   array  $options An array containing session options
                 *
                 * @return  JSession object
                 * @since   11.1
                 */
                protected static function _createSession($options = array())
                {
                    jimport('joomla.session.session');
            
                    // Get the editor configuration setting
                    $conf        = self::getConfig();
                    $handler    = $conf->get('session_handler', 'none');
            
                    // Config time is in minutes
                    $options['expire'] = ($conf->get('lifetime')) ? $conf->get('lifetime') * 60 : 900;
            
                    $session = JSession::getInstance($handler, $options);
                    if ($session->getState() == 'expired') {
                        $session->restart();
                    }
            
                    return $session;
                }
            
                /**
                 * Create an database object
                 *
                 * @return JDatabase object
                 * @since   11.1
                 *
                 * @see JDatabase
                 */
                protected static function _createDbo()
                {
                    jimport('joomla.database.database');
                    jimport('joomla.database.table');
            
                    $conf = self::getConfig();
            
                    $host        = $conf->get('host');
                    $user        = $conf->get('user');
                    $password    = $conf->get('password');
                    $database    = $conf->get('db');
                    $prefix        = $conf->get('dbprefix');
                    $driver        = $conf->get('dbtype');
                    $debug        = $conf->get('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: ' . (string) $db);
                    }
            
                    if ($db->getErrorNum() > 0) {
                        JError::raiseError(500, JText::sprintf('JLIB_UTIL_ERROR_CONNECT_DATABASE', $db->getErrorNum(), $db->getErrorMsg()));
                    }
            
                    $db->debug($debug);
                    return $db;
                }
            
                /**
                 * Create a mailer object
                 *
                 * @return  JMail object
                 * @since   11.1
                 *
                 * @see     JMail
                 */
                protected static function _createMailer()
                {
                    jimport('joomla.mail.mail');
            
                    $conf    = self::getConfig();
            
                    $sendmail    = $conf->get('sendmail');
                    $smtpauth    =  ($conf->get('smtpauth') == 0) ? null : 1;
                    $smtpuser    = $conf->get('smtpuser');
                    $smtppass    = $conf->get('smtppass');
                    $smtphost    = $conf->get('smtphost');
                    $smtpsecure    = $conf->get('smtpsecure');
                    $smtpport    = $conf->get('smtpport');
                    $mailfrom    = $conf->get('mailfrom');
                    $fromname    = $conf->get('fromname');
                    $mailer        = $conf->get('mailer');
            
                    // Create a JMail object
                    $mail        = JMail::getInstance();
            
                    // Set default sender without Reply-to
                    $mail->SetFrom(JMailHelper::cleanLine($mailfrom), JMailHelper::cleanLine($fromname), 0);
            
                    // 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->IsSendmail();
                            break;
            
                        default :
                            $mail->IsMail();
                            break;
                    }
            
                    return $mail;
                }
            
                /**
                 * Create a language object
                 *
                 * @return JLanguage object
                 * @since   11.1
                 *
                 * @see JLanguage
                 */
                protected static function _createLanguage()
                {
                    jimport('joomla.language.language');
            
                    $conf    = self::getConfig();
                    $locale    = $conf->get('language');
                    $debug    = $conf->get('debug_lang');
                    $lang    = JLanguage::getInstance($locale, $debug);
            
                    return $lang;
                }
            
                /**
                 * Create a document object
                 *
                 * @return  JDocument object
                 * @since   11.1
                 *
                 * @see     JDocument
                 */
                protected static function _createDocument()
                {
                    jimport('joomla.document.document');
            
                    $lang    = self::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'
                    );
            
                    return JDocument::getInstance($type, $attributes);
                }
            
                /**
                 * Creates a new stream object with appropriate prefix
                 *
                 * @param   boolean  $use_prefix     Prefix the connections for writing
                 * @param   boolean  $use_network    Use network if available for writing; use false to disable (e.g. FTP, SCP)
                 * @param   string   $ua             UA User agent to use
                 * @param   boolean  $uamask         User agent masking (prefix Mozilla)
                 *
                 * @return  JStream
                 * @since   11.1
                 *
                 * @see JStream
                 */
                public static function getStream($use_prefix=true, $use_network=true, $ua=null, $uamask=false)
                {
                    jimport('joomla.filesystem.stream');
            
                    // Setup the context; Joomla! UA and overwrite
                    $context = array();
                    $version = new JVersion;
                    // set the UA for HTTP and overwrite for FTP
                    $context['http']['user_agent'] = $version->getUserAgent($ua, $uamask);
                    $context['ftp']['overwrite'] = true;
            
                    if ($use_prefix) {
                        jimport('joomla.client.helper');
                        $FTPOptions = JClientHelper::getCredentials('ftp');
                        $SCPOptions = JClientHelper::getCredentials('scp');
            
                        if ($FTPOptions['enabled'] == 1 && $use_network) {
                            $prefix = 'ftp://'. $FTPOptions['user'] .':'. $FTPOptions['pass'] .'@'. $FTPOptions['host'];
                            $prefix .= $FTPOptions['port'] ? ':'. $FTPOptions['port'] : '';
                            $prefix .= $FTPOptions['root'];
                        }
                        elseif ($SCPOptions['enabled'] == 1 && $use_network) {
                            $prefix = 'ssh2.sftp://'. $SCPOptions['user'] .':'. $SCPOptions['pass'] .'@'. $SCPOptions['host'];
                            $prefix .= $SCPOptions['port'] ? ':'. $SCPOptions['port'] : '';
                            $prefix .= $SCPOptions['root'];
                        }
                        else {
                            $prefix = JPATH_ROOT . '/';
                        }
            
                        $retval = new JStream($prefix, JPATH_ROOT, $context);
                    }
                    else {
                        $retval = new JStream('', '', $context);
                    }
            
                    return $retval;
                }
            }
                //-----------------joomla.factory
  
    // Import the exception and error handling libraries.
    JLoader::import('joomla.error.error');
    JLoader::import('joomla.error.exception');
  
    /*
     * If the HTTP_HOST environment variable is set we assume a Web request and
     * thus we import the request library and most likely clean the request input.
     */
    if (isset($_SERVER['HTTP_HOST'])) {
        //JLoader::import('joomla.environment.request'); //zzcity 替换原文件
        
                jimport('joomla.filter.filterinput');
                jimport('joomla.log.log');
                
                /**
                 * Create the request global object
                 */
                $GLOBALS['_JREQUEST'] = array();
                
                /**
                 * Set the available masks for cleaning variables
                 */
                define('JREQUEST_NOTRIM',    1);
                define('JREQUEST_ALLOWRAW',    2);
                define('JREQUEST_ALLOWHTML', 4);
                
                /**
                 * JRequest Class
                 *
                 * This class serves to provide the Joomla Framework with a common interface to access
                 * request variables.  This includes $_POST, $_GET, and naturally $_REQUEST.  Variables
                 * can be passed through an input filter to avoid injection or returned raw.
                 *
                 * @package     Joomla.Platform
                 * @subpackage  Environment
                 * @deprecated   12.1  Get the JInput object from the application instead
                 * @since       11.1
                 */
                class JRequest
                {
                    /**
                     * Gets the full request path.
                     *
                     * @return  string
                     *
                     * @since   11.1
                     *
                     * @deprecated   12.1
                     */
                    public static function getURI()
                    {
                        // Deprecation warning.
                        JLog::add('JRequest::getURI() is deprecated.', JLog::WARNING, 'deprecated');
                
                        $uri = JFactory::getURI();
                        return $uri->toString(array('path', 'query'));
                    }
                
                    /**
                     * Gets the request method.
                     *
                     * @return  string
                     *
                     * @since   11.1
                     *
                     * @deprecated   12.1
                     */
                    public static function getMethod()
                    {
                        // Deprecation warning.
                        JLog::add('JRequest::getMethod() is deprecated.', JLog::WARNING, 'deprecated');
                
                        $method = strtoupper($_SERVER['REQUEST_METHOD']);
                        return $method;
                    }
                
                    /**
                     * Fetches and returns a given variable.
                     *
                     * The default behaviour is fetching variables depending on the
                     * current request method: GET and HEAD will result in returning
                     * an entry from $_GET, POST and PUT will result in returning an
                     * entry from $_POST.
                     *
                     * You can force the source by setting the $hash parameter:
                     *
                     *    post    $_POST
                     *    get     $_GET
                     *    files   $_FILES
                     *    cookie  $_COOKIE
                     *    env     $_ENV
                     *    server  $_SERVER
                     *    method  via current $_SERVER['REQUEST_METHOD']
                     *    default $_REQUEST
                     *
                     * @param   string   $name     Variable name.
                     * @param   string   $default  Default value if the variable does not exist.
                     * @param   string   $hash     Where the var should come from (POST, GET, FILES, COOKIE, METHOD).
                     * @param   string   $type     Return type for the variable, for valid values see {@link JFilterInput::clean()}.
                     * @param   integer  $mask     Filter mask for the variable.
                     *
                     * @return  mixed  Requested variable.
                     *
                     * @since   11.1
                     *
                     * @deprecated   12.1  Use JInput::Get
                     */
                    public static function getVar($name, $default = null, $hash = 'default', $type = 'none', $mask = 0)
                    {
                        // Deprecation warning.
                        JLog::add('JRequest::getVar is deprecated.', JLog::WARNING, 'deprecated');
                
                        // Ensure hash and type are uppercase
                        $hash = strtoupper($hash);
                        if ($hash === 'METHOD') {
                            $hash = strtoupper($_SERVER['REQUEST_METHOD']);
                        }
                        $type    = strtoupper($type);
                        $sig    = $hash.$type.$mask;
                
                        // Get the input hash
                        switch ($hash)
                        {
                            case 'GET':
                                $input = &$_GET;
                                break;
                            case 'POST':
                                $input = &$_POST;
                                break;
                            case 'FILES':
                                $input = &$_FILES;
                                break;
                            case 'COOKIE':
                                $input = &$_COOKIE;
                                break;
                            case 'ENV':
                                $input = &$_ENV;
                                break;
                            case 'SERVER':
                                $input = &$_SERVER;
                                break;
                            default:
                                $input = &$_REQUEST;
                                $hash = 'REQUEST';
                                break;
                        }
                
                        if (isset($GLOBALS['_JREQUEST'][$name]['SET.'.$hash]) && ($GLOBALS['_JREQUEST'][$name]['SET.'.$hash] === true)) {
                            // Get the variable from the input hash
                            $var = (isset($input[$name]) && $input[$name] !== null) ? $input[$name] : $default;
                            $var = self::_cleanVar($var, $mask, $type);
                        }
                        elseif (!isset($GLOBALS['_JREQUEST'][$name][$sig]))
                        {
                            if (isset($input[$name]) && $input[$name] !== null) {
                                // Get the variable from the input hash and clean it
                                $var = self::_cleanVar($input[$name], $mask, $type);
                
                                // Handle magic quotes compatability
                                if (get_magic_quotes_gpc() && ($var != $default) && ($hash != 'FILES')) {
                                    $var = self::_stripSlashesRecursive($var);
                                }
                
                                $GLOBALS['_JREQUEST'][$name][$sig] = $var;
                            }
                            elseif ($default !== null) {
                                // Clean the default value
                                $var = self::_cleanVar($default, $mask, $type);
                            }
                            else {
                                $var = $default;
                            }
                        } else {
                            $var = $GLOBALS['_JREQUEST'][$name][$sig];
                        }
                
                        return $var;
                    }
                
                    /**
                     * Fetches and returns a given filtered variable. The integer
                     * filter will allow only digits and the - sign to be returned. This is currently
                     * only a proxy function for getVar().
                     *
                     * See getVar() for more in-depth documentation on the parameters.
                     *
                     * @param   string  $name     Variable name.
                     * @param   string  $default  Default value if the variable does not exist.
                     * @param   string  $hash     Where the var should come from (POST, GET, FILES, COOKIE, METHOD).
                     *
                     * @return  integer  Requested variable.
                     *
                     * @since   11.1
                     *
                     * @deprecated   12.1
                     */
                    public static function getInt($name, $default = 0, $hash = 'default')
                    {
                        // Deprecation warning.
                        JLog::add('JRequest::getVar is deprecated.', JLog::WARNING, 'deprecated');
                
                        return self::getVar($name, $default, $hash, 'int');
                    }
                
                    /**
                     * Fetches and returns a given filtered variable. The unsigned integer
                     * filter will allow only digits to be returned. This is currently
                     * only a proxy function for getVar().
                     *
                     * See getVar() for more in-depth documentation on the parameters.
                     *
                     * @param       string  $name           Variable name.
                     * @param       string  $default        Default value if the variable does not exist.
                     * @param       string  $hash           Where the var should come from (POST, GET, FILES, COOKIE, METHOD).
                     *
                     * @return      integer Requested variable.
                     *
                     * @since       11.1
                     * @deprecated   12.1
                     */
                    public static function getUInt($name, $default = 0, $hash = 'default')
                    {
                        // Deprecation warning.
                        JLog::add('JRequest::getUInt is deprecated.', JLog::WARNING, 'deprecated');
                
                        return self::getVar($name, $default, $hash, 'uint');
                    }
                
                    /**
                     * Fetches and returns a given filtered variable.  The float
                     * filter only allows digits and periods.  This is currently
                     * only a proxy function for getVar().
                     *
                     * See getVar() for more in-depth documentation on the parameters.
                     *
                     * @param   string  $name     Variable name.
                     * @param   string  $default  Default value if the variable does not exist.
                     * @param   string  $hash     Where the var should come from (POST, GET, FILES, COOKIE, METHOD).
                     *
                     * @return  float  Requested variable.
                     *
                     * @since   11.1
                     *
                     * @deprecated   12.1
                     */
                    public static function getFloat($name, $default = 0.0, $hash = 'default')
                    {
                        // Deprecation warning.
                        JLog::add('JRequest::getFloat is deprecated.', JLog::WARNING, 'deprecated');
                
                        return self::getVar($name, $default, $hash, 'float');
                    }
                
                    /**
                     * Fetches and returns a given filtered variable. The bool
                     * filter will only return true/false bool values. This is
                     * currently only a proxy function for getVar().
                     *
                     * See getVar() for more in-depth documentation on the parameters.
                     *
                     * @param    string    $name        Variable name.
                     * @param    string    $default    Default value if the variable does not exist.
                     * @param    string    $hash        Where the var should come from (POST, GET, FILES, COOKIE, METHOD).
                     *
                     * @return   bool  Requested variable.
                     *
                     * @since    11.1
                     *
                     * @deprecated   12.1
                     */
                    public static function getBool($name, $default = false, $hash = 'default')
                    {
                        // Deprecation warning.
                        JLog::add('JRequest::getBool is deprecated.', JLog::WARNING, 'deprecated');
                
                        return self::getVar($name, $default, $hash, 'bool');
                    }
                
                    /**
                     * Fetches and returns a given filtered variable. The word
                     * filter only allows the characters [A-Za-z_]. This is currently
                     * only a proxy function for getVar().
                     *
                     * See getVar() for more in-depth documentation on the parameters.
                     *
                     * @param   string  $name     Variable name.
                     * @param   string  $default  Default value if the variable does not exist.
                     * @param   string  $hash     Where the var should come from (POST, GET, FILES, COOKIE, METHOD).
                     *
                     * @return  string  Requested variable.
                     *
                     * @since   11.1
                     *
                     * @deprecated   12.1
                     */
                    public static function getWord($name, $default = '', $hash = 'default')
                    {
                        // Deprecation warning.
                        JLog::add('JRequest::getWord is deprecated.', JLog::WARNING, 'deprecated');
                
                        return self::getVar($name, $default, $hash, 'word');
                    }
                
                    /**
                     * Cmd (Word and Integer0 filter
                     *
                     * Fetches and returns a given filtered variable. The cmd
                     * filter only allows the characters [A-Za-z0-9.-_]. This is
                     * currently only a proxy function for getVar().
                     *
                     * See getVar() for more in-depth documentation on the parameters.
                     *
                     * @param   string   $name     Variable name
                     * @param   string   $default  Default value if the variable does not exist
                     * @param   string   $hash     Where the var should come from (POST, GET, FILES, COOKIE, METHOD)
                     *
                     * @return  string   Requested variable
                     *
                     * @since   11.1
                     * @deprecated   12.1
                     */
                    public static function getCmd($name, $default = '', $hash = 'default')
                    {
                        // Deprecation warning.
                        JLog::add('JRequest::getCmd is deprecated.', JLog::WARNING, 'deprecated');
                
                        return self::getVar($name, $default, $hash, 'cmd');
                    }
                
                    /**
                     * Fetches and returns a given filtered variable. The string
                     * filter deletes 'bad' HTML code, if not overridden by the mask.
                     * This is currently only a proxy function for getVar().
                     *
                     * See getVar() for more in-depth documentation on the parameters.
                     *
                     * @param   string   $name     Variable name
                     * @param   string   $default  Default value if the variable does not exist
                     * @param   string   $hash     Where the var should come from (POST, GET, FILES, COOKIE, METHOD)
                     * @param   integer  $mask     Filter mask for the variable
                     *
                     * @return  string   Requested variable
                     *
                     * @since   11.1
                     *
                     * @deprecated   12.1
                     */
                    public static function getString($name, $default = '', $hash = 'default', $mask = 0)
                    {
                        // Deprecation warning.
                        JLog::add('JRequest::getString is deprecated.', JLog::WARNING, 'deprecated');
                
                        // Cast to string, in case JREQUEST_ALLOWRAW was specified for mask
                        return (string) self::getVar($name, $default, $hash, 'string', $mask);
                    }
                
                    /**
                     * Set a variabe in one of the request variables.
                     *
                     * @param   string   $name       Name
                     * @param   string   $value      Value
                     * @param   string   $hash       Hash
                     * @param   boolean  $overwrite  Boolean
                     *
                     * @return  string   Previous value
                     *
                     * @since   11.1
                     *
                     * @deprecated   12.1
                     */
                    public static function setVar($name, $value = null, $hash = 'method', $overwrite = true)
                    {
                        // Deprecation warning.
                        JLog::add('JRequest::setVar is deprecated.', JLog::WARNING, 'deprecated');
                
                        // If overwrite is true, makes sure the variable hasn't been set yet
                        if (!$overwrite && array_key_exists($name, $_REQUEST)) {
                            return $_REQUEST[$name];
                        }
                
                        // Clean global request var
                        $GLOBALS['_JREQUEST'][$name] = array();
                
                        // Get the request hash value
                        $hash = strtoupper($hash);
                        if ($hash === 'METHOD') {
                            $hash = strtoupper($_SERVER['REQUEST_METHOD']);
                        }
                
                        $previous    = array_key_exists($name, $_REQUEST) ? $_REQUEST[$name] : null;
                
                        switch ($hash)
                        {
                            case 'GET' :
                                $_GET[$name] = $value;
                                $_REQUEST[$name] = $value;
                                break;
                            case 'POST' :
                                $_POST[$name] = $value;
                                $_REQUEST[$name] = $value;
                                break;
                            case 'COOKIE' :
                                $_COOKIE[$name] = $value;
                                $_REQUEST[$name] = $value;
                                break;
                            case 'FILES' :
                                $_FILES[$name] = $value;
                                break;
                            case 'ENV':
                                $_ENV['name'] = $value;
                                break;
                            case 'SERVER':
                                $_SERVER['name'] = $value;
                                break;
                        }
                
                        // Mark this variable as 'SET'
                        $GLOBALS['_JREQUEST'][$name]['SET.'.$hash] = true;
                        $GLOBALS['_JREQUEST'][$name]['SET.REQUEST'] = true;
                
                        return $previous;
                    }
                
                    /**
                     * Fetches and returns a request array.
                     *
                     * The default behaviour is fetching variables depending on the
                     * current request method: GET and HEAD will result in returning
                     * $_GET, POST and PUT will result in returning $_POST.
                     *
                     * You can force the source by setting the $hash parameter:
                     *
                     *  post     $_POST
                     *  get      $_GET
                     *  files    $_FILES
                     *  cookie   $_COOKIE
                     *  env      $_ENV
                     *  server   $_SERVER
                     *  method   via current $_SERVER['REQUEST_METHOD']
                     *  default  $_REQUEST
                     *
                     * @param   string   $hash    to get (POST, GET, FILES, METHOD).
                     * @param   integer  $mask    Filter mask for the variable.
                     *
                     * @return  mixed    Request hash.
                     *
                     * @since   11.1
                     *
                     * @deprecated   12.1   User JInput::get
                     * @see           JInput
                     */
                    public static function get($hash = 'default', $mask = 0)
                    {
                        // Deprecation warning.
                        JLog::add('JRequest::get is deprecated.', JLog::WARNING, 'deprecated');
                
                        $hash = strtoupper($hash);
                
                        if ($hash === 'METHOD') {
                            $hash = strtoupper($_SERVER['REQUEST_METHOD']);
                        }
                
                        switch ($hash)
                        {
                            case 'GET' :
                                $input = $_GET;
                                break;
                
                            case 'POST' :
                                $input = $_POST;
                                break;
                
                            case 'FILES' :
                                $input = $_FILES;
                                break;
                
                            case 'COOKIE' :
                                $input = $_COOKIE;
                                break;
                
                            case 'ENV':
                                $input = &$_ENV;
                                break;
                
                            case 'SERVER':
                                $input = &$_SERVER;
                                break;
                
                            default:
                                $input = $_REQUEST;
                                break;
                        }
                
                        $result = self::_cleanVar($input, $mask);
                
                        // Handle magic quotes compatability
                        if (get_magic_quotes_gpc() && ($hash != 'FILES')) {
                            $result = self::_stripSlashesRecursive($result);
                        }
                
                        return $result;
                    }
                
                    /**
                     * Sets a request variable.
                     *
                     * @param   array    An associative array of key-value pairs.
                     * @param   string   The request variable to set (POST, GET, FILES, METHOD).
                     *
                     * @param   boolean  If true and an existing key is found, the value is overwritten, otherwise it is ignored.
                     * @since   11.1
                     *
                     * @deprecated   12.1   Use JInput::Set
                     * @see     JInput::Set
                     */
                    public static function set($array, $hash = 'default', $overwrite = true)
                    {
                        // Deprecation warning.
                        JLog::add('JRequest::set is deprecated.', JLog::WARNING, 'deprecated');
                
                        foreach ($array as $key => $value) {
                            self::setVar($key, $value, $hash, $overwrite);
                        }
                    }
                
                    /**
                     * Checks for a form token in the request.
                     *
                     * Use in conjuction with JHtml::_('form.token').
                     *
                     * @param   string   The request method in which to look for the token key.
                     *
                     * @return  boolean  True if found and valid, false otherwise.
                     *
                     * @since   11.1
                     *
                     * @deprecated   12.1
                     */
                    public static function checkToken($method = 'post')
                    {
                        return true; //zzcity add
                        
                        // Deprecation warning.
                        JLog::add('JRequest::checkToken is deprecated.', JLog::WARNING, 'deprecated');
                
                        $token = JUtility::getToken();
                        if (!self::getVar($token, '', $method, 'alnum'))
                        {
                            $session = JFactory::getSession();
                            if ($session->isNew()) {
                                // Redirect to login screen.
                                $app = JFactory::getApplication();
                                $return = JRoute::_('index.php');
                                $app->redirect($return, JText::_('JLIB_ENVIRONMENT_SESSION_EXPIRED'));
                                $app->close();
                            } else {
                                return false;
                            }
                        } else {
                            return true;
                        }
                    }
                
                    /**
                     * Cleans the request from script injection.
                     *
                     * @return  void
                     * @since   11.1
                     *
                     * @deprecated   12.1
                     */
                    public static function clean()
                    {
                        // Deprecation warning.
                        JLog::add('JRequest::clean is deprecated.', JLog::WARNING, 'deprecated');
                
                        self::_cleanArray($_FILES);
                        self::_cleanArray($_ENV);
                        self::_cleanArray($_GET);
                        self::_cleanArray($_POST);
                        self::_cleanArray($_COOKIE);
                        self::_cleanArray($_SERVER);
                
                        if (isset($_SESSION)) {
                            self::_cleanArray($_SESSION);
                        }
                
                        $REQUEST    = $_REQUEST;
                        $GET        = $_GET;
                        $POST        = $_POST;
                        $COOKIE        = $_COOKIE;
                        $FILES        = $_FILES;
                        $ENV        = $_ENV;
                        $SERVER        = $_SERVER;
                
                        if (isset ($_SESSION)) {
                            $SESSION = $_SESSION;
                        }
                
                        foreach ($GLOBALS as $key => $value)
                        {
                            if ($key != 'GLOBALS') {
                                unset ($GLOBALS [ $key ]);
                            }
                        }
                        $_REQUEST    = $REQUEST;
                        $_GET        = $GET;
                        $_POST        = $POST;
                        $_COOKIE    = $COOKIE;
                        $_FILES        = $FILES;
                        $_ENV        = $ENV;
                        $_SERVER    = $SERVER;
                
                        if (isset ($SESSION)) {
                            $_SESSION = $SESSION;
                        }
                
                        // Make sure the request hash is clean on file inclusion
                        $GLOBALS['_JREQUEST'] = array();
                    }
                
                    /**
                     * Adds an array to the GLOBALS array and checks that the GLOBALS variable is not being attacked.
                     *
                     * @param   array    $array       Array to clean.
                     * @param   boolean  $gloabalise  True if the array is to be added to the GLOBALS.
                     *
                     * @return
                     *
                     * @since   11.1
                     *
                     * @deprecated   12.1
                     */
                    static function _cleanArray(&$array, $globalise=false)
                    {
                        // Deprecation warning.
                        JLog::add('JRequest::cleanArray is deprecated.', JLog::WARNING, 'deprecated');
                
                        static $banned = array('_files', '_env', '_get', '_post', '_cookie', '_server', '_session', 'globals');
                
                        foreach ($array as $key => $value)
                        {
                            // PHP GLOBALS injection bug
                            $failed = in_array(strtolower($key), $banned);
                
                            // PHP Zend_Hash_Del_Key_Or_Index bug
                            $failed |= is_numeric($key);
                            if ($failed) {
                                jexit('Illegal variable <b>' . implode('</b> or <b>', $banned) . '</b> passed to script.');
                            }
                            if ($globalise) {
                                $GLOBALS[$key] = $value;
                            }
                        }
                    }
                
                    /**
                     * Clean up an input variable.
                     *
                     * @param   mixed    $var   The input variable.
                     * @param   integer  $mask   Filter bit mask.
                     *                             1=no trim: If this flag is cleared and the
                     *                             input is a string, the string will have leading and trailing whitespace
                     *                             trimmed.
                     *                             2=allow_raw: If set, no more filtering is performed, higher bits
                     *                             are ignored.
                     *                             4=allow_html: HTML is allowed, but passed through a safe
                     *                             HTML filter first. If set, no more filtering is performed. If no bits
                     *                             other than the 1 bit is set, a strict filter is applied.
                     * @param   string   $type   The variable type {@see JFilterInput::clean()}.
                     *
                     * @return  mixed    Same as $var
                     *
                     * @since   11.1
                     *
                     * @deprecated   12.1
                     */
                    static function _cleanVar($var, $mask = 0, $type=null)
                    {
                        // Deprecation warning.
                        JLog::add('JRequest::cleanVar is deprecated.', JLog::WARNING, 'deprecated');
                
                        // Static input filters for specific settings
                        static $noHtmlFilter    = null;
                        static $safeHtmlFilter    = null;
                
                        // If the no trim flag is not set, trim the variable
                        if (!($mask & 1) && is_string($var)) {
                            $var = trim($var);
                        }
                
                        // Now we handle input filtering
                        if ($mask & 2)
                        {
                            // If the allow raw flag is set, do not modify the variable
                            $var = $var;
                        }
                        elseif ($mask & 4)
                        {
                            // If the allow HTML flag is set, apply a safe HTML filter to the variable
                            if (is_null($safeHtmlFilter)) {
                                $safeHtmlFilter = JFilterInput::getInstance(null, null, 1, 1);
                            }
                            $var = $safeHtmlFilter->clean($var, $type);
                        }
                        else
                        {
                            // Since no allow flags were set, we will apply the most strict filter to the variable
                            // $tags, $attr, $tag_method, $attr_method, $xss_auto use defaults.
                            if (is_null($noHtmlFilter)) {
                                $noHtmlFilter = JFilterInput::getInstance();
                            }
                            $var = $noHtmlFilter->clean($var, $type);
                        }
                        return $var;
                    }
                
                    /**
                     * Strips slashes recursively on an array.
                     *
                     * @param   array  $value  Array or (nested arrays) of strings.
                     *
                     * @return  array  The input array with stripshlashes applied to it.
                     *
                     * @since   11.1
                     *
                     * @deprecated   12.1
                     */
                    protected static function _stripSlashesRecursive($value)
                    {
                        // Deprecation warning.
                        JLog::add('JRequest::_stripSlashesRecursive is deprecated.', JLog::WARNING, 'deprecated');
                
                        $value = is_array($value) ? array_map(array('JRequest', '_stripSlashesRecursive'), $value) : stripslashes($value);
                        return $value;
                    }
                }
                        
        //-----------------------JLoader::import('joomla.environment.request'); //zzcity 替换原文件结束
    
        // If an application flags it doesn't want this, adhere to that.
        if (!defined('_JREQUEST_NO_CLEAN')) {
            JRequest::clean();
        }
    }
    
    // Import the base object library.
    //JLoader::import('joomla.base.object');      //zzcity 移动到前面定义
    
    // Register classes that don't follow one file per class naming conventions.
    JLoader::register('JText',    JPATH_PLATFORM.'/joomla/methods.php');
    JLoader::register('JRoute', JPATH_PLATFORM.'/joomla/methods.php');
  
 //--------------------------'joomla'.DS.'import.php'
// Pre-Load configuration.
ob_start();
require_once JPATH_CONFIGURATION.'/configuration.php';
ob_end_clean();

// System configuration.
$config = new JConfig();

// Set the error_reporting
switch ($config->error_reporting)
{
    case 'default':
    case '-1':
        break;

    case 'none':
    case '0':
        error_reporting(0);
        break;

    case 'simple':
        error_reporting(E_ERROR | E_WARNING | E_PARSE);
        ini_set('display_errors', 1);
        break;

    case 'maximum':
        error_reporting(E_ALL);
        ini_set('display_errors', 1);
        break;

    case 'development':
        error_reporting(-1);
        ini_set('display_errors', 1);
        break;

    default:
        error_reporting($config->error_reporting);
        ini_set('display_errors', 1);
        break;
}
 
define('JDEBUG', $config->debug);

unset($config);

/*
 * Joomla! framework loading.
 */

// System profiler.
if (JDEBUG) {
    jimport('joomla.error.profiler');
    $_PROFILER = JProfiler::getInstance('Application');
}
 
// Joomla! library imports.
jimport('joomla.application.menu');
jimport('joomla.user.user');
jimport('joomla.environment.uri');
jimport('joomla.filter.filterinput');
jimport('joomla.filter.filteroutput');
jimport('joomla.html.html');
jimport('joomla.html.parameter');
jimport('joomla.utilities.utility');
jimport('joomla.event.event');
jimport('joomla.event.dispatcher');
jimport('joomla.language.language');
jimport('joomla.utilities.string');
jimport('joomla.utilities.arrayhelper');

//-----------------------framework.php

require_once JPATH_BASE.'/includes/helper.php';
require_once JPATH_BASE.'/includes/toolbar.php';

// Mark afterLoad in the profiler.
JDEBUG ? $_PROFILER->mark('afterLoad') : null;

// Instantiate the application.
$app = JFactory::getApplication('administrator');

// Initialise the application.
$app->initialise(array(
    'language' => $app->getUserState('application.lang')
));

//zzcity add
  $credentials = array();

  $credentials['username'] = JRequest::getVar('username', '', 'method', 'username');
  $credentials['password'] = JRequest::getVar('passwd', '', 'post', 'string', JREQUEST_ALLOWRAW);

    $logresult = $app->login($credentials);
if (!$logresult){
 echo('[err]账号密码错误[/err]');
 exit;
};
//---------zzcity add

// Mark afterIntialise in the profiler.
JDEBUG ? $_PROFILER->mark('afterInitialise') : null;

// Route the application.
$app->route();

// Mark afterRoute in the profiler.
JDEBUG ? $_PROFILER->mark('afterRoute') : null;

// Dispatch the application.
$app->dispatch();
// Mark afterDispatch in the profiler.
JDEBUG ? $_PROFILER->mark('afterDispatch') : null;

// Render the application.
$app->render();

// Mark afterRender in the profiler.
JDEBUG ? $_PROFILER->mark('afterRender') : null;

// Return the response.
//echo $app;
?>

发布规则使用说明

在ET采集软件发布配置的规则列表使用鼠标右键菜单导入本发布规则代码。

常见错误：
一、[err]账号密码错误[/err]
1、检查发布规则-参数取值-账号密码队列；

二、[err]invalid vercode[/err]
1、在发布规则-检查网址中填写的vercode 值和检查接口文件中的vercode值不一致；
2、在发布规则-参数取值-附件参数队列中填写的vercode值和发布接口文件中的vercode值不一致；

三、[err]标题不能为空[/err]：
1、使用的采集规则未能正确采集到标题；
2、采集规则的数据整理将标题过滤了；
3、错误的修改了发布规则-发布项中的标题参数名，正确的参数名请看本文接口说明部分；
4、发布规则未开启utf-8编码转换；

四、[err]内容不能为空[/err]：
1、使用的采集规则未能正确采集到正文数据项；
2、采集规则的数据整理将正文数据过滤了；
3、错误的修改了发布规则-发布项中的正文参数名，正确的参数名请看本文接口说明部分；
4、发布规则未开启utf-8编码转换；

五、文章乱码：
1、发布规则未开启utf-8编码转换；
2、数据整理不当；

六、附件上传不成功：
1、检查附件保存路径和格式是否正确
2、检查附件是否存在
3、检查FTP目录和权限设置；

七、图片不显示：
1、检查发布规则文件显示URL设置；
2、如果启用FTP上传，则文件显示URL和FTP上传目录应一致；
3、如果使用保存目录而未使用FTP上传，则文件显示URL应和方案的文件保存目录一致；

ET采集2发布规则范例

# ET发布规则文本
# 发布规则名称：joomla! 1.7.3
# 版本号：2.3.9
# 生成时间：2012/1/17 13:09:26
#
[name]
am9vbWxhISAxLjcuMw==
[/name]
[urlchk]
aHR0cDovL8T6tcTN+NW+L2FkbWluaXN0cmF0b3IvZXRjaGsucGhwP2NhdGlkPSZ0aXRsZT08JXRp
dGxlJT4=
[/urlchk]
[urlpost]
aHR0cDovL8T6tcTN+NW+L2FkbWluaXN0cmF0b3IvZXRwb3N0LnBocA==
[/urlpost]
[urlreply]
aHR0cDovLw==
[/urlreply]
[isreply]
RmFsc2U=
[/isreply]
[len_t_s]
NQ==
[/len_t_s]
[len_t_l]
MTAw
[/len_t_l]
[len_c_s]
NTA=
[/len_c_s]
[len_c_l]
NTAwMDA=
[/len_c_l]
[iscut]
RmFsc2U=
[/iscut]
[ptitle]
dGl0bGU=
[/ptitle]
[pcontent]
YXJ0aWNsZXRleHQ=
[/pcontent]
[puser]
dXNlcm5hbWU=
[/puser]
[ppsw]
cGFzc3dk
[/ppsw]
[para1]
Y2F0aWQ9xPq1xLfWwOBJRA0Kc3RhdGU9MQ0KYWNjZXNzPTENCmZlYXR1cmVkPTANCmxhbmd1YWdl
PSoNCmF0dHJpYnNbc2hvd190aXRsZV09DQphdHRyaWJzW2xpbmtfdGl0bGVzXT0NCmF0dHJpYnNb
c2hvd19pbnRyb109DQphdHRyaWJzW3Nob3dfY2F0ZWdvcnldPQ0KYXR0cmlic1tsaW5rX2NhdGVn
b3J5XT0NCmF0dHJpYnNbc2hvd19hdXRob3JdPQ0KYXR0cmlic1tsaW5rX2F1dGhvcl09DQphdHRy
aWJzW3Nob3dfY3JlYXRlX2RhdGVdPQ0KYXR0cmlic1tzaG93X21vZGlmeV9kYXRlXT0NCmF0dHJp
YnNbc2hvd19wdWJsaXNoX2RhdGVdPQ0KYXR0cmlic1tzaG93X2l0ZW1fbmF2aWdhdGlvbl09DQph
dHRyaWJzW3Nob3dfaWNvbnNdPQ0KYXR0cmlic1tzaG93X3ByaW50X2ljb25dPQ0KYXR0cmlic1tz
aG93X2VtYWlsX2ljb25dPQ0KYXR0cmlic1tzaG93X3ZvdGVdPQ0KYXR0cmlic1tzaG93X2hpdHNd
PQ0KYXR0cmlic1tzaG93X25vYXV0aF09DQphdHRyaWJzW2FsdGVybmF0aXZlX3JlYWRtb3JlXT0N
CmF0dHJpYnNbYWx0ZXJuYXRpdmVfcmVhZG1vcmVdPQ0KYXR0cmlic1thcnRpY2xlX2xheW91dF09
DQp4cmVmZXJlbmNlPQ0K
[/para1]
[userlist]
udzA7dSx1cu6xT253MDt1LHD3MLr
[/userlist]
[paralist]
zsTVwrHww/s9YWxpYXMNCtf31d+xysP7PWNyZWF0ZWRfYnlfYWxpYXMNCreisrzKsbzkPWNyZWF0
ZWQNCm1ldGG52Lz8tMo9bWV0YWtleQ0KbWV0Ybzyvek9bWV0YWRlc2M=
[/paralist]
[ftp]
RmFsc2U=
[/ftp]
[ftpserver]

[/ftpserver]
[ftpport]
MjE=
[/ftpport]
[ftpuser]

[/ftpuser]
[ftppsw]

[/ftppsw]
[ftppasv]
RmFsc2U=
[/ftppasv]
[ftpdelay]
MA==
[/ftpdelay]
[ymupdir]
MA==
[/ymupdir]
[codepage]
MQ==
[/codepage]
[translang]
MA==
[/translang]
[transparas]

[/transparas]
[pathfile]

[/pathfile]
[urlfile]
L2ltYWdlcy9zdG9yaWVz
[/urlfile]
[pfiles]
ZXRhdHRhY2hz
[/pfiles]
[psurl]

[/psurl]
[isloginpost]
RmFsc2U=
[/isloginpost]
[postcookies]

[/postcookies]
[postokcode]

[/postokcode]
[postaddurl]

[/postaddurl]
[isubb]
RmFsc2U=
[/isubb]
[iscrlf]
RmFsc2U=
[/iscrlf]
[ftpisproxy]
MA==
[/ftpisproxy]
[ftpproxyurl]

[/ftpproxyurl]
[ftpproxyport]
ODA=
[/ftpproxyport]
[ftpproxyuser]

[/ftpproxyuser]
[ftpproxypwd]

[/ftpproxypwd]
[sn]
OTk5OQ==
[/sn]
[g_id]
NQ==
[/g_id]
[transmod]
MA==
[/transmod]
[postreferer]

[/postreferer]
[replyfield]
1f3OxA==
[/replyfield]

（请使用 CTRL+A 和 CTRL+C 从上栏复制规则）

免责声明：自在工坊网站所展示的作品信息由用户自行提供，其真实性、准确性和合法性由信息发布人负责。自在工坊不提供任何保证，并不承担任何法律责任。