芝麻web文件管理V1.00

编辑当前文件:/home2/sdektunc/xmintal-back/vendor/yiisoft/yii2/web/ErrorHandler.php

<?php
/**
 * @link https://www.yiiframework.com/
 * @copyright Copyright (c) 2008 Yii Software LLC
 * @license https://www.yiiframework.com/license/
 */

namespace yii\web;

use Yii;
use yii\base\ErrorException;
use yii\base\Exception;
use yii\base\UserException;
use yii\helpers\VarDumper;

/**
 * ErrorHandler handles uncaught PHP errors and exceptions.
 *
 * ErrorHandler displays these errors using appropriate views based on the
 * nature of the errors and the mode the application runs at.
 *
 * ErrorHandler is configured as an application component in [[\yii\base\Application]] by default.
 * You can access that instance via `Yii::$app->errorHandler`.
 *
 * For more details and usage information on ErrorHandler, see the [guide article on handling errors](guide:runtime-handling-errors).
 *
 * @author Qiang Xue <qiang.xue@gmail.com>
 * @author Timur Ruziev <resurtm@gmail.com>
 * @since 2.0
 */
class ErrorHandler extends \yii\base\ErrorHandler
{
 /**
 * @var int maximum number of source code lines to be displayed. Defaults to 19.
 */
 public $maxSourceLines = 19;
 /**
 * @var int maximum number of trace source code lines to be displayed. Defaults to 13.
 */
 public $maxTraceSourceLines = 13;
 /**
 * @var string|null the route (e.g. `site/error`) to the controller action that will be used
 * to display external errors. Inside the action, it can retrieve the error information
 * using `Yii::$app->errorHandler->exception`. This property defaults to null, meaning ErrorHandler
 * will handle the error display.
 */
 public $errorAction;
 /**
 * @var string the path of the view file for rendering exceptions without call stack information.
 */
 public $errorView = '@yii/views/errorHandler/error.php';
 /**
 * @var string the path of the view file for rendering exceptions.
 */
 public $exceptionView = '@yii/views/errorHandler/exception.php';
 /**
 * @var string the path of the view file for rendering exceptions and errors call stack element.
 */
 public $callStackItemView = '@yii/views/errorHandler/callStackItem.php';
 /**
 * @var string the path of the view file for rendering previous exceptions.
 */
 public $previousExceptionView = '@yii/views/errorHandler/previousException.php';
 /**
 * @var array list of the PHP predefined variables that should be displayed on the error page.
 * Note that a variable must be accessible via `$GLOBALS`. Otherwise it won't be displayed.
 * Defaults to `['_GET', '_POST', '_FILES', '_COOKIE', '_SESSION']`.
 * @see renderRequest()
 * @since 2.0.7
 */
 public $displayVars = ['_GET', '_POST', '_FILES', '_COOKIE', '_SESSION'];
 /**
 * @var string trace line with placeholders to be be substituted.
 * The placeholders are {file}, {line} and {text} and the string should be as follows.
 *
 * `File: {file} - Line: {line} - Text: {text}`
 *
 * @example <a href="ide://open?file={file}&line={line}">{html}</a>
 * @see https://github.com/yiisoft/yii2-debug#open-files-in-ide
 * @since 2.0.14
 */
 public $traceLine = '{html}';

/**
     * Renders the exception.
     * @param \Throwable $exception the exception to be rendered.
     */
    protected function renderException($exception)
    {
        if (Yii::$app->has('response')) {
            $response = Yii::$app->getResponse();
            // reset parameters of response to avoid interference with partially created response data
            // in case the error occurred while sending the response.
            $response->isSent = false;
            $response->stream = null;
            $response->data = null;
            $response->content = null;
        } else {
            $response = new Response();
        }

$response->setStatusCodeByException($exception);

$useErrorView = $response->format === Response::FORMAT_HTML && (!YII_DEBUG || $exception instanceof UserException);

if ($useErrorView && $this->errorAction !== null) {
 Yii::$app->view->clear();
 $result = Yii::$app->runAction($this->errorAction);
 if ($result instanceof Response) {
 $response = $result;
 } else {
 $response->data = $result;
 }
 } elseif ($response->format === Response::FORMAT_HTML) {
 if ($this->shouldRenderSimpleHtml()) {
 // AJAX request
 $response->data = '<pre>' . $this->htmlEncode(static::convertExceptionToString($exception)) . '</pre>';
 } else {
 // if there is an error during error rendering it's useful to
 // display PHP error in debug mode instead of a blank screen
 if (YII_DEBUG) {
 ini_set('display_errors', 1);
 }
 $file = $useErrorView ? $this->errorView : $this->exceptionView;
 $response->data = $this->renderFile($file, [
 'exception' => $exception,
 ]);
 }
 } elseif ($response->format === Response::FORMAT_RAW) {
 $response->data = static::convertExceptionToString($exception);
 } else {
 $response->data = $this->convertExceptionToArray($exception);
 }

$response->send();
    }

/**
     * Converts an exception into an array.
     * @param \Throwable $exception the exception being converted
     * @return array the array representation of the exception.
     */
    protected function convertExceptionToArray($exception)
    {
        if (!YII_DEBUG && !$exception instanceof UserException && !$exception instanceof HttpException) {
            $exception = new HttpException(500, Yii::t('yii', 'An internal server error occurred.'));
        }

$array = [
            'name' => ($exception instanceof Exception || $exception instanceof ErrorException) ? $exception->getName() : 'Exception',
            'message' => $exception->getMessage(),
            'code' => $exception->getCode(),
        ];
        if ($exception instanceof HttpException) {
            $array['status'] = $exception->statusCode;
        }
        if (YII_DEBUG) {
            $array['type'] = get_class($exception);
            if (!$exception instanceof UserException) {
                $array['file'] = $exception->getFile();
                $array['line'] = $exception->getLine();
                $array['stack-trace'] = explode("\n", $exception->getTraceAsString());
                if ($exception instanceof \yii\db\Exception) {
                    $array['error-info'] = $exception->errorInfo;
                }
            }
        }
        if (($prev = $exception->getPrevious()) !== null) {
            $array['previous'] = $this->convertExceptionToArray($prev);
        }

return $array;
    }

/**
     * Converts special characters to HTML entities.
     * @param string $text to encode.
     * @return string encoded original text.
     */
    public function htmlEncode($text)
    {
        return htmlspecialchars($text, ENT_NOQUOTES | ENT_SUBSTITUTE | ENT_HTML5, 'UTF-8');
    }

/**
     * Adds informational links to the given PHP type/class.
     * @param string $code type/class name to be linkified.
     * @return string linkified with HTML type/class name.
     */
    public function addTypeLinks($code)
    {
        if (preg_match('/(.*?)::([^(]+)/', $code, $matches)) {
            $class = $matches[1];
            $method = $matches[2];
            $text = $this->htmlEncode($class) . '::' . $this->htmlEncode($method);
        } else {
            $class = $code;
            $method = null;
            $text = $this->htmlEncode($class);
        }

$url = null;

$shouldGenerateLink = true;
        if ($method !== null && substr_compare($method, '{closure}', -9) !== 0) {
            $reflection = new \ReflectionClass($class);
            if ($reflection->hasMethod($method)) {
                $reflectionMethod = $reflection->getMethod($method);
                $shouldGenerateLink = $reflectionMethod->isPublic() || $reflectionMethod->isProtected();
            } else {
                $shouldGenerateLink = false;
            }
        }

if ($shouldGenerateLink) {
            $url = $this->getTypeUrl($class, $method);
        }

if ($url === null) {
            return $text;
        }

return '<a href="' . $url . '" target="_blank">' . $text . '</a>';
 }

/**
     * Returns the informational link URL for a given PHP type/class.
     * @param string $class the type or class name.
     * @param string|null $method the method name.
     * @return string|null the informational link URL.
     * @see addTypeLinks()
     */
    protected function getTypeUrl($class, $method)
    {
        if (strncmp($class, 'yii\\', 4) !== 0) {
            return null;
        }

$page = $this->htmlEncode(strtolower(str_replace('\\', '-', $class)));
        $url = "https://www.yiiframework.com/doc-2.0/$page.html";
        if ($method) {
            $url .= "#$method()-detail";
        }

return $url;
    }

/**
     * Renders a view file as a PHP script.
     * @param string $_file_ the view file.
     * @param array $_params_ the parameters (name-value pairs) that will be extracted and made available in the view file.
     * @return string the rendering result
     */
    public function renderFile($_file_, $_params_)
    {
        $_params_['handler'] = $this;
        if ($this->exception instanceof ErrorException || !Yii::$app->has('view')) {
            ob_start();
            ob_implicit_flush(false);
            extract($_params_, EXTR_OVERWRITE);
            require Yii::getAlias($_file_);

return ob_get_clean();
        }

$view = Yii::$app->getView();
        $view->clear();

return $view->renderFile($_file_, $_params_, $this);
    }

/**
     * Renders the previous exception stack for a given Exception.
     * @param \Throwable $exception the exception whose precursors should be rendered.
     * @return string HTML content of the rendered previous exceptions.
     * Empty string if there are none.
     */
    public function renderPreviousExceptions($exception)
    {
        if (($previous = $exception->getPrevious()) !== null) {
            return $this->renderFile($this->previousExceptionView, ['exception' => $previous]);
        }

return '';
    }

/**
 * Renders a single call stack element.
 * @param string|null $file name where call has happened.
 * @param int|null $line number on which call has happened.
 * @param string|null $class called class name.
 * @param string|null $method called function/method name.
 * @param array $args array of method arguments.
 * @param int $index number of the call stack element.
 * @return string HTML content of the rendered call stack element.
 */
 public function renderCallStackItem($file, $line, $class, $method, $args, $index)
 {
 $lines = [];
 $begin = $end = 0;
 if ($file !== null && $line !== null) {
 $line--; // adjust line number from one-based to zero-based
 $lines = @file($file);
 if ($line < 0 || $lines === false || ($lineCount = count($lines)) < $line) {
 return '';
 }

$half = (int) (($index === 1 ? $this->maxSourceLines : $this->maxTraceSourceLines) / 2);
 $begin = $line - $half > 0 ? $line - $half : 0;
 $end = $line + $half < $lineCount ? $line + $half : $lineCount - 1;
 }

return $this->renderFile($this->callStackItemView, [
            'file' => $file,
            'line' => $line,
            'class' => $class,
            'method' => $method,
            'index' => $index,
            'lines' => $lines,
            'begin' => $begin,
            'end' => $end,
            'args' => $args,
        ]);
    }

/**
 * Renders call stack.
 * @param \Throwable $exception exception to get call stack from
 * @return string HTML content of the rendered call stack.
 * @since 2.0.12
 */
 public function renderCallStack($exception)
 {
 $out = '<ul>';
 $out .= $this->renderCallStackItem($exception->getFile(), $exception->getLine(), null, null, [], 1);
 for ($i = 0, $trace = $exception->getTrace(), $length = count($trace); $i < $length; ++$i) {
 $file = !empty($trace[$i]['file']) ? $trace[$i]['file'] : null;
 $line = !empty($trace[$i]['line']) ? $trace[$i]['line'] : null;
 $class = !empty($trace[$i]['class']) ? $trace[$i]['class'] : null;
 $function = null;
 if (!empty($trace[$i]['function']) && $trace[$i]['function'] !== 'unknown') {
 $function = $trace[$i]['function'];
 }
 $args = !empty($trace[$i]['args']) ? $trace[$i]['args'] : [];
 $out .= $this->renderCallStackItem($file, $line, $class, $function, $args, $i + 2);
 }
 $out .= '</ul>';
 return $out;
 }

/**
     * Renders the global variables of the request.
     * List of global variables is defined in [[displayVars]].
     * @return string the rendering result
     * @see displayVars
     */
    public function renderRequest()
    {
        $request = '';
        foreach ($this->displayVars as $name) {
            if (!empty($GLOBALS[$name])) {
                $request .= '$' . $name . ' = ' . VarDumper::export($GLOBALS[$name]) . ";\n\n";
            }
        }

return '<pre>' . $this->htmlEncode(rtrim($request, "\n")) . '</pre>';
 }

/**
     * Determines whether given name of the file belongs to the framework.
     * @param string $file name to be checked.
     * @return bool whether given name of the file belongs to the framework.
     */
    public function isCoreFile($file)
    {
        return $file === null || strpos(realpath($file), YII2_PATH . DIRECTORY_SEPARATOR) === 0;
    }

/**
 * Creates HTML containing link to the page with the information on given HTTP status code.
 * @param int $statusCode to be used to generate information link.
 * @param string $statusDescription Description to display after the the status code.
 * @return string generated HTML with HTTP status code information.
 */
 public function createHttpStatusLink($statusCode, $statusDescription)
 {
 return '<a href="https://en.wikipedia.org/wiki/List_of_HTTP_status_codes#' . (int) $statusCode . '" target="_blank">HTTP ' . (int) $statusCode . ' – ' . $statusDescription . '</a>';
 }

/**
 * Creates string containing HTML link which refers to the home page of determined web-server software
 * and its full name.
 * @return string server software information hyperlink.
 */
 public function createServerInformationLink()
 {
 $serverUrls = [
 'https://httpd.apache.org/' => ['apache'],
 'https://nginx.org/' => ['nginx'],
 'https://www.lighttpd.net/' => ['lighttpd'],
 'http://gwan.com/' => ['g-wan', 'gwan'],
 'https://www.iis.net/' => ['iis', 'services'],
 'https://www.php.net/manual/en/features.commandline.webserver.php' => ['development'],
 ];
 if (isset($_SERVER['SERVER_SOFTWARE'])) {
 foreach ($serverUrls as $url => $keywords) {
 foreach ($keywords as $keyword) {
 if (stripos($_SERVER['SERVER_SOFTWARE'], $keyword) !== false) {
 return '<a href="' . $url . '" target="_blank">' . $this->htmlEncode($_SERVER['SERVER_SOFTWARE']) . '</a>';
 }
 }
 }
 }

return '';
    }

/**
 * Creates string containing HTML link which refers to the page with the current version
 * of the framework and version number text.
 * @return string framework version information hyperlink.
 */
 public function createFrameworkVersionLink()
 {
 return '<a href="https://github.com/yiisoft/yii2/" target="_blank">' . $this->htmlEncode(Yii::getVersion()) . '</a>';
 }

/**
     * Converts arguments array to its string representation.
     *
     * @param array $args arguments array to be converted
     * @return string string representation of the arguments array
     */
    public function argumentsToString($args)
    {
        $count = 0;
        $isAssoc = $args !== array_values($args);

foreach ($args as $key => $value) {
            $count++;
            if ($count >= 5) {
                if ($count > 5) {
                    unset($args[$key]);
                } else {
                    $args[$key] = '...';
                }
                continue;
            }

if (is_object($value)) {
 $args[$key] = '' . $this->htmlEncode(get_class($value)) . '';
 } elseif (is_bool($value)) {
 $args[$key] = '' . ($value ? 'true' : 'false') . '';
 } elseif (is_string($value)) {
 $fullValue = $this->htmlEncode($value);
 if (mb_strlen($value, 'UTF-8') > 32) {
 $displayValue = $this->htmlEncode(mb_substr($value, 0, 32, 'UTF-8')) . '...';
 $args[$key] = "'$displayValue'";
 } else {
 $args[$key] = "'$fullValue'";
 }
 } elseif (is_array($value)) {
 $args[$key] = '[' . $this->argumentsToString($value) . ']';
 } elseif ($value === null) {
 $args[$key] = 'null';
 } elseif (is_resource($value)) {
 $args[$key] = 'resource';
 } else {
 $args[$key] = '' . $value . '';
 }

if (is_string($key)) {
 $args[$key] = '\'' . $this->htmlEncode($key) . "' => $args[$key]";
 } elseif ($isAssoc) {
 $args[$key] = "$key => $args[$key]";
 }
 }

return implode(', ', $args);
    }

/**
     * Returns human-readable exception name.
     * @param \Throwable $exception
     * @return string|null human-readable exception name or null if it cannot be determined
     */
    public function getExceptionName($exception)
    {
        if ($exception instanceof \yii\base\Exception || $exception instanceof \yii\base\InvalidCallException || $exception instanceof \yii\base\InvalidParamException || $exception instanceof \yii\base\UnknownMethodException) {
            return $exception->getName();
        }

return null;
    }

/**
     * @return bool if simple HTML should be rendered
     * @since 2.0.12
     */
    protected function shouldRenderSimpleHtml()
    {
        return YII_ENV_TEST || Yii::$app->request->getIsAjax();
    }
}