Response.php 24.3 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;
Qiang Xue committed
16
use yii\helpers\SecurityHelper;
17
use yii\helpers\StringHelper;
Qiang Xue committed
18 19 20

/**
 * @author Qiang Xue <qiang.xue@gmail.com>
21
 * @author Carsten Brandt <mail@cebe.cc>
Qiang Xue committed
22 23 24 25
 * @since 2.0
 */
class Response extends \yii\base\Response
{
26 27 28 29 30 31 32 33 34 35 36 37
	/**
	 * @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
38
	const EVENT_AFTER_PREPARE = 'afterPrepare';
39

40 41 42 43 44 45 46
	const FORMAT_RAW = 'raw';
	const FORMAT_HTML = 'html';
	const FORMAT_JSON = 'json';
	const FORMAT_JSONP = 'jsonp';
	const FORMAT_XML = 'xml';

	/**
47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64
	 * @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
65 66
	 */
	public $format = self::FORMAT_HTML;
Qiang Xue committed
67 68 69 70
	/**
	 * @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.
71
	 * @see format
Qiang Xue committed
72 73
	 */
	public $formatters;
74 75 76 77 78 79 80 81 82 83 84 85
	/**
	 * @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;
86 87 88 89 90
	/**
	 * @var string the charset of the text response. If not set, it will use
	 * the value of [[Application::charset]].
	 */
	public $charset;
Qiang Xue committed
91 92 93 94 95 96 97
	/**
	 * @var integer the HTTP status code that should be used when redirecting in AJAX mode.
	 * This is used by [[redirect()]]. A 2xx code should normally be used for this purpose
	 * so that the AJAX handler will treat the response as a success.
	 * @see redirect
	 */
	public $ajaxRedirectCode = 278;
Qiang Xue committed
98 99 100 101 102
	/**
	 * @var string
	 */
	public $statusText;
	/**
103 104
	 * @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
105
	 */
106
	public $version;
Qiang Xue committed
107 108 109
	/**
	 * @var array list of HTTP status codes and the corresponding texts
	 */
Qiang Xue committed
110
	public static $httpStatuses = array(
Qiang Xue committed
111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 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
		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',
154
		418 => 'I\'m a teapot',
Qiang Xue committed
155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177
		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',
	);

178 179 180
	/**
	 * @var integer the HTTP status code to send with the response.
	 */
Qiang Xue committed
181
	private $_statusCode;
Qiang Xue committed
182 183 184
	/**
	 * @var HeaderCollection
	 */
Qiang Xue committed
185 186
	private $_headers;

Qiang Xue committed
187 188 189
	/**
	 * Initializes this component.
	 */
Qiang Xue committed
190 191
	public function init()
	{
192 193 194 195 196 197
		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
198
		}
199 200 201
		if ($this->charset === null) {
			$this->charset = Yii::$app->charset;
		}
Qiang Xue committed
202 203
	}

204 205 206
	/**
	 * @return integer the HTTP status code to send with the response.
	 */
Qiang Xue committed
207 208 209 210 211
	public function getStatusCode()
	{
		return $this->_statusCode;
	}

Qiang Xue committed
212 213 214 215 216 217 218
	/**
	 * 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
219
	public function setStatusCode($value, $text = null)
Qiang Xue committed
220
	{
Qiang Xue committed
221 222 223 224 225
		if ($value === null) {
			$this->_statusCode = null;
			$this->statusText = null;
			return;
		}
Qiang Xue committed
226
		$this->_statusCode = (int)$value;
227
		if ($this->getIsInvalid()) {
Qiang Xue committed
228 229
			throw new InvalidParamException("The HTTP status code is invalid: $value");
		}
Qiang Xue committed
230
		if ($text === null) {
Qiang Xue committed
231
			$this->statusText = isset(self::$httpStatuses[$this->_statusCode]) ? self::$httpStatuses[$this->_statusCode] : '';
Qiang Xue committed
232 233 234
		} else {
			$this->statusText = $text;
		}
Qiang Xue committed
235 236
	}

Qiang Xue committed
237 238 239 240 241 242 243 244 245 246 247 248 249
	/**
	 * 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
250 251 252 253 254
	/**
	 * Sends the response to the client.
	 */
	public function send()
	{
255 256
		$this->trigger(self::EVENT_BEFORE_SEND, new ResponseEvent($this));
		$this->prepare();
Qiang Xue committed
257
		$this->trigger(self::EVENT_AFTER_PREPARE, new ResponseEvent($this));
Qiang Xue committed
258 259
		$this->sendHeaders();
		$this->sendContent();
260
		$this->trigger(self::EVENT_AFTER_SEND, new ResponseEvent($this));
261
		$this->clear();
Qiang Xue committed
262 263
	}

