Request.php

Go to the documentation of this file.

<?php
 
namespace Rsi\Fred;
 
/**
 *  Component comprising all information regarding an HTTP-request (to transport these along all stepts executed during a
 *  request).
 */
class Request extends Component{
 
  public $encoding = 'UTF-8'; //!< Check encoding.
  public $errors = []; //!< Errors detected during the processing of the request (key = item ID, value = error code).
  public $data = []; //!< Data to be presented by the view (key-value pairs).
  public $result = null; //!< Result fo the request (mixed).
  public $redir = null; //!< URL for redirection (empty = no redirection).
  public $viewControllerName = null; //!< Name of the view controller (same as the request handler when empty).
 
  public $cookieOptions = []; //!< Default cookie options.
  public $jsonDecodingError = 'JSON decoding error: [error]';
  public $postExceededError = 'POST exceeded ([size] / [max])';
 
  protected $_files = null;
  protected $_server = null;
 
  protected function init(){
    parent::init();
    if(\Rsi\Http::method() == \Rsi\Http::METHOD_POST) $this->checkPost();
  }
  /**
   * Checks the post (by content type).
   */
  protected function checkPost(){
    try{
      switch(($type = $_SERVER['CONTENT_TYPE'] ?? null) ? strtolower(trim(explode(';',$type)[0] ?? null)) : null){
        case 'application/json':
          if(is_array($data = json_decode(file_get_contents('php://input'),true))) $_POST = $data;
          if(json_last_error()) $this->errors['post'] = $this->component('trans')->str($this->jsonDecodingError,['error' => json_last_error_msg()]);
          break;
        case 'application/xml':
          if(is_array($data = json_decode(json_encode(simplexml_load_file('php://input',null,LIBXML_NOCDATA)),true))) $_POST = $data;
          break;
        default:
          if(\Rsi\Http::postExceeded($size,$max)){
            $local = $this->component('local');
            $this->errors['post'] = $this->component('trans')->str($this->postExceededError,['size' => $local->formatBytes($size),'max' => $local->formatBytes($max)]);
          }
      }
    }
    catch(\Exception $e){
      $this->_fred->externalError($e->getMessage());
    }
  }
  /**
   * Transform an array of uploaded files to a 'normal' structure.
   * Single file uploads have an entry in the $_FILES array with properties 'tmp_name', 'size', and so on. With an array of
   * files this is also the case, and each of these properties has a multi dimensional array of values. For the processing of
   * single files though it is more convinient if all files have the same single dimension array structure as the single file
   * upload at the deepest level. Therefore the property names must move to the end of the structure.
   * @param array $values  Array with properties (single or multi dimensional).
   * @param array $prefix  Array to prefix before the keys.
   * @param array $files  Already determined, correct structure.
   * @return array  Complemented, correct structure.
   */
  protected function fixFileKey($values,$prefix = null,$files = null){
    if(!$prefix) $prefix = $files = [];
    foreach($values as $key => $value){
      $key = array_merge($prefix,[$key]);
      if(is_array($value)) $files = $this->fixFileKey($value,$key,$files);
      else{
        $item = array_shift($key);
        \Rsi\Record::set($files,array_merge($key,[$item]),$value);
      }
    }
    return $files;
  }
  /**
   * Map command line arguments to the $_GET.
   * @param array $keys  Array with key for every consecutive argument. If empty, the argument itself is parsed for keys
   *   ("key=value foo=bar" format).
   */
  public function mapArgs($keys = null){
    global $argv;
 
    if($keys) foreach(array_values($keys) as $index => $key) $_GET[$key] = $argv[$index + 1] ?? null;
    else parse_str(implode('&',array_slice($argv,1)),$_GET);
  }
  /**
   * Retrieve a file upload from the request.
   * @param string $key  Name of the sought file.
   * @return mixed  Found value (might be empty or have errors).
   */
  public function file($key){
    return \Rsi\Record::get($this->files,$key);
  }
  /**
   * Retrieve a complex parameter (simple type or array) from the request.
   * Parameters are first sought-after in the $_POST, then in the $_FILES, and last in the $_GET. Only the latter will be done
   * case insensitive.
   * @param string $key  Name of the sought parameter.
   * @param mixed $default  Default value if the key does not exist.
   * @return mixed  Found value, or default value if the key does not exist.
   */
  public function complex($key,$default = null){
    if(($value = \Rsi\Record::get($_POST,$key,false)) !== false) return $value;
    if(($value = $this->file($key)) !== null) return $value;
    return \Rsi\Record::iget($_GET,$key,$default);
  }
  /**
   * Retrieve a record like parameter (single layer array) from the request.
   * @see complex()
   * @param string $key  Name of the sought parameter.
   * @param mixed $default  Default value if the key does not exist.
   * @return mixed  Found value, or default value if the key does not exist or the value is not valid.
   */
  public function record($key,$default = null){
    if(!is_array($value = $this->complex($key,$default))) return $default;
    foreach($value as $sub) if(is_array($sub) || ($this->encoding && !mb_check_encoding($sub,$this->encoding))) return $default;
    return $value;
  }
  /**
   * Retrieve a simple parameter (not an array) from the request.
   * @see complex()
   * @param string $key  Name of the sought parameter.
   * @param mixed $default  Default value if the key does not exist.
   * @param string $mask  Regex to check the value with (true = word chars only).
   * @return mixed  Found value, or default value if the key does not exist or the value is not valid.
   */
  public function simple($key,$default = null,$mask = null){
    return (is_array($value = $this->complex($key,$default)) || ($value && (
      ($this->encoding && !mb_check_encoding($value,$this->encoding)) ||
      ($mask && !preg_match($mask === true ? '/^\\w+$/' : $mask,$value))
    ))) ? $default : $value;
  }
 
  public function data($key,$default = null){
    return \Rsi\Record::get($this->data,$key,$default);
  }
  /**
   * Set and/or get a cookie.
   * @param string $key  Cookie key.
   * @param mixed $value  Cookie value.
   * @param int $days  Cookie lifetime (in days).
   * @param array $options  Cookie options (see https://www.php.net/setcookie; when 'secure' is undefined, the value is
   *   automatically set to true when the request was made using a secure connection).
   * @return mixed  Cookie value (false when unknown).
   */
  public function cookie($key,$value = null,$days = 365,$options = null){
    if(func_num_args() > 1) \Rsi\Http::setCookie($key,$value,$days,($options ?: []) + $this->cookieOptions);
    return $_COOKIE[$key] ?? false;
  }
 
  protected function getFiles(){
    if($this->_files === null){
      $this->_files = [];
      foreach($_FILES as $key => $value) $this->_files[$key] = $this->fixFileKey($value);
    }
    return $this->_files;
  }
 
  protected function getServer(){
    if($this->_server === null){
      $server = ['http' => []];
      foreach($_SERVER as $key => $value)
        if(substr($key = strtolower($key),0,5) == 'http_') $server['http'][lcfirst(\Rsi\Str::camel(substr($key,5)))] = $value;
        else $server[lcfirst(\Rsi\Str::camel($key))] = $value;
      $this->_server = new \Rsi\Wrapper\Record($server);
    }
    return $this->_server;
  }
 
  protected function _get($key){
    return array_key_exists($key,$this->data) ? $this->data[$key] : $this->simple($key);
  }
 
  protected function _set($key,$value){
    $this->data[$key] = $value;
  }
 
  public function __invoke($key,$default = null){
    return $this->data($key,$default);
  }
 
}