if (strpos($this->webroot, ‘/’ . $dir . ‘/’) === false) {
$this->webroot .= $dir . ‘/’;
}
if (strpos($this->webroot, ‘/’ . $webroot . ‘/’) === false) {
$this->webroot .= $webroot . ‘/’;
}
}
return $this->base = $base . $file;
}

/**
* Process $_FILES and move things into the object.
*
* @return void
*/
protected function _processFiles() {
if $_FILES) && is_array($_FILES {
foreach ($_FILES as $name => $data) {
if ($name !== ‘data’) {
$this->params‘form’$name = $data;
}
}
}

if 'data'" class="wiki wikinew text-danger tips isset">$_FILES‘data’ {
foreach ($_FILES‘data’ as $key => $data) {
$this->_processFileData(‘’, $data, $key);
}
}
}

/**
* Recursively walks the FILES array restructuring the data
* into something sane and useable.
*
* @param string $path The dot separated path to insert $data into.
* @param array $data The data to traverse/insert.
* @param string $field The terminal field name, which is the top level key in $_FILES.
* @return void
*/
protected function _processFileData($path, $data, $field) {
foreach ($data as $key => $fields) {
$newPath = $key;
if (strlen($path) > 0) {
$newPath = $path . ‘.’ . $key;
}
if (is_array($fields)) {
$this->_processFileData($newPath, $fields, $field);
} else {
$newPath .= ‘.’ . $field;
$this->data = Hash::insert($this->data, $newPath, $fields);
}
}
}

/**
* Get the content type used in this request.
*
* @return string
*/
public function contentType() {
$type = env(‘CONTENT_TYPE’);
if ($type) {
return $type;
}
return env(‘HTTP_CONTENT_TYPE’);
}

/**
* Get the IP the client is using, or says they are using.
*
* @param bool $safe Use safe = false when you think the user might manipulate their HTTP_CLIENT_IP
* header. Setting $safe = false will also look at HTTP_X_FORWARDED_FOR
* @return string The client IP.
*/
public function clientIp($safe = true) {
if (!$safe && env(‘HTTP_X_FORWARDED_FOR’)) {
$ipaddr = preg_replace(‘/(?:,.*)/’, ‘’, env(‘HTTP_X_FORWARDED_FOR’));
} elseif (!$safe && env(‘HTTP_CLIENT_IP’)) {
$ipaddr = env(‘HTTP_CLIENT_IP’);
} else {
$ipaddr = env(‘REMOTE_ADDR’);
}
return trim($ipaddr);
}

/**
* Returns the referer that referred this request.
*
* @param bool $local Attempt to return a local address. Local addresses do not contain hostnames.
* @return string The referring address for this request.
*/
public function referer($local = false) {
$ref = env(‘HTTP_REFERER’);

$base = Configure::read(‘App.fullBaseUrl’) . $this->webroot;
if (!empty($ref) && !empty($base)) {
if ($local && strpos($ref, $base) === 0) {
$ref = substr($ref, strlen($base));
if $ref {
$ref = ‘/’;
}
if ($ref0 !== ‘/’) {
$ref = ‘/’ . $ref;
}
return $ref;
} elseif (!$local) {
return $ref;
}
}
return ‘/’;
}

/**
* Missing method handler, handles wrapping older style isAjax() type methods
*
* @param string $name The method called
* @param array $params Array of parameters for the method call
* @return mixed
* @throws CakeException when an invalid method is called.
*/
public function __call($name, $params) {
if (strpos($name, ‘is’) === 0) {
$type = strtolower$name, 2;
return $this->is($type);
}
throw new CakeException(__d(‘cake_dev’, ‘Method %s does not exist’, $name));
}

/**
* Magic get method allows access to parsed routing parameters directly on the object.
*
* Allows access to `$this->params‘controller’` via `$this->controller`
*
* @param string $name The property being accessed.
* @return mixed Either the value of the parameter or null.
*/
public function __get($name) {
if $name" class="wiki wikinew text-danger tips isset">$this->params$name {
return $this->params$name;
}
return null;
}