Qiang Xue committed
264 265 266
	/**
	 * Clears the headers, cookies, content, status code of the response.
	 */
267
	public function clear()
Qiang Xue committed
268 269
	{
		$this->_headers = null;
Qiang Xue committed
270
		$this->_cookies = null;
Qiang Xue committed
271
		$this->_statusCode = null;
272 273
		$this->data = null;
		$this->content = null;
Qiang Xue committed
274 275 276
		$this->statusText = null;
	}

Qiang Xue committed
277 278 279 280 281
	/**
	 * Sends the response headers to the client
	 */
	protected function sendHeaders()
	{
Qiang Xue committed
282 283 284
		if (headers_sent()) {
			return;
		}
Qiang Xue committed
285 286 287 288
		$statusCode = $this->getStatusCode();
		if ($statusCode !== null) {
			header("HTTP/{$this->version} $statusCode {$this->statusText}");
		}
Qiang Xue committed
289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315
		if ($this->_headers) {
			$headers = $this->getHeaders();
			foreach ($headers as $name => $values) {
				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)) {
				$value = SecurityHelper::hashData(serialize($value), $validationKey);
Qiang Xue committed
316
			}
Qiang Xue committed
317
			setcookie($cookie->name, $value, $cookie->expire, $cookie->path, $cookie->domain, $cookie->secure, $cookie->httpOnly);
Qiang Xue committed
318
		}
Qiang Xue committed
319
		$this->getCookies()->removeAll();
Qiang Xue committed
320 321 322 323 324 325 326
	}

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

Qiang Xue committed
330
	/**
331 332 333
	 * 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
334
	 * @param string $mimeType the MIME type of the content. If null, it will be guessed based on `$filePath`
Qiang Xue committed
335
	 */
Qiang Xue committed
336
	public function sendFile($filePath, $attachmentName = null, $mimeType = null)
Qiang Xue committed
337
	{
338
		if ($mimeType === null && ($mimeType = FileHelper::getMimeTypeByExtension($filePath)) === null) {
339
			$mimeType = 'application/octet-stream';
Qiang Xue committed
340
		}
341 342
		if ($attachmentName === null) {
			$attachmentName = basename($filePath);
343
		}
344
		$handle = fopen($filePath, 'rb');
Qiang Xue committed
345
		$this->sendStreamAsFile($handle, $attachmentName, $mimeType);
346
	}
347

348 349 350 351
	/**
	 * 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
352
	 * @param string $mimeType the MIME type of the content.
353
	 * @throws HttpException if the requested range is not satisfiable
354
	 */
355
	public function sendContentAsFile($content, $attachmentName, $mimeType = 'application/octet-stream')
356
	{
357 358 359 360 361 362 363 364
		$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'));
		}

365 366 367 368 369 370 371 372
		$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\"");
373

374 375 376 377
		list($begin, $end) = $range;
		if ($begin !=0 || $end != $contentLength - 1) {
			$this->setStatusCode(206);
			$headers->set('Content-Range', "bytes $begin-$end/$contentLength");
378
			$this->content = StringHelper::substr($content, $begin, $end - $begin + 1);
379 380
		} else {
			$this->setStatusCode(200);
381
			$this->content = $content;
382 383
		}

384
		$this->format = self::FORMAT_RAW;
385
		$this->send();
Qiang Xue committed
386 387
	}

388 389 390 391
	/**
	 * 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
392
	 * @param string $mimeType the MIME type of the stream content.
393 394
	 * @throws HttpException if the requested range cannot be satisfied.
	 */
395
	public function sendStreamAsFile($handle, $attachmentName, $mimeType = 'application/octet-stream')
Qiang Xue committed
396
	{
397
		$headers = $this->getHeaders();
Qiang Xue committed
398 399 400
		fseek($handle, 0, SEEK_END);
		$fileSize = ftell($handle);

401 402 403 404 405
		$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
406

407 408
		list($begin, $end) = $range;
		if ($begin !=0 || $end != $fileSize - 1) {
Qiang Xue committed
409
			$this->setStatusCode(206);
410
			$headers->set('Content-Range', "bytes $begin-$end/$fileSize");
Qiang Xue committed
411 412 413 414
		} else {
			$this->setStatusCode(200);
		}

415
		$length = $end - $begin + 1;
Qiang Xue committed
416

417 418 419 420 421 422 423 424
		$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\"");
425 426
		$this->format = self::FORMAT_RAW;
		$this->data = $this->content = null;
427
		$this->send();
Qiang Xue committed
428

429
		fseek($handle, $begin);
Qiang Xue committed
430 431
		set_time_limit(0); // Reset time limit for big files
		$chunkSize = 8 * 1024 * 1024; // 8MB per chunk
