Class yii\web\Response

                public function clear()
{
    $this->_headers = null;
    $this->_cookies = null;
    $this->_statusCode = 200;
    $this->statusText = 'OK';
    $this->data = null;
    $this->stream = null;
    $this->content = null;
    $this->isSent = false;
}

            

                protected function defaultFormatters()
{
    return [
        self::FORMAT_HTML => [
            'class' => 'yii\web\HtmlResponseFormatter',
        ],
        self::FORMAT_XML => [
            'class' => 'yii\web\XmlResponseFormatter',
        ],
        self::FORMAT_JSON => [
            'class' => 'yii\web\JsonResponseFormatter',
        ],
        self::FORMAT_JSONP => [
            'class' => 'yii\web\JsonResponseFormatter',
            'useJsonp' => true,
        ],
    ];
}

            

                public function getCookies()
{
    if ($this->_cookies === null) {
        $this->_cookies = new CookieCollection();
    }
    return $this->_cookies;
}

            

                protected function getDispositionHeaderValue($disposition, $attachmentName)
{
    $fallbackName = str_replace(
        ['%', '/', '\\', '"', "\x7F"],
        ['_', '_', '_', '\\"', '_'],
        Inflector::transliterate($attachmentName, Inflector::TRANSLITERATE_LOOSE)
    );
    $utfName = rawurlencode(str_replace(['%', '/', '\\'], '', $attachmentName));
    $dispositionHeader = "{$disposition}; filename=\"{$fallbackName}\"";
    if ($utfName !== $fallbackName) {
        $dispositionHeader .= "; filename*=utf-8''{$utfName}";
    }
    return $dispositionHeader;
}

            

                public function getHeaders()
{
    if ($this->_headers === null) {
        $this->_headers = new HeaderCollection();
    }
    return $this->_headers;
}

            

                protected function getHttpRange($fileSize)
{
    $rangeHeader = Yii::$app->getRequest()->getHeaders()->get('Range', '-');
    if ($rangeHeader === '-') {
        return [0, $fileSize - 1];
    }
    if (!preg_match('/^bytes=(\d*)-(\d*)$/', $rangeHeader, $matches)) {
        return false;
    }
    if ($matches[1] === '') {
        $start = $fileSize - $matches[2];
        $end = $fileSize - 1;
    } elseif ($matches[2] !== '') {
        $start = $matches[1];
        $end = $matches[2];
        if ($end >= $fileSize) {
            $end = $fileSize - 1;
        }
    } else {
        $start = $matches[1];
        $end = $fileSize - 1;
    }
    if ($start < 0 || $start > $end) {
        return false;
    }
    return [$start, $end];
}

            

                public function getIsClientError()
{
    return $this->getStatusCode() >= 400 && $this->getStatusCode() < 500;
}

            

                public function getIsEmpty()
{
    return in_array($this->getStatusCode(), [201, 204, 304]);
}

            

                public function getIsForbidden()
{
    return $this->getStatusCode() == 403;
}

            

                public function getIsInformational()
{
    return $this->getStatusCode() >= 100 && $this->getStatusCode() < 200;
}

            

                public function getIsInvalid()
{
    return $this->getStatusCode() < 100 || $this->getStatusCode() >= 600;
}

            

                public function getIsNotFound()
{
    return $this->getStatusCode() == 404;
}

            

                public function getIsOk()
{
    return $this->getStatusCode() == 200;
}

            

                public function getIsRedirection()
{
    return $this->getStatusCode() >= 300 && $this->getStatusCode() < 400;
}

            

                public function getIsServerError()
{
    return $this->getStatusCode() >= 500 && $this->getStatusCode() < 600;
}

            

                public function getIsSuccessful()
{
    return $this->getStatusCode() >= 200 && $this->getStatusCode() < 300;
}

            

                public function getStatusCode()
{
    return $this->_statusCode;
}

            

                public function init()
{
    if ($this->version === null) {
        if (isset($_SERVER['SERVER_PROTOCOL']) && $_SERVER['SERVER_PROTOCOL'] === 'HTTP/1.0') {
            $this->version = '1.0';
        } else {
            $this->version = '1.1';
        }
    }
    if ($this->charset === null) {
        $this->charset = Yii::$app->charset;
    }
    $this->formatters = array_merge($this->defaultFormatters(), $this->formatters);
}

            

                protected function prepare()
{
    if (in_array($this->getStatusCode(), [204, 304])) {
        // A 204/304 response cannot contain a message body according to rfc7231/rfc7232
        $this->content = '';
        $this->stream = null;
        return;
    }
    if ($this->stream !== null) {
        return;
    }
    if (isset($this->formatters[$this->format])) {
        $formatter = $this->formatters[$this->format];
        if (!is_object($formatter)) {
            $this->formatters[$this->format] = $formatter = Yii::createObject($formatter);
        }
        if ($formatter instanceof ResponseFormatterInterface) {
            $formatter->format($this);
        } else {
            throw new InvalidConfigException("The '{$this->format}' response formatter is invalid. It must implement the ResponseFormatterInterface.");
        }
    } elseif ($this->format === self::FORMAT_RAW) {
        if ($this->data !== null) {
            $this->content = $this->data;
        }
    } else {
        throw new InvalidConfigException("Unsupported response format: {$this->format}");
    }
    if (is_array($this->content)) {
        throw new InvalidArgumentException('Response content must not be an array.');
    } elseif (is_object($this->content)) {
        if (method_exists($this->content, '__toString')) {
            $this->content = $this->content->__toString();
        } else {
            throw new InvalidArgumentException('Response content must be a string or an object implementing __toString().');
        }
    }
}

            

                public function redirect($url, $statusCode = 302, $checkAjax = true)
{
    if (is_array($url) && isset($url[0])) {
        // ensure the route is absolute
        $url[0] = '/' . ltrim($url[0], '/');
    }
    $request = Yii::$app->getRequest();
    $normalizedUrl = Url::to($url);
    if ($normalizedUrl !== null) {
        if (preg_match('/\n/', $normalizedUrl)) {
            throw new InvalidRouteException('Route with new line character detected "' . $normalizedUrl . '".');
        }
        if (strncmp($normalizedUrl, '/', 1) === 0 && strncmp($normalizedUrl, '//', 2) !== 0) {
            $normalizedUrl = $request->getHostInfo() . $normalizedUrl;
        }
    }
    if ($checkAjax && $request->getIsAjax()) {
        if (
            in_array($statusCode, [301, 302])
            && preg_match('/Trident\/|MSIE /', (string)$request->userAgent)
        ) {
            $statusCode = 200;
        }
        if ($request->getIsPjax()) {
            $this->getHeaders()->set('X-Pjax-Url', $normalizedUrl);
        } else {
            $this->getHeaders()->set('X-Redirect', $normalizedUrl);
        }
    } else {
        $this->getHeaders()->set('Location', $normalizedUrl);
    }
    $this->setStatusCode($statusCode);
    return $this;
}

            

                public function refresh($anchor = '')
{
    return $this->redirect(Yii::$app->getRequest()->getUrl() . $anchor);
}

            

                public function send()
{
    if ($this->isSent) {
        return;
    }
    $this->trigger(self::EVENT_BEFORE_SEND);
    $this->prepare();
    $this->trigger(self::EVENT_AFTER_PREPARE);
    $this->sendHeaders();
    $this->sendContent();
    $this->trigger(self::EVENT_AFTER_SEND);
    $this->isSent = true;
}

            

                protected function sendContent()
{
    if ($this->stream === null) {
        echo $this->content;
        return;
    }
    // Try to reset time limit for big files
    if (!function_exists('set_time_limit') || !@set_time_limit(0)) {
        Yii::warning('set_time_limit() is not available', __METHOD__);
    }
    if (is_callable($this->stream)) {
        $data = call_user_func($this->stream);
        foreach ($data as $datum) {
            echo $datum;
            flush();
        }
        return;
    }
    $chunkSize = 8 * 1024 * 1024; // 8MB per chunk
    if (is_array($this->stream)) {
        list($handle, $begin, $end) = $this->stream;
        // only seek if stream is seekable
        if ($this->isSeekable($handle)) {
            fseek($handle, $begin);
        }
        while (!feof($handle) && ($pos = ftell($handle)) <= $end) {
            if ($pos + $chunkSize > $end) {
                $chunkSize = $end - $pos + 1;
            }
            echo fread($handle, $chunkSize);
            flush(); // Free up memory. Otherwise large files will trigger PHP's memory limit.
        }
        fclose($handle);
    } else {
        while (!feof($this->stream)) {
            echo fread($this->stream, $chunkSize);
            flush();
        }
        fclose($this->stream);
    }
}

            

                public function sendContentAsFile($content, $attachmentName, $options = [])
{
    $headers = $this->getHeaders();
    $contentLength = StringHelper::byteLength($content);
    $range = $this->getHttpRange($contentLength);
    if ($range === false) {
        $headers->set('Content-Range', "bytes */$contentLength");
        throw new RangeNotSatisfiableHttpException();
    }
    list($begin, $end) = $range;
    if ($begin != 0 || $end != $contentLength - 1) {
        $this->setStatusCode(206);
        $headers->set('Content-Range', "bytes $begin-$end/$contentLength");
        $this->content = StringHelper::byteSubstr($content, $begin, $end - $begin + 1);
    } else {
        $this->setStatusCode(200);
        $this->content = $content;
    }
    $mimeType = isset($options['mimeType']) ? $options['mimeType'] : 'application/octet-stream';
    $this->setDownloadHeaders($attachmentName, $mimeType, !empty($options['inline']), $end - $begin + 1);
    $this->format = self::FORMAT_RAW;
    return $this;
}

            

                protected function sendCookies()
{
    if ($this->_cookies === null) {
        return;
    }
    $request = Yii::$app->getRequest();
    if ($request->enableCookieValidation) {
        if ($request->cookieValidationKey == '') {
            throw new InvalidConfigException(get_class($request) . '::cookieValidationKey must be configured with a secret key.');
        }
        $validationKey = $request->cookieValidationKey;
    }
    foreach ($this->getCookies() as $cookie) {
        $value = $cookie->value;
        $expire = $cookie->expire;
        if (is_string($expire)) {
            $expire = strtotime($expire);
        } elseif (interface_exists('\\DateTimeInterface') && $expire instanceof \DateTimeInterface) {
            $expire = $expire->getTimestamp();
        }
        if ($expire === null || $expire === false) {
            $expire = 0;
        }
        if ($expire != 1 && isset($validationKey)) {
            $value = Yii::$app->getSecurity()->hashData(serialize([$cookie->name, $value]), $validationKey);
        }
        if (PHP_VERSION_ID >= 70300) {
            setcookie($cookie->name, $value, [
                'expires' => $expire,
                'path' => $cookie->path,
                'domain' => $cookie->domain,
                'secure' => $cookie->secure,
                'httpOnly' => $cookie->httpOnly,
                'sameSite' => !empty($cookie->sameSite) ? $cookie->sameSite : null,
            ]);
        } else {
            // Work around for setting sameSite cookie prior PHP 7.3
            // https://stackoverflow.com/questions/39750906/php-setcookie-samesite-strict/46971326#46971326
            $cookiePath = $cookie->path;
            if (!is_null($cookie->sameSite)) {
                $cookiePath .= '; samesite=' . $cookie->sameSite;
            }
            setcookie($cookie->name, $value, $expire, $cookiePath, $cookie->domain, $cookie->secure, $cookie->httpOnly);
        }
    }
}

            

                public function sendFile($filePath, $attachmentName = null, $options = [])
{
    if (!isset($options['mimeType'])) {
        $options['mimeType'] = FileHelper::getMimeTypeByExtension($filePath);
    }
    if ($attachmentName === null) {
        $attachmentName = basename($filePath);
    }
    $handle = fopen($filePath, 'rb');
    $this->sendStreamAsFile($handle, $attachmentName, $options);
    return $this;
}

            

                protected function sendHeaders()
{
    if (headers_sent($file, $line)) {
        throw new HeadersAlreadySentException($file, $line);
    }
    if ($this->_headers) {
        foreach ($this->getHeaders() as $name => $values) {
            $name = str_replace(' ', '-', ucwords(str_replace('-', ' ', $name)));
            // set replace for first occurrence of header but false afterwards to allow multiple
            $replace = true;
            foreach ($values as $value) {
                header("$name: $value", $replace);
                $replace = false;
            }
        }
    }
    $statusCode = $this->getStatusCode();
    header("HTTP/{$this->version} {$statusCode} {$this->statusText}");
    $this->sendCookies();
}

            

                public function sendStreamAsFile($handle, $attachmentName, $options = [])
{
    $headers = $this->getHeaders();
    if (isset($options['fileSize'])) {
        $fileSize = $options['fileSize'];
    } else {
        if ($this->isSeekable($handle)) {
            fseek($handle, 0, SEEK_END);
            $fileSize = ftell($handle);
        } else {
            $fileSize = 0;
        }
    }
    $range = $this->getHttpRange($fileSize);
    if ($range === false) {
        $headers->set('Content-Range', "bytes */$fileSize");
        throw new RangeNotSatisfiableHttpException();
    }
    list($begin, $end) = $range;
    if ($begin != 0 || $end != $fileSize - 1) {
        $this->setStatusCode(206);
        $headers->set('Content-Range', "bytes $begin-$end/$fileSize");
    } else {
        $this->setStatusCode(200);
    }
    $mimeType = isset($options['mimeType']) ? $options['mimeType'] : 'application/octet-stream';
    $this->setDownloadHeaders($attachmentName, $mimeType, !empty($options['inline']), $end - $begin + 1);
    $this->format = self::FORMAT_RAW;
    $this->stream = [$handle, $begin, $end];
    return $this;
}

            

                public function setDownloadHeaders($attachmentName, $mimeType = null, $inline = false, $contentLength = null)
{
    $headers = $this->getHeaders();
    $disposition = $inline ? 'inline' : 'attachment';
    $headers->setDefault('Pragma', 'public')
        ->setDefault('Accept-Ranges', 'bytes')
        ->setDefault('Expires', '0')
        ->setDefault('Cache-Control', 'must-revalidate, post-check=0, pre-check=0')
        ->setDefault('Content-Disposition', $this->getDispositionHeaderValue($disposition, $attachmentName));
    if ($mimeType !== null) {
        $headers->setDefault('Content-Type', $mimeType);
    }
    if ($contentLength !== null) {
        $headers->setDefault('Content-Length', $contentLength);
    }
    return $this;
}

            

                public function setStatusCode($value, $text = null)
{
    if ($value === null) {
        $value = 200;
    }
    $this->_statusCode = (int) $value;
    if ($this->getIsInvalid()) {
        throw new InvalidArgumentException("The HTTP status code is invalid: $value");
    }
    if ($text === null) {
        $this->statusText = isset(static::$httpStatuses[$this->_statusCode]) ? static::$httpStatuses[$this->_statusCode] : '';
    } else {
        $this->statusText = $text;
    }
    return $this;
}

            

                public function setStatusCodeByException($e)
{
    if ($e instanceof HttpException) {
        $this->setStatusCode($e->statusCode);
    } else {
        $this->setStatusCode(500);
    }
    return $this;
}

            

                public function xSendFile($filePath, $attachmentName = null, $options = [])
{
    if ($attachmentName === null) {
        $attachmentName = basename($filePath);
    }
    if (isset($options['mimeType'])) {
        $mimeType = $options['mimeType'];
    } elseif (($mimeType = FileHelper::getMimeTypeByExtension($filePath)) === null) {
        $mimeType = 'application/octet-stream';
    }
    if (isset($options['xHeader'])) {
        $xHeader = $options['xHeader'];
    } else {
        $xHeader = 'X-Sendfile';
    }
    $disposition = empty($options['inline']) ? 'attachment' : 'inline';
    $this->getHeaders()
        ->setDefault($xHeader, $filePath)
        ->setDefault('Content-Type', $mimeType)
        ->setDefault('Content-Disposition', $this->getDispositionHeaderValue($disposition, $attachmentName));
    $this->format = self::FORMAT_RAW;
    return $this;
}