/**
* Magic isset method allows isset/empty checks
* on routing parameters.
*
* @param string $name The property being accessed.
* @return bool Existence
*/
public function __isset($name) {
return isset($this->params$name);
}

/**
* Check whether or not a Request is a certain type.
*
* Uses the built in detection rules as well as additional rules
* defined with CakeRequest::addDetector(). Any detector can be called
* as `is($type)` or `is$Type()`.
*
* @param string|array $type The type of request you want to check. If an array
* this method will return true if the request matches any type.
* @return bool Whether or not the request is the type you are checking.
*/
public function is($type) {
if (is_array($type)) {
$result = array_map(array($this, ‘is’), $type);
return count(array_filter($result)) > 0;
}
$type = strtolower($type);
if (!isset($this->_detectors$type)) {
return false;
}
$detect = $this->_detectors$type;
if 'env') && $this->_environmentDetector($detect" class="wiki wikinew text-danger tips isset">$detect‘env’) && $this->_environmentDetector($detect {
return true;
}
if 'header') && $this->_headerDetector($detect" class="wiki wikinew text-danger tips isset">$detect‘header’) && $this->_headerDetector($detect {
return true;
}
if 'accept') && $this->_acceptHeaderDetector($detect" class="wiki wikinew text-danger tips isset">$detect‘accept’) && $this->_acceptHeaderDetector($detect {
return true;
}
if 'param') && $this->_paramDetector($detect" class="wiki wikinew text-danger tips isset">$detect‘param’) && $this->_paramDetector($detect {
return true;
}
if 'callback') && is_callable($detect'callback'" class="wiki wikinew text-danger tips isset">$detect‘callback’) && is_callable($detect‘callback’ {
return call_user_func($detect‘callback’, $this);
}
return false;
}

/**
* Detects if a URL extension is present.
*
* @param array $detect Detector options array.
* @return bool Whether or not the request is the type you are checking.
*/
protected function _extensionDetector($detect) {
if (is_string($detect‘extension’)) {
$detect‘extension’ = array($detect‘extension’);
}
if (in_array($this->params‘ext’, $detect‘extension’)) {
return true;
}
return false;
}

/**
* Detects if a specific accept header is present.
*
* @param array $detect Detector options array.
* @return bool Whether or not the request is the type you are checking.
*/
protected function _acceptHeaderDetector($detect) {
$acceptHeaders = explode(‘,’, (string)env(‘HTTP_ACCEPT’));
foreach ($detect‘accept’ as $header) {
if (in_array($header, $acceptHeaders)) {
return true;
}
}
return false;
}

/**
* Detects if a specific header is present.
*
* @param array $detect Detector options array.
* @return bool Whether or not the request is the type you are checking.
*/
protected function _headerDetector($detect) {
foreach ($detect‘header’ as $header => $value) {
$header = env(‘HTTP_’ . strtoupper($header));
if (!is_null($header)) {
if (!is_string($value) && !is_bool($value) && is_callable($value)) {
return call_user_func($value, $header);
}
return ($header === $value);
}
}
return false;
}

/**
* Detects if a specific request parameter is present.
*
* @param array $detect Detector options array.
* @return bool Whether or not the request is the type you are checking.
*/
protected function _paramDetector($detect) {
$key = $detect‘param’;
if 'value'" class="wiki wikinew text-danger tips isset">$detect‘value’ {
$value = $detect‘value’;
return isset($this->params$key) ? $this->params$key == $value : false;
}
if 'options'" class="wiki wikinew text-danger tips isset">$detect‘options’ {
return isset($this->params$key) ? in_array($this->params$key, $detect‘options’) : false;
}
return false;
}

/**
* Detects if a specific environment variable is present.
*
* @param array $detect Detector options array.
* @return bool Whether or not the request is the type you are checking.
*/
protected function _environmentDetector($detect) {
if 'env'" class="wiki wikinew text-danger tips isset">$detect‘env’ {
if 'value'" class="wiki wikinew text-danger tips isset">$detect‘value’ {
return env($detect‘env’) == $detect‘value’;
}
if 'pattern'" class="wiki wikinew text-danger tips isset">$detect‘pattern’ {
return (bool)preg_match($detect‘pattern’, env($detect‘env’));
}
if 'options'" class="wiki wikinew text-danger tips isset">$detect‘options’ {
$pattern = ‘/’ . implode(‘|’, $detect‘options’) . ‘/i’;
return (bool)preg_match($pattern, env($detect‘env’));
}
}
return false;
}