432 433 434
		while (!feof($handle) && ($pos = ftell($handle)) <= $end) {
			if ($pos + $chunkSize > $end) {
				$chunkSize = $end - $pos + 1;
Qiang Xue committed
435 436 437 438 439 440 441
			}
			echo fread($handle, $chunkSize);
			flush(); // Free up memory. Otherwise large files will trigger PHP's memory limit.
		}
		fclose($handle);
	}

442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474
	/**
	 * 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'] === '-') {
			return array(0, $fileSize - 1);
		}
		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 {
			return array($start, $end);
		}
	}

Qiang Xue committed
475 476 477 478 479 480 481 482 483 484 485 486 487 488
	/**
	 * 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
489 490 491 492 493 494 495
	 * 
	 * - 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
496 497 498
	 * 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
499 500 501 502
	 * **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
503
	 *
Qiang Xue committed
504 505
	 * **Side effects**
	 * 
Qiang Xue committed
506 507 508
	 * 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
509 510
	 * **Known issues**
	 * 
Qiang Xue committed
511
	 * 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
512 513 514 515 516 517
	 * 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**
	 * 
	 * ~~~
518 519
	 * Yii::app()->request->xSendFile('/home/user/Pictures/picture1.jpg');
	 * ~~~
Qiang Xue committed
520
	 *
Qiang Xue committed
521
	 * @param string $filePath file name with full path
522 523 524
	 * @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
525
	 */
Qiang Xue committed
526
	public function xSendFile($filePath, $attachmentName = null, $mimeType = null, $xHeader = 'X-Sendfile')
Qiang Xue committed
527
	{
528 529
		if ($mimeType === null && ($mimeType = FileHelper::getMimeTypeByExtension($filePath)) === null) {
			$mimeType = 'application/octet-stream';
Qiang Xue committed
530
		}
531 532
		if ($attachmentName === null) {
			$attachmentName = basename($filePath);
Qiang Xue committed
533
		}
Qiang Xue committed
534

535
		$this->getHeaders()
536 537 538
			->setDefault($xHeader, $filePath)
			->setDefault('Content-Type', $mimeType)
			->setDefault('Content-Disposition', "attachment; filename=\"$attachmentName\"");
Qiang Xue committed
539

Qiang Xue committed
540
		$this->send();
Qiang Xue committed
541
	}
Qiang Xue committed
542 543 544

	/**
	 * Redirects the browser to the specified URL.
Qiang Xue committed
545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562
	 * This method will send out a "Location" header to achieve the redirection.
	 * 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,
	 * this method will use [[ajaxRedirectCode]] as the HTTP status code when performing
	 * redirection in AJAX mode. The following JavaScript code may be used on the client
	 * side to handle the redirection response:
	 *
	 * ~~~
	 * $(document).ajaxSuccess(function(event, xhr, settings) {
	 *     if (xhr.status == 278) {
	 *         window.location = xhr.getResponseHeader('Location');
	 *     }
	 * });
	 * ~~~
	 *
	 * @param array|string $url the URL to be redirected to. [[\yii\helpers\Html::url()]]
	 * will be used to normalize the URL. If the resulting URL is still a relative URL
	 * (one without host info), the current request host info will be used.
563 564
	 * @param integer $statusCode the HTTP status code. If null, it will use 302
	 * for normal requests, and [[ajaxRedirectCode]] for AJAX requests.
Qiang Xue committed
565
	 * See [[http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html]]
566
	 * for details about HTTP status code
567
	 * @return Response the response object itself
Qiang Xue committed
568
	 */
569
	public function redirect($url, $statusCode = null)
Qiang Xue committed
570
	{
Qiang Xue committed
571
		$url = Html::url($url);
Qiang Xue committed
572 573 574
		if (strpos($url, '/') === 0 && strpos($url, '//') !== 0) {
			$url = Yii::$app->getRequest()->getHostInfo() . $url;
		}
575 576
		if ($statusCode === null) {
			$statusCode = Yii::$app->getRequest()->getIsAjax() ? $this->ajaxRedirectCode : 302;
Qiang Xue committed
577
		}
Qiang Xue committed
578 579
		$this->getHeaders()->set('Location', $url);
		$this->setStatusCode($statusCode);
580
		return $this;
Qiang Xue committed
581
	}
582

583 584 585 586 587 588
	/**
	 * 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).
	 * @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.
589
	 * @return Response the response object itself
590
	 */
591
	public function refresh($anchor = '')
592
	{
593
		return $this->redirect(Yii::$app->getRequest()->getUrl() . $anchor);
594 595
	}

Qiang Xue committed
596 597
	private $_cookies;

