Response.php 26.6 KB
Newer Older
Qiang Xue committed
1 2 3
<?php
/**
 * @link http://www.yiiframework.com/
Qiang Xue committed
4
 * @copyright Copyright (c) 2008 Yii Software LLC
Qiang Xue committed
5 6 7 8 9
 * @license http://www.yiiframework.com/license/
 */

namespace yii\web;

Qiang Xue committed
10
use Yii;
11
use yii\base\InvalidConfigException;
Qiang Xue committed
12
use yii\base\InvalidParamException;
Qiang Xue committed
13
use yii\helpers\FileHelper;
Qiang Xue committed
14
use yii\helpers\Html;
Qiang Xue committed
15
use yii\helpers\Json;
16
use yii\helpers\Security;
17
use yii\helpers\StringHelper;
Qiang Xue committed
18 19

/**
20 21 22 23
 * The web Response class represents an HTTP response
 *
 * It holds the [[headers]], [[cookies]] and [[content]] that is to be sent to the client.
 * It also controls the HTTP [[statusCode|status code]].
24
 *
25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40
 * @property CookieCollection $cookies The cookie collection. This property is read-only.
 * @property HeaderCollection $headers The header collection. This property is read-only.
 * @property boolean $isClientError Whether this response indicates a client error. This property is
 * read-only.
 * @property boolean $isEmpty Whether this response is empty. This property is read-only.
 * @property boolean $isForbidden Whether this response indicates the current request is forbidden. This
 * property is read-only.
 * @property boolean $isInformational Whether this response is informational. This property is read-only.
 * @property boolean $isInvalid Whether this response has a valid [[statusCode]]. This property is read-only.
 * @property boolean $isNotFound Whether this response indicates the currently requested resource is not
 * found. This property is read-only.
 * @property boolean $isOk Whether this response is OK. This property is read-only.
 * @property boolean $isRedirection Whether this response is a redirection. This property is read-only.
 * @property boolean $isServerError Whether this response indicates a server error. This property is
 * read-only.
 * @property boolean $isSuccessful Whether this response is successful. This property is read-only.
41 42
 * @property integer $statusCode The HTTP status code to send with the response.
 *
Qiang Xue committed
43
 * @author Qiang Xue <qiang.xue@gmail.com>
44
 * @author Carsten Brandt <mail@cebe.cc>
Qiang Xue committed
45 46 47 48
 * @since 2.0
 */
class Response extends \yii\base\Response
{
49 50 51 52 53 54 55 56 57 58 59 60
	/**
	 * @event ResponseEvent an event that is triggered at the beginning of [[send()]].
	 */
	const EVENT_BEFORE_SEND = 'beforeSend';
	/**
	 * @event ResponseEvent an event that is triggered at the end of [[send()]].
	 */
	const EVENT_AFTER_SEND = 'afterSend';
	/**
	 * @event ResponseEvent an event that is triggered right after [[prepare()]] is called in [[send()]].
	 * You may respond to this event to filter the response content before it is sent to the client.
	 */
Qiang Xue committed
61
	const EVENT_AFTER_PREPARE = 'afterPrepare';
62

63 64 65 66 67 68 69
	const FORMAT_RAW = 'raw';
	const FORMAT_HTML = 'html';
	const FORMAT_JSON = 'json';
	const FORMAT_JSONP = 'jsonp';
	const FORMAT_XML = 'xml';