/**
* Check that a request matches all the given types.
*
* Allows you to test multiple types and union the results.
* See CakeRequest::is() for how to add additional types and the
* built-in types.
*
* @param array $types The types to check.
* @return bool Success.
* @see CakeRequest::is()
*/
public function isAll(array $types) {
$result = array_filter(array_map$this, ‘is’), $types;
return count($result) === count($types);
}

/**
* Add a new detector to the list of detectors that a request can use.
* There are several different formats and types of detectors that can be set.
*
* ### Environment value comparison
*
* An environment value comparison, compares a value fetched from `env()` to a known value
* the environment value is equality checked against the provided value.
*
* e.g `addDetector(‘post’, array(‘env’ => ‘REQUEST_METHOD’, ‘value’ => ‘POST’))`
*
* ### Pattern value comparison
*
* Pattern value comparison allows you to compare a value fetched from `env()` to a regular expression.
*
* e.g `addDetector(‘iphone’, array(‘env’ => ‘HTTP_USER_AGENT’, ‘pattern’ => ‘/iPhone/i’));`
*
* ### Option based comparison
*
* Option based comparisons use a list of options to create a regular expression. Subsequent calls
* to add an already defined options detector will merge the options.
*
* e.g `addDetector(‘mobile’, array(‘env’ => ‘HTTP_USER_AGENT’, ‘options’ => array(‘Fennec’)));`
*
* ### Callback detectors
*
* Callback detectors allow you to provide a ‘callback’ type to handle the check. The callback will
* receive the request object as its only parameter.
*
* e.g `addDetector(‘custom’, array(‘callback’ => array(‘SomeClass’, ‘somemethod’)));`
*
* ### Request parameter detectors
*
* Allows for custom detectors on the request parameters.
*
* e.g `addDetector(‘requested’, array(‘param’ => ‘requested’, ‘value’ => 1)`
*
* You can also make parameter detectors that accept multiple values
* using the `options` key. This is useful when you want to check
* if a request parameter is in a list of options.
*
* `addDetector(‘extension’, array(‘param’ => ‘ext’, ‘options’ => array(‘pdf’, ‘csv’))`
*
* @param string $name The name of the detector.
* @param array $options The options for the detector definition. See above.
* @return void
*/
public function addDetector($name, $options) {
$name = strtolower($name);
if $name) && isset($options'options'" class="wiki wikinew text-danger tips isset">$this->_detectors$name) && isset($options‘options’ {
$options = Hash::merge($this->_detectors$name, $options);
}
$this->_detectors$name = $options;
}

/**
* Add parameters to the request’s parsed parameter set. This will overwrite any existing parameters.
* This modifies the parameters available through `$request->params`.
*
* @param array $params Array of parameters to merge in
* @return self
*/
public function addParams($params) {
$this->params = array_merge($this->params, (array)$params);
return $this;
}

/**
* Add paths to the requests’ paths vars. This will overwrite any existing paths.
* Provides an easy way to modify, here, webroot and base.
*
* @param array $paths Array of paths to merge in
* @return self
*/
public function addPaths($paths) {
foreach (array(‘webroot’, ‘here’, ‘base’) as $element) {
if $element" class="wiki wikinew text-danger tips isset">$paths$element {
$this->{$element} = $paths$element;
}
}
return $this;
}

/**
* Get the value of the current requests URL. Will include named parameters and querystring arguments.
*
* @param bool $base Include the base path, set to false to trim the base path off.
* @return string the current request URL including query string args.
*/
public function here($base = true) {
$url = $this->here;
if (!empty($this->query)) {
$url .= ‘?’ . http_build_query($this->query, null, ‘&’);
}
if (!$base) {