libraries/Response.class.php

   1 <?php
   2 /* vim: set expandtab sw=4 ts=4 sts=4: */
   3 /**
   4  * Manages the rendering of pages in PMA
   5  *
   6  * @package PhpMyAdmin
   7  */
   8 if (! defined('PHPMYADMIN')) {
   9     exit;
  10 }
  11
  12 require_once 'libraries/OutputBuffering.class.php';
  13 require_once 'libraries/Header.class.php';
  14 require_once 'libraries/Footer.class.php';
  15
  16 /**
  17  * Singleton class used to manage the rendering of pages in PMA
  18  *
  19  * @package PhpMyAdmin
  20  */
  21 class PMA_Response
  22 {
  23     /**
  24      * PMA_Response instance
  25      *
  26      * @access private
  27      * @static
  28      * @var PMA_Response
  29      */
  30     private static $_instance;
  31     /**
  32      * PMA_Header instance
  33      *
  34      * @access private
  35      * @var PMA_Header
  36      */
  37     private $_header;
  38     /**
  39      * HTML data to be used in the response
  40      *
  41      * @access private
  42      * @var string
  43      */
  44     private $_HTML;
  45     /**
  46      * An array of JSON key-value pairs
  47      * to be sent back for ajax requests
  48      *
  49      * @access private
  50      * @var array
  51      */
  52     private $_JSON;
  53     /**
  54      * PMA_Footer instance
  55      *
  56      * @access private
  57      * @var PMA_Footer
  58      */
  59     private $_footer;
  60     /**
  61      * Whether we are servicing an ajax request.
  62      * We can't simply use $GLOBALS['is_ajax_request']
  63      * here since it may have not been initialised yet.
  64      *
  65      * @access private
  66      * @var bool
  67      */
  68     private $_isAjax;
  69     /**
  70      * Whether we are servicing an ajax request for a page
  71      * that was fired using the generic page handler in JS.
  72      *
  73      * @access private
  74      * @var bool
  75      */
  76     private $_isAjaxPage;
  77     /**
  78      * Whether there were any errors during the processing of the request
  79      * Only used for ajax responses
  80      *
  81      * @access private
  82      * @var bool
  83      */
  84     private $_isSuccess;
  85     /**
  86      * Workaround for PHP bug
  87      *
  88      * @access private
  89      * @var string|bool
  90      */
  91     private $_CWD;
  92
  93     /**
  94      * Creates a new class instance
  95      */
  96     private function __construct()
  97     {
  98         if (! defined('TESTSUITE')) {
  99             $buffer = PMA_OutputBuffering::getInstance();
 100             $buffer->start();
 101             register_shutdown_function('PMA_Response::response');
 102         }
 103         $this->_header = new PMA_Header();
 104         $this->_HTML   = '';
 105         $this->_JSON   = array();
 106         $this->_footer = new PMA_Footer();
 107
 108         $this->_isSuccess  = true;
 109         $this->_isAjax     = false;
 110         $this->_isAjaxPage = false;
 111         if (isset($_REQUEST['ajax_request']) && $_REQUEST['ajax_request'] == true) {
 112             $this->_isAjax = true;
 113         }
 114         if (isset($_REQUEST['ajax_page_request'])
 115             && $_REQUEST['ajax_page_request'] == true
 116         ) {
 117             $this->_isAjaxPage = true;
 118         }
 119         $this->_header->setAjax($this->_isAjax);
 120         $this->_footer->setAjax($this->_isAjax);
 121         $this->_CWD = getcwd();
 122     }
 123
 124     /**
 125      * Returns the singleton PMA_Response object
 126      *
 127      * @return PMA_Response object
 128      */
 129     public static function getInstance()
 130     {
 131         if (empty(self::$_instance)) {
 132             self::$_instance = new PMA_Response();
 133         }
 134         return self::$_instance;
 135     }
 136
 137     /**
 138      * Set the status of an ajax response,
 139      * whether it is a success or an error
 140      *
 141      * @param bool $state Whether the request was successfully processed
 142      *
 143      * @return void
 144      */
 145     public function isSuccess($state)
 146     {
 147         $this->_isSuccess = ($state == true);
 148     }
 149
 150     /**
 151      * Returns true or false depending on whether
 152      * we are servicing an ajax request
 153      *
 154      * @return bool
 155      */
 156     public function isAjax()
 157     {
 158         return $this->_isAjax;
 159     }
 160
 161     /**
 162      * Returns the path to the current working directory
 163      * Necessary to work around a PHP bug where the CWD is
 164      * reset after the initial script exits
 165      *
 166      * @return string
 167      */
 168     public function getCWD()
 169     {
 170         return $this->_CWD;
 171     }
 172
 173     /**
 174      * Disables the rendering of the header
 175      * and the footer in responses
 176      *
 177      * @return void
 178      */
 179     public function disable()
 180     {
 181         $this->_header->disable();
 182         $this->_footer->disable();
 183     }
 184
 185     /**
 186      * Returns a PMA_Header object
 187      *
 188      * @return PMA_Header
 189      */
 190     public function getHeader()
 191     {
 192         return $this->_header;
 193     }
 194
 195     /**
 196      * Returns a PMA_Footer object
 197      *
 198      * @return PMA_Footer
 199      */
 200     public function getFooter()
 201     {
 202         return $this->_footer;
 203     }
 204
 205     /**
 206      * Add HTML code to the response
 207      *
 208      * @param string $content A string to be appended to
 209      *                        the current output buffer
 210      *
 211      * @return void
 212      */
 213     public function addHTML($content)
 214     {
 215         if (is_array($content)) {
 216             foreach ($content as $msg) {
 217                 $this->addHTML($msg);
 218             }
 219         } elseif ($content instanceof PMA_Message) {
 220             $this->_HTML .= $content->getDisplay();
 221         } else {
 222             $this->_HTML .= $content;
 223         }
 224     }
 225
 226     /**
 227      * Add JSON code to the response
 228      *
 229      * @param mixed $json  Either a key (string) or an
 230      *                     array or key-value pairs
 231      * @param mixed $value Null, if passing an array in $json otherwise
 232      *                     it's a string value to the key
 233      *
 234      * @return void
 235      */
 236     public function addJSON($json, $value = null)
 237     {
 238         if (is_array($json)) {
 239             foreach ($json as $key => $value) {
 240                 $this->addJSON($key, $value);
 241             }
 242         } else {
 243             if ($value instanceof PMA_Message) {
 244                 $this->_JSON[$json] = $value->getDisplay();
 245             } else {
 246                 $this->_JSON[$json] = $value;
 247             }
 248         }
 249
 250     }
 251
 252     /**
 253      * Renders the HTML response text
 254      *
 255      * @return string
 256      */
 257     private function _getDisplay()
 258     {
 259         // The header may contain nothing at all,
 260         // if its content was already rendered
 261         // and, in this case, the header will be
 262         // in the content part of the request
 263         $retval  = $this->_header->getDisplay();
 264         $retval .= $this->_HTML;
 265         $retval .= $this->_footer->getDisplay();
 266         return $retval;
 267     }
 268
 269     /**
 270      * Sends an HTML response to the browser
 271      *
 272      * @return void
 273      */
 274     private function _htmlResponse()
 275     {
 276         echo $this->_getDisplay();
 277     }
 278
 279     /**
 280      * Sends a JSON response to the browser
 281      *
 282      * @return void
 283      */
 284     private function _ajaxResponse()
 285     {
 286         if (! isset($this->_JSON['message'])) {
 287             $this->_JSON['message'] = $this->_getDisplay();
 288         } else if ($this->_JSON['message'] instanceof PMA_Message) {
 289             $this->_JSON['message'] = $this->_JSON['message']->getDisplay();
 290         }
 291
 292         if ($this->_isSuccess) {
 293             $this->_JSON['success'] = true;
 294         } else {
 295             $this->_JSON['success'] = false;
 296             $this->_JSON['error']   = $this->_JSON['message'];
 297             unset($this->_JSON['message']);
 298         }
 299
 300         if ($this->_isSuccess) {
 301             // Note: the old judge sentence is:
 302             // $this->_isAjaxPage && $this->_isSuccess
 303             // Removal the first, because console need log all queries, if caused any
 304             // bug, contact Edward Cheng
 305             $this->addJSON('_title', $this->getHeader()->getTitleTag());
 306
 307             if (isset($GLOBALS['dbi'])) {
 308                 $menuHash = $this->getHeader()->getMenu()->getHash();
 309                 $this->addJSON('_menuHash', $menuHash);
 310                 $hashes = array();
 311                 if (isset($_REQUEST['menuHashes'])) {
 312                     $hashes = explode('-', $_REQUEST['menuHashes']);
 313                 }
 314                 if (! in_array($menuHash, $hashes)) {
 315                     $this->addJSON('_menu', $this->getHeader()->getMenu()->getDisplay());
 316                 }
 317             }
 318
 319             $this->addJSON('_scripts', $this->getHeader()->getScripts()->getFiles());
 320             $this->addJSON('_selflink', $this->getFooter()->getSelfUrl('unencoded'));
 321             $this->addJSON('_displayMessage', $this->getHeader()->getMessage());
 322
 323             $debug = $this->_footer->getDebugMessage();
 324             if (/*overload*/mb_strlen($debug)) {
 325                 $this->addJSON('_debug', $debug);
 326             }
 327
 328             $errors = $this->_footer->getErrorMessages();
 329             if (/*overload*/mb_strlen($errors)) {
 330                 $this->addJSON('_errors', $errors);
 331             }
 332             $promptPhpErrors = $GLOBALS['error_handler']->hasErrorsForPrompt();
 333             $this->addJSON('_promptPhpErrors', $promptPhpErrors);
 334
 335             if (empty($GLOBALS['error_message'])) {
 336                 // set current db, table and sql query in the querywindow
 337                 // (this is for the bottom console)
 338                 $query = '';
 339                 $maxChars = $GLOBALS['cfg']['MaxCharactersInDisplayedSQL'];
 340                 if (isset($GLOBALS['sql_query'])
 341                     && /*overload*/mb_strlen($GLOBALS['sql_query']) < $maxChars
 342                 ) {
 343                     $query = $GLOBALS['sql_query'];
 344                 }
 345                 $this->addJSON(
 346                     '_reloadQuerywindow',
 347                     array(
 348                         'db' => PMA_ifSetOr($GLOBALS['db'], ''),
 349                         'table' => PMA_ifSetOr($GLOBALS['table'], ''),
 350                         'sql_query' => $query
 351                     )
 352                 );
 353                 if (! empty($GLOBALS['focus_querywindow'])) {
 354                     $this->addJSON('_focusQuerywindow', $query);
 355                 }
 356                 if (! empty($GLOBALS['reload'])) {
 357                     $this->addJSON('_reloadNavigation', 1);
 358                 }
 359                 $this->addJSON('_params', $this->getHeader()->getJsParams());
 360             }
 361         }
 362
 363         // Set the Content-Type header to JSON so that jQuery parses the
 364         // response correctly.
 365         if (! defined('TESTSUITE')) {
 366             header('Cache-Control: no-cache');
 367             header('Content-Type: application/json');
 368         }
 369
 370         echo json_encode($this->_JSON);
 371     }
 372
 373     /**
 374      * Sends an HTML response to the browser
 375      *
 376      * @static
 377      * @return void
 378      */
 379     public static function response()
 380     {
 381         $response = PMA_Response::getInstance();
 382         chdir($response->getCWD());
 383         $buffer = PMA_OutputBuffering::getInstance();
 384         if (empty($response->_HTML)) {
 385             $response->_HTML = $buffer->getContents();
 386         }
 387         if ($response->isAjax()) {
 388             $response->_ajaxResponse();
 389         } else {
 390             $response->_htmlResponse();
 391         }
 392         $buffer->flush();
 393         exit;
 394     }
 395 }
 396
 397 ?>