	/**
70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87
	 * @var string the response format. This determines how to convert [[data]] into [[content]]
	 * when the latter is not set. By default, the following formats are supported:
	 *
	 * - [[FORMAT_RAW]]: the data will be treated as the response content without any conversion.
	 *   No extra HTTP header will be added.
	 * - [[FORMAT_HTML]]: the data will be treated as the response content without any conversion.
	 *   The "Content-Type" header will set as "text/html" if it is not set previously.
	 * - [[FORMAT_JSON]]: the data will be converted into JSON format, and the "Content-Type"
	 *   header will be set as "application/json".
	 * - [[FORMAT_JSONP]]: the data will be converted into JSONP format, and the "Content-Type"
	 *   header will be set as "text/javascript". Note that in this case `$data` must be an array
	 *   with "data" and "callback" elements. The former refers to the actual data to be sent,
	 *   while the latter refers to the name of the JavaScript callback.
	 * - [[FORMAT_XML]]: the data will be converted into XML format. Please refer to [[XmlResponseFormatter]]
	 *   for more details.
	 *
	 * You may customize the formatting process or support additional formats by configuring [[formatters]].
	 * @see formatters
88 89
	 */
	public $format = self::FORMAT_HTML;
Qiang Xue committed
90 91 92 93
	/**
	 * @var array the formatters for converting data into the response content of the specified [[format]].
	 * The array keys are the format names, and the array values are the corresponding configurations
	 * for creating the formatter objects.
94
	 * @see format
Qiang Xue committed
95 96
	 */
	public $formatters;
97 98 99 100 101 102 103 104 105 106 107 108
	/**
	 * @var mixed the original response data. When this is not null, it will be converted into [[content]]
	 * according to [[format]] when the response is being sent out.
	 * @see content
	 */
	public $data;
	/**
	 * @var string the response content. When [[data]] is not null, it will be converted into [[content]]
	 * according to [[format]] when the response is being sent out.
	 * @see data
	 */
	public $content;
109 110 111 112 113
	/**
	 * @var string the charset of the text response. If not set, it will use
	 * the value of [[Application::charset]].
	 */
	public $charset;
Qiang Xue committed
114 115 116 117 118
	/**
	 * @var string
	 */
	public $statusText;
	/**
119 120
	 * @var string the version of the HTTP protocol to use. If not set, it will be determined via `$_SERVER['SERVER_PROTOCOL']`,
	 * or '1.1' if that is not available.
Qiang Xue committed
121
	 */
122
	public $version;
Qiang Xue committed
123 124 125
	/**
	 * @var array list of HTTP status codes and the corresponding texts
	 */
Alexander Makarov committed
126
	public static $httpStatuses = [
Qiang Xue committed
127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169
		100 => 'Continue',
		101 => 'Switching Protocols',
		102 => 'Processing',
		118 => 'Connection timed out',
		200 => 'OK',
		201 => 'Created',
		202 => 'Accepted',
		203 => 'Non-Authoritative',
		204 => 'No Content',
		205 => 'Reset Content',
		206 => 'Partial Content',
		207 => 'Multi-Status',
		208 => 'Already Reported',
		210 => 'Content Different',
		226 => 'IM Used',
		300 => 'Multiple Choices',
		301 => 'Moved Permanently',
		302 => 'Found',
		303 => 'See Other',
		304 => 'Not Modified',
		305 => 'Use Proxy',
		306 => 'Reserved',
		307 => 'Temporary Redirect',
		308 => 'Permanent Redirect',
		310 => 'Too many Redirect',
		400 => 'Bad Request',
		401 => 'Unauthorized',
		402 => 'Payment Required',
		403 => 'Forbidden',
		404 => 'Not Found',
		405 => 'Method Not Allowed',
		406 => 'Not Acceptable',
		407 => 'Proxy Authentication Required',
		408 => 'Request Time-out',
		409 => 'Conflict',
		410 => 'Gone',
		411 => 'Length Required',
		412 => 'Precondition Failed',
		413 => 'Request Entity Too Large',
		414 => 'Request-URI Too Long',
		415 => 'Unsupported Media Type',
		416 => 'Requested range unsatisfiable',
		417 => 'Expectation failed',
170
		418 => 'I\'m a teapot',
Qiang Xue committed
171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191
		422 => 'Unprocessable entity',
		423 => 'Locked',
		424 => 'Method failure',
		425 => 'Unordered Collection',
		426 => 'Upgrade Required',
		428 => 'Precondition Required',
		429 => 'Too Many Requests',
		431 => 'Request Header Fields Too Large',
		449 => 'Retry With',
		450 => 'Blocked by Windows Parental Controls',
		500 => 'Internal Server Error',
		501 => 'Not Implemented',
		502 => 'Bad Gateway ou Proxy Error',
		503 => 'Service Unavailable',
		504 => 'Gateway Time-out',
		505 => 'HTTP Version not supported',
		507 => 'Insufficient storage',
		508 => 'Loop Detected',
		509 => 'Bandwidth Limit Exceeded',
		510 => 'Not Extended',
		511 => 'Network Authentication Required',
Alexander Makarov committed
192
	];
Qiang Xue committed
193

194 195 196
	/**
	 * @var integer the HTTP status code to send with the response.
	 */
Qiang Xue committed
197
	private $_statusCode;
Qiang Xue committed
198 199 200
	/**
	 * @var HeaderCollection
	 */
Qiang Xue committed
201 202
	private $_headers;

Qiang Xue committed
203 204 205
	/**
	 * Initializes this component.
	 */
Qiang Xue committed
206 207
	public function init()
	{
208 209 210 211 212 213
		if ($this->version === null) {
			if (isset($_SERVER['SERVER_PROTOCOL']) && $_SERVER['SERVER_PROTOCOL'] === '1.0') {
				$this->version = '1.0';
			} else {
				$this->version = '1.1';
			}
Qiang Xue committed
214
		}
215 216 217
		if ($this->charset === null) {
			$this->charset = Yii::$app->charset;
		}
Qiang Xue committed
218 219
	}

220 221 222
	/**
	 * @return integer the HTTP status code to send with the response.
	 */
Qiang Xue committed
223 224 225 226 227
	public function getStatusCode()
	{
		return $this->_statusCode;
	}

Qiang Xue committed
228 229 230 231 232 233 234
	/**
	 * Sets the response status code.
	 * This method will set the corresponding status text if `$text` is null.
	 * @param integer $value the status code
	 * @param string $text the status text. If not set, it will be set automatically based on the status code.
	 * @throws InvalidParamException if the status code is invalid.
	 */
Qiang Xue committed
235
	public function setStatusCode($value, $text = null)
Qiang Xue committed
236
	{
Qiang Xue committed
237 238 239 240 241
		if ($value === null) {
			$this->_statusCode = null;
			$this->statusText = null;
			return;
		}
Qiang Xue committed
242
		$this->_statusCode = (int)$value;
243
		if ($this->getIsInvalid()) {
Qiang Xue committed
244 245
			throw new InvalidParamException("The HTTP status code is invalid: $value");
		}
Qiang Xue committed
246
		if ($text === null) {
Qiang Xue committed
247
			$this->statusText = isset(self::$httpStatuses[$this->_statusCode]) ? self::$httpStatuses[$this->_statusCode] : '';
Qiang Xue committed
248 249 250
		} else {
			$this->statusText = $text;
		}
Qiang Xue committed
251 252
	}

Qiang Xue committed
253 254 255 256 257 258 259 260 261 262 263 264 265
	/**
	 * Returns the header collection.
	 * The header collection contains the currently registered HTTP headers.
	 * @return HeaderCollection the header collection
	 */
	public function getHeaders()
	{
		if ($this->_headers === null) {
			$this->_headers = new HeaderCollection;
		}
		return $this->_headers;
	}

Qiang Xue committed
266 267 268 269 270
	/**
	 * Sends the response to the client.
	 */
	public function send()
	{
271 272
		$this->trigger(self::EVENT_BEFORE_SEND, new ResponseEvent($this));
		$this->prepare();
Qiang Xue committed
273
		$this->trigger(self::EVENT_AFTER_PREPARE, new ResponseEvent($this));
Qiang Xue committed
274 275
		$this->sendHeaders();
		$this->sendContent();
276
		$this->trigger(self::EVENT_AFTER_SEND, new ResponseEvent($this));
Qiang Xue committed
277 278
	}

Qiang Xue committed
279 280 281
	/**
	 * Clears the headers, cookies, content, status code of the response.
	 */
282
	public function clear()
Qiang Xue committed
283 284
	{
		$this->_headers = null;
Qiang Xue committed
285
		$this->_cookies = null;
Qiang Xue committed
286
		$this->_statusCode = null;
287 288
		$this->data = null;
		$this->content = null;
Qiang Xue committed
289 290 291
		$this->statusText = null;
	}

Qiang Xue committed
292 293 294 295 296
	/**
	 * Sends the response headers to the client
	 */
	protected function sendHeaders()
	{
Qiang Xue committed
297 298 299
		if (headers_sent()) {
			return;
		}
Qiang Xue committed
300 301 302 303
		$statusCode = $this->getStatusCode();
		if ($statusCode !== null) {
			header("HTTP/{$this->version} $statusCode {$this->statusText}");
		}
Qiang Xue committed
304 305 306
		if ($this->_headers) {
			$headers = $this->getHeaders();
			foreach ($headers as $name => $values) {
Qiang Xue committed
307
				$name = str_replace(' ', '-', ucwords(str_replace('-', ' ', $name)));
Qiang Xue committed
308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330
				foreach ($values as $value) {
					header("$name: $value", false);
				}
			}
		}
		$this->sendCookies();
	}