598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618
	/**
	 * Returns the cookie collection.
	 * Through the returned cookie collection, you add or remove cookies as follows,
	 *
	 * ~~~
	 * // add a cookie
	 * $response->cookies->add(new Cookie(array(
	 *     'name' => $name,
	 *     'value' => $value,
	 * ));
	 *
	 * // remove a cookie
	 * $response->cookies->remove('name');
	 * // alternatively
	 * unset($response->cookies['name']);
	 * ~~~
	 *
	 * @return CookieCollection the cookie collection.
	 */
	public function getCookies()
	{
Qiang Xue committed
619 620 621 622
		if ($this->_cookies === null) {
			$this->_cookies = new CookieCollection;
		}
		return $this->_cookies;
623
	}
Qiang Xue committed
624 625 626 627

	/**
	 * @return boolean whether this response has a valid [[statusCode]].
	 */
628
	public function getIsInvalid()
Qiang Xue committed
629 630 631 632 633 634 635
	{
		return $this->getStatusCode() < 100 || $this->getStatusCode() >= 600;
	}

	/**
	 * @return boolean whether this response is informational
	 */
636
	public function getIsInformational()
Qiang Xue committed
637 638 639 640 641
	{
		return $this->getStatusCode() >= 100 && $this->getStatusCode() < 200;
	}

	/**
642
	 * @return boolean whether this response is successful
Qiang Xue committed
643
	 */
644
	public function getIsSuccessful()
Qiang Xue committed
645 646 647 648 649 650 651
	{
		return $this->getStatusCode() >= 200 && $this->getStatusCode() < 300;
	}

	/**
	 * @return boolean whether this response is a redirection
	 */
652
	public function getIsRedirection()
Qiang Xue committed
653 654 655 656 657 658 659
	{
		return $this->getStatusCode() >= 300 && $this->getStatusCode() < 400;
	}

	/**
	 * @return boolean whether this response indicates a client error
	 */
660
	public function getIsClientError()
Qiang Xue committed
661 662 663 664 665 666 667
	{
		return $this->getStatusCode() >= 400 && $this->getStatusCode() < 500;
	}

	/**
	 * @return boolean whether this response indicates a server error
	 */
668
	public function getIsServerError()
Qiang Xue committed
669 670 671 672 673 674 675
	{
		return $this->getStatusCode() >= 500 && $this->getStatusCode() < 600;
	}

	/**
	 * @return boolean whether this response is OK
	 */
676
	public function getIsOk()
Qiang Xue committed
677
	{
678
		return $this->getStatusCode() == 200;
Qiang Xue committed
679 680 681 682 683
	}

	/**
	 * @return boolean whether this response indicates the current request is forbidden
	 */
684
	public function getIsForbidden()
Qiang Xue committed
685
	{
686
		return $this->getStatusCode() == 403;
Qiang Xue committed
687 688 689 690 691
	}

	/**
	 * @return boolean whether this response indicates the currently requested resource is not found
	 */
692
	public function getIsNotFound()
Qiang Xue committed
693
	{
694
		return $this->getStatusCode() == 404;
Qiang Xue committed
695 696 697 698 699
	}

	/**
	 * @return boolean whether this response is empty
	 */
700
	public function getIsEmpty()
Qiang Xue committed
701 702 703
	{
		return in_array($this->getStatusCode(), array(201, 204, 304));
	}
704

Qiang Xue committed
705
	/**
706 707
	 * Prepares for sending the response.
	 * The default implementation will convert [[data]] into [[content]] and set headers accordingly.
708
	 * @throws InvalidConfigException if the formatter for the specified format is invalid or [[format]] is not supported
Qiang Xue committed
709
	 */
710
	protected function prepare()
711
	{
712 713 714 715 716 717
		if ($this->data === null) {
			return;
		}

		if (isset($this->formatters[$this->format])) {
			$formatter = $this->formatters[$this->format];
Qiang Xue committed
718 719 720 721
			if (!is_object($formatter)) {
				$formatter = Yii::createObject($formatter);
			}
			if ($formatter instanceof ResponseFormatter) {
722
				$formatter->format($this);
Qiang Xue committed
723
			} else {
724
				throw new InvalidConfigException("The '{$this->format}' response formatter is invalid. It must implement the ResponseFormatter interface.");
Qiang Xue committed
725
			}
Qiang Xue committed
726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753
		} 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:
					$this->content = Yii::createObject(XmlResponseFormatter::className())->format($this);
					break;
				default:
					throw new InvalidConfigException("Unsupported response format: {$this->format}");
			}
Qiang Xue committed
754 755
		}

Qiang Xue committed
756 757 758 759
		if (is_array($this->content)) {
			$this->content = 'array()';
		} elseif (is_object($this->content)) {
			$this->content = method_exists($this->content, '__toString') ? (string)$this->content : get_class($this->content);
760 761
		}
	}
Qiang Xue committed
762
}