	/**
	 * Sends the cookies to the client.
	 */
	protected function sendCookies()
	{
		if ($this->_cookies === null) {
			return;
		}
		$request = Yii::$app->getRequest();
		if ($request->enableCookieValidation) {
			$validationKey = $request->getCookieValidationKey();
		}
		foreach ($this->getCookies() as $cookie) {
			$value = $cookie->value;
			if ($cookie->expire != 1  && isset($validationKey)) {
331
				$value = Security::hashData(serialize($value), $validationKey);
Qiang Xue committed
332
			}
Qiang Xue committed
333
			setcookie($cookie->name, $value, $cookie->expire, $cookie->path, $cookie->domain, $cookie->secure, $cookie->httpOnly);
Qiang Xue committed
334
		}
Qiang Xue committed
335
		$this->getCookies()->removeAll();
Qiang Xue committed
336 337 338 339 340 341 342
	}

	/**
	 * Sends the response content to the client
	 */
	protected function sendContent()
	{
Qiang Xue committed
343
		echo $this->content;
Qiang Xue committed
344 345
	}

Qiang Xue committed
346
	/**
347 348 349
	 * Sends a file to the browser.
	 * @param string $filePath the path of the file to be sent.
	 * @param string $attachmentName the file name shown to the user. If null, it will be determined from `$filePath`.
Qiang Xue committed
350
	 * @param string $mimeType the MIME type of the content. If null, it will be guessed based on `$filePath`
Qiang Xue committed
351
	 */
Qiang Xue committed
352
	public function sendFile($filePath, $attachmentName = null, $mimeType = null)
Qiang Xue committed
353
	{
354
		if ($mimeType === null && ($mimeType = FileHelper::getMimeTypeByExtension($filePath)) === null) {
355
			$mimeType = 'application/octet-stream';
Qiang Xue committed
356
		}
357 358
		if ($attachmentName === null) {
			$attachmentName = basename($filePath);
359
		}
360
		$handle = fopen($filePath, 'rb');
Qiang Xue committed
361
		$this->sendStreamAsFile($handle, $attachmentName, $mimeType);
362
	}
363

364 365 366 367
	/**
	 * Sends the specified content as a file to the browser.
	 * @param string $content the content to be sent. The existing [[content]] will be discarded.
	 * @param string $attachmentName the file name shown to the user.
Qiang Xue committed
368
	 * @param string $mimeType the MIME type of the content.
369
	 * @throws HttpException if the requested range is not satisfiable
370
	 */
371
	public function sendContentAsFile($content, $attachmentName, $mimeType = 'application/octet-stream')
372
	{
373 374 375 376 377 378 379 380
		$headers = $this->getHeaders();
		$contentLength = StringHelper::strlen($content);
		$range = $this->getHttpRange($contentLength);
		if ($range === false) {
			$headers->set('Content-Range', "bytes */$contentLength");
			throw new HttpException(416, Yii::t('yii', 'Requested range not satisfiable'));
		}

381 382 383 384 385 386 387 388
		$headers->setDefault('Pragma', 'public')
			->setDefault('Accept-Ranges', 'bytes')
			->setDefault('Expires', '0')
			->setDefault('Content-Type', $mimeType)
			->setDefault('Cache-Control', 'must-revalidate, post-check=0, pre-check=0')
			->setDefault('Content-Transfer-Encoding', 'binary')
			->setDefault('Content-Length', StringHelper::strlen($content))
			->setDefault('Content-Disposition', "attachment; filename=\"$attachmentName\"");
389

390 391 392 393
		list($begin, $end) = $range;
		if ($begin !=0 || $end != $contentLength - 1) {
			$this->setStatusCode(206);
			$headers->set('Content-Range', "bytes $begin-$end/$contentLength");
394
			$this->content = StringHelper::substr($content, $begin, $end - $begin + 1);
395 396
		} else {
			$this->setStatusCode(200);
397
			$this->content = $content;
398 399
		}

400
		$this->format = self::FORMAT_RAW;
401
		$this->send();
Qiang Xue committed
402 403
	}

404 405 406 407
	/**
	 * Sends the specified stream as a file to the browser.
	 * @param resource $handle the handle of the stream to be sent.
	 * @param string $attachmentName the file name shown to the user.
Qiang Xue committed
408
	 * @param string $mimeType the MIME type of the stream content.
409 410
	 * @throws HttpException if the requested range cannot be satisfied.
	 */
411
	public function sendStreamAsFile($handle, $attachmentName, $mimeType = 'application/octet-stream')
Qiang Xue committed
412
	{
413
		$headers = $this->getHeaders();
Qiang Xue committed
414 415 416
		fseek($handle, 0, SEEK_END);
		$fileSize = ftell($handle);

417 418 419 420 421
		$range = $this->getHttpRange($fileSize);
		if ($range === false) {
			$headers->set('Content-Range', "bytes */$fileSize");
			throw new HttpException(416, Yii::t('yii', 'Requested range not satisfiable'));
		}
Qiang Xue committed
422

423 424
		list($begin, $end) = $range;
		if ($begin !=0 || $end != $fileSize - 1) {
Qiang Xue committed
425
			$this->setStatusCode(206);
426
			$headers->set('Content-Range', "bytes $begin-$end/$fileSize");
Qiang Xue committed
427 428 429 430
		} else {
			$this->setStatusCode(200);
		}

431
		$length = $end - $begin + 1;
Qiang Xue committed
432

433 434 435 436 437 438 439 440
		$headers->setDefault('Pragma', 'public')
			->setDefault('Accept-Ranges', 'bytes')
			->setDefault('Expires', '0')
			->setDefault('Content-Type', $mimeType)
			->setDefault('Cache-Control', 'must-revalidate, post-check=0, pre-check=0')
			->setDefault('Content-Transfer-Encoding', 'binary')
			->setDefault('Content-Length', $length)
			->setDefault('Content-Disposition', "attachment; filename=\"$attachmentName\"");
441 442
		$this->format = self::FORMAT_RAW;
		$this->data = $this->content = null;
443
		$this->send();
Qiang Xue committed
444

445
		fseek($handle, $begin);
Qiang Xue committed
446 447
		set_time_limit(0); // Reset time limit for big files
		$chunkSize = 8 * 1024 * 1024; // 8MB per chunk
448 449 450
		while (!feof($handle) && ($pos = ftell($handle)) <= $end) {
			if ($pos + $chunkSize > $end) {
				$chunkSize = $end - $pos + 1;
Qiang Xue committed
451 452 453 454 455 456 457
			}
			echo fread($handle, $chunkSize);
			flush(); // Free up memory. Otherwise large files will trigger PHP's memory limit.
		}
		fclose($handle);
	}

458 459 460 461 462 463 464 465
	/**
	 * Determines the HTTP range given in the request.
	 * @param integer $fileSize the size of the file that will be used to validate the requested HTTP range.
	 * @return array|boolean the range (begin, end), or false if the range request is invalid.
	 */
	protected function getHttpRange($fileSize)
	{
		if (!isset($_SERVER['HTTP_RANGE']) || $_SERVER['HTTP_RANGE'] === '-') {
Alexander Makarov committed
466
			return [0, $fileSize - 1];
467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486
		}
		if (!preg_match('/^bytes=(\d*)-(\d*)$/', $_SERVER['HTTP_RANGE'], $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;
		} else {
Alexander Makarov committed
487
			return [$start, $end];
488 489 490
		}
	}

Qiang Xue committed
491 492 493 494 495 496 497 498 499 500 501 502 503 504
	/**
	 * Sends existing file to a browser as a download using x-sendfile.
	 *
	 * X-Sendfile is a feature allowing a web application to redirect the request for a file to the webserver
	 * that in turn processes the request, this way eliminating the need to perform tasks like reading the file
	 * and sending it to the user. When dealing with a lot of files (or very big files) this can lead to a great
	 * increase in performance as the web application is allowed to terminate earlier while the webserver is
	 * handling the request.
	 *
	 * The request is sent to the server through a special non-standard HTTP-header.
	 * When the web server encounters the presence of such header it will discard all output and send the file
	 * specified by that header using web server internals including all optimizations like caching-headers.
	 *
	 * As this header directive is non-standard different directives exists for different web servers applications:
Qiang Xue committed
505 506 507 508 509 510 511
	 * 
	 * - Apache: [X-Sendfile](http://tn123.org/mod_xsendfile) 
	 * - Lighttpd v1.4: [X-LIGHTTPD-send-file](http://redmine.lighttpd.net/projects/lighttpd/wiki/X-LIGHTTPD-send-file)
	 * - Lighttpd v1.5: [X-Sendfile](http://redmine.lighttpd.net/projects/lighttpd/wiki/X-LIGHTTPD-send-file)
	 * - Nginx: [X-Accel-Redirect](http://wiki.nginx.org/XSendfile)
	 * - Cherokee: [X-Sendfile and X-Accel-Redirect](http://www.cherokee-project.com/doc/other_goodies.html#x-sendfile)
	 *
Qiang Xue committed
512 513 514
	 * So for this method to work the X-SENDFILE option/module should be enabled by the web server and
	 * a proper xHeader should be sent.
	 *
Qiang Xue committed
515 516 517 518
	 * **Note**
	 * 
	 * This option allows to download files that are not under web folders, and even files that are otherwise protected 
	 * (deny from all) like `.htaccess`.
Qiang Xue committed
519
	 *
Qiang Xue committed
520 521
	 * **Side effects**
	 * 
Qiang Xue committed
522 523 524
	 * If this option is disabled by the web server, when this method is called a download configuration dialog
	 * will open but the downloaded file will have 0 bytes.
	 *
Qiang Xue committed
525 526
	 * **Known issues**
	 * 
Qiang Xue committed
527
	 * There is a Bug with Internet Explorer 6, 7 and 8 when X-SENDFILE is used over an SSL connection, it will show
Qiang Xue committed
528 529 530 531 532 533
	 * an error message like this: "Internet Explorer was not able to open this Internet site. The requested site 
	 * is either unavailable or cannot be found.". You can work around this problem by removing the `Pragma`-header.
	 *
	 * **Example**
	 * 
	 * ~~~
Ryadnov committed
534
	 * Yii::$app->request->xSendFile('/home/user/Pictures/picture1.jpg');
535
	 * ~~~
Qiang Xue committed
536
	 *
Qiang Xue committed
537
	 * @param string $filePath file name with full path
538 539 540
	 * @param string $mimeType the MIME type of the file. If null, it will be determined based on `$filePath`.
	 * @param string $attachmentName file name shown to the user. If null, it will be determined from `$filePath`.
	 * @param string $xHeader the name of the x-sendfile header.
Qiang Xue committed
541
	 */
Qiang Xue committed
542
	public function xSendFile($filePath, $attachmentName = null, $mimeType = null, $xHeader = 'X-Sendfile')
Qiang Xue committed
543
	{
544 545
		if ($mimeType === null && ($mimeType = FileHelper::getMimeTypeByExtension($filePath)) === null) {
			$mimeType = 'application/octet-stream';
Qiang Xue committed
546
		}
547 548
		if ($attachmentName === null) {
			$attachmentName = basename($filePath);
Qiang Xue committed
549
		}
Qiang Xue committed
550

551
		$this->getHeaders()
552 553 554
			->setDefault($xHeader, $filePath)
			->setDefault('Content-Type', $mimeType)
			->setDefault('Content-Disposition', "attachment; filename=\"$attachmentName\"");
Qiang Xue committed
555

Qiang Xue committed
556
		$this->send();
Qiang Xue committed
557
	}
Qiang Xue committed
558 559 560

	/**
	 * Redirects the browser to the specified URL.
Qiang Xue committed
561
	 *
Qiang Xue committed
562 563 564 565 566 567 568 569 570 571 572 573 574 575
	 * This method adds a "Location" header to the current response. Note that it does not send out
	 * the header until [[send()]] is called. In a controller action you may use this method as follows:
	 *
	 * ~~~
	 * return Yii::$app->getResponse()->redirect($url);
	 * ~~~
	 *
	 * In other places, if you want to send out the "Location" header immediately, you should use
	 * the following code:
	 *
	 * ~~~
	 * Yii::$app->getResponse()->redirect($url)->send();
	 * return;
	 * ~~~
Qiang Xue committed
576
	 *
Qiang Xue committed
577 578
	 * In AJAX mode, this normally will not work as expected unless there are some
	 * client-side JavaScript code handling the redirection. To help achieve this goal,
Qiang Xue committed
579 580 581 582 583
	 * this method will send out a "X-Redirect" header instead of "Location".
	 *
	 * If you use the "yii" JavaScript module, it will handle the AJAX redirection as
	 * described above. Otherwise, you should write the following JavaScript code to
	 * handle the redirection:
Qiang Xue committed
584 585
	 *
	 * ~~~
Qiang Xue committed
586 587 588 589
	 * $document.ajaxComplete(function (event, xhr, settings) {
	 *     var url = xhr.getResponseHeader('X-Redirect');
	 *     if (url) {
	 *         window.location = url;
Qiang Xue committed
590 591 592 593
	 *     }
	 * });
	 * ~~~
	 *
Qiang Xue committed
594 595 596 597
	 * @param string|array $url the URL to be redirected to. This can be in one of the following formats:
	 *
	 * - a string representing a URL (e.g. "http://example.com")
	 * - a string representing a URL alias (e.g. "@example.com")
Alexander Makarov committed
598
	 * - an array in the format of `[$route, ...name-value pairs...]` (e.g. `['site/index', 'ref' => 1]`).
Qiang Xue committed
599 600 601 602 603 604
	 *   Note that the route is with respect to the whole application, instead of relative to a controller or module.
	 *   [[Html::url()]] will be used to convert the array into a URL.
	 *
	 * Any relative URL will be converted into an absolute one by prepending it with the host info
	 * of the current request.
	 *
605
	 * @param integer $statusCode the HTTP status code. Defaults to 302.
Qiang Xue committed
606
	 * See [[http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html]]
607
	 * for details about HTTP status code
608
	 * @return static the response object itself
Qiang Xue committed
609
	 */
610
	public function redirect($url, $statusCode = 302)
Qiang Xue committed
611
	{
Qiang Xue committed
612 613 614 615 616
		if (is_array($url) && isset($url[0])) {
			// ensure the route is absolute
			$url[0] = '/' . ltrim($url[0], '/');
		}
		$url = Html::url($url);
Qiang Xue committed
617 618 619
		if (strpos($url, '/') === 0 && strpos($url, '//') !== 0) {
			$url = Yii::$app->getRequest()->getHostInfo() . $url;
		}
Qiang Xue committed
620 621 622 623 624

		if (Yii::$app->getRequest()->getIsAjax()) {
			$this->getHeaders()->set('X-Redirect', $url);
		} else {
			$this->getHeaders()->set('Location', $url);
Qiang Xue committed
625
		}
Qiang Xue committed
626
		$this->setStatusCode($statusCode);
Qiang Xue committed
627

628
		return $this;
Qiang Xue committed
629
	}
630

631 632 633 634
	/**
	 * Refreshes the current page.
	 * The effect of this method call is the same as the user pressing the refresh button of his browser
	 * (without re-posting data).
635 636 637 638 639 640 641
	 *
	 * In a controller action you may use this method like this:
	 *
	 * ~~~
	 * return Yii::$app->getResponse()->refresh();
	 * ~~~
	 *
642 643
	 * @param string $anchor the anchor that should be appended to the redirection URL.
	 * Defaults to empty. Make sure the anchor starts with '#' if you want to specify it.
644
	 * @return Response the response object itself
645
	 */
646
	public function refresh($anchor = '')
647
	{
648
		return $this->redirect(Yii::$app->getRequest()->getUrl() . $anchor);
649 650
	}

Qiang Xue committed
651 652
	private $_cookies;

653 654 655 656 657 658
	/**
	 * Returns the cookie collection.
	 * Through the returned cookie collection, you add or remove cookies as follows,
	 *
	 * ~~~
	 * // add a cookie
Alexander Makarov committed
659
	 * $response->cookies->add(new Cookie([
660 661
	 *     'name' => $name,
	 *     'value' => $value,
Alexander Makarov committed
662
	 * ]);
663 664 665 666 667 668 669 670 671 672 673
	 *
	 * // remove a cookie
	 * $response->cookies->remove('name');
	 * // alternatively
	 * unset($response->cookies['name']);
	 * ~~~
	 *
	 * @return CookieCollection the cookie collection.
	 */
	public function getCookies()
	{
Qiang Xue committed
674 675 676 677
		if ($this->_cookies === null) {
			$this->_cookies = new CookieCollection;
		}
		return $this->_cookies;
678
	}
Qiang Xue committed
679 680 681 682

	/**
	 * @return boolean whether this response has a valid [[statusCode]].
	 */
683
	public function getIsInvalid()
Qiang Xue committed
684 685 686 687 688 689 690
	{
		return $this->getStatusCode() < 100 || $this->getStatusCode() >= 600;
	}

	/**
	 * @return boolean whether this response is informational
	 */
691
	public function getIsInformational()
Qiang Xue committed
692 693 694 695 696
	{
		return $this->getStatusCode() >= 100 && $this->getStatusCode() < 200;
	}

	/**
697
	 * @return boolean whether this response is successful
Qiang Xue committed
698
	 */
699
	public function getIsSuccessful()
Qiang Xue committed
700 701 702 703 704 705 706
	{
		return $this->getStatusCode() >= 200 && $this->getStatusCode() < 300;
	}

	/**
	 * @return boolean whether this response is a redirection
	 */
707
	public function getIsRedirection()
Qiang Xue committed
708 709 710 711 712 713 714
	{
		return $this->getStatusCode() >= 300 && $this->getStatusCode() < 400;
	}

	/**
	 * @return boolean whether this response indicates a client error
	 */
715
	public function getIsClientError()
Qiang Xue committed
716 717 718 719 720 721 722
	{
		return $this->getStatusCode() >= 400 && $this->getStatusCode() < 500;
	}

	/**
	 * @return boolean whether this response indicates a server error
	 */
723
	public function getIsServerError()
Qiang Xue committed
724 725 726 727 728 729 730
	{
		return $this->getStatusCode() >= 500 && $this->getStatusCode() < 600;
	}

	/**
	 * @return boolean whether this response is OK
	 */
731
	public function getIsOk()
Qiang Xue committed
732
	{
733
		return $this->getStatusCode() == 200;
Qiang Xue committed
734 735 736 737 738
	}

	/**
	 * @return boolean whether this response indicates the current request is forbidden
	 */
739
	public function getIsForbidden()
Qiang Xue committed
740
	{
741
		return $this->getStatusCode() == 403;
Qiang Xue committed
742 743 744 745 746
	}

	/**
	 * @return boolean whether this response indicates the currently requested resource is not found
	 */
747
	public function getIsNotFound()
Qiang Xue committed
748
	{
749
		return $this->getStatusCode() == 404;
Qiang Xue committed
750 751 752 753 754
	}

	/**
	 * @return boolean whether this response is empty
	 */
755
	public function getIsEmpty()
Qiang Xue committed
756
	{
Alexander Makarov committed
757
		return in_array($this->getStatusCode(), [201, 204, 304]);
Qiang Xue committed
758
	}
759

Qiang Xue committed
760
	/**
761 762
	 * Prepares for sending the response.
	 * The default implementation will convert [[data]] into [[content]] and set headers accordingly.
763
	 * @throws InvalidConfigException if the formatter for the specified format is invalid or [[format]] is not supported
Qiang Xue committed
764
	 */
765
	protected function prepare()
766
	{
767 768 769 770 771 772
		if ($this->data === null) {
			return;
		}

		if (isset($this->formatters[$this->format])) {
			$formatter = $this->formatters[$this->format];
Qiang Xue committed
773 774 775
			if (!is_object($formatter)) {
				$formatter = Yii::createObject($formatter);
			}
776
			if ($formatter instanceof ResponseFormatterInterface) {
777
				$formatter->format($this);
Qiang Xue committed
778
			} else {
779
				throw new InvalidConfigException("The '{$this->format}' response formatter is invalid. It must implement the ResponseFormatterInterface.");
Qiang Xue committed
780
			}
Qiang Xue committed
781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803
		} else {
			switch ($this->format) {
				case self::FORMAT_HTML:
					$this->getHeaders()->setDefault('Content-Type', 'text/html; charset=' . $this->charset);
					$this->content = $this->data;
					break;
				case self::FORMAT_RAW:
					$this->content = $this->data;
					break;
				case self::FORMAT_JSON:
					$this->getHeaders()->set('Content-Type', 'application/json');
					$this->content = Json::encode($this->data);
					break;
				case self::FORMAT_JSONP:
					$this->getHeaders()->set('Content-Type', 'text/javascript; charset=' . $this->charset);
					if (is_array($this->data) && isset($this->data['data'], $this->data['callback'])) {
						$this->content = sprintf('%s(%s);', $this->data['callback'], Json::encode($this->data['data']));
					} else {
						$this->content = '';
						Yii::warning("The 'jsonp' response requires that the data be an array consisting of both 'data' and 'callback' elements.", __METHOD__);
					}
					break;
				case self::FORMAT_XML:
Borro committed
804
					Yii::createObject(XmlResponseFormatter::className())->format($this);
Qiang Xue committed
805 806 807 808
					break;
				default:
					throw new InvalidConfigException("Unsupported response format: {$this->format}");
			}
Qiang Xue committed
809 810
		}

Qiang Xue committed
811 812 813
		if (is_array($this->content)) {
			$this->content = 'array()';
		} elseif (is_object($this->content)) {
814
			$this->content = method_exists($this->content, '__toString') ? $this->content->__toString() : get_class($this->content);
815 816
		}
	}
Qiang Xue committed
817
}