File.php

Go to the documentation of this file.

<?php

namespace Rsi\Fred\Controller\Widget;

use \Rsi\Qr;

class File extends \Rsi\Fred\Controller\Widget{

  const TYPES = 'types'; //!< Allowed file types (mime or extension; mime can have asterisk wildcards or even be a complete
    // regex; all lower case).
  const FILENAME = 'filename'; //!< Fixed filename for the upload. If everything is OK, file will be overwitten directly, and
    // can also be deleted (if not required).
  const MULTI = 'multi'; //!< Allow multiple files to be uploaded.
  const PREVIEW_SIZE = 'previewSize'; //!< Size (width) of preview image (false = no preview).
  const USER_FILES = 'userFiles'; //!< Show user files.

  const EVENT_UPLOAD = 'controller:widget:file:upload';

  public $types = [];
  public $filename = null;
  public $multi = false;
  public $previewSize = false;

  public $previewMax = 3; //!< Maximum number of preview images.

  public $sideloadControllerName = null; //!< Controller that provides the sideloading.
  public $sideloadPath = null; //!< Path to temporary store sideload files.
  public $sideloadExt = '.side'; //!< Extension for sideload files.
  public $sideloadMode = 0666; //!< File mode for sideload files.
  public $sideloadTokenLength = 16; //!< Length of the sideload token.
  public $sideloadHint = null; //!< Hint to show during sideloading (translated).
  public $sideloadInterval = 5; //!< Poll interval for sideloading check (seconds).
  public $sideloadGarbageChance = 100; //!< Clear sideloading path once every ... times.
  public $sideloadSkip = 5; //!< Stop scanning for new files after this number of misses.

  protected $_raw = null;
  protected $_multiRaw = null;

  public function clientConfig(){
    $config = array_merge(parent::clientConfig(),$this->get([self::TYPES]));
    if(!$this->max) $config[self::MAX] = \Rsi\Number::shorthandBytes(ini_get('post_max_size'));
    if($this->trailer === null) $config[self::TRAILER] = '%n (%s %u)';
    if($this->filename){
      $config[self::FILENAME] = \Rsi\File::basename($this->filename);
      $config['fileExists'] = is_file($this->filename);
      if($this->sideloadControllerName && $this->sideloadPath && !$this->_controller->component('client')->mobile){
        $image = !$this->types;
        foreach($this->types as $type) if($image = preg_match('/^(image|jpe?g)/i',$type)) break;
        if($image) $config['sideloadInterval'] = $this->sideloadInterval;
      }
//TODO: user files werkt nu alleen met een direct lokale filename (dus niet "classic" POST - via een hidden met name ofzo)
      if($this->userFiles && $this->_controller->component('user')->id) $config[self::USER_FILES] = true;
    }
    if($this->multi) $config[self::MULTI] = true;
    return $config;
  }
  /**
   * Purge uploaded filename from possible array construction.
   * If all details are needed you can call fred->request->file(['widget','id']) (where \$id can also be multiple levels
   * deep).
   */
  protected function purgeBase($value){
    if($value && is_array($value)) $value = $this->multi //classic upload
      ? array_column($this->_multiRaw = $value,'tmp_name')
      : \Rsi\Record::get($this->_raw = $value,'tmp_name');
    elseif(!$value && $this->filename && is_file($this->filename)) $value = $this->filename; //earlier async upload
    return parent::purgeBase($value);
  }

  protected function uploadEvent($name){
    return $this->_controller->component('event')->trigger(self::EVENT_UPLOAD,$this,$name);
  }

  protected function checkMin($value,$index = null){
    return parent::checkMin(filesize($value));
  }

  protected function checkMax($value,$index = null){
    return parent::checkMax(filesize($value));
  }

  protected function checkUpload($value,$index = null){
    return !$this->_raw || (is_uploaded_file($value) && !$this->_raw['error']); //http://php.net/manual/en/features.file-upload.errors.php
  }

  protected function checkTypes($value,$index = null){
    if($this->_raw) $value = $this->_raw['name'];
    if(!$this->types || in_array(\Rsi\File::ext($value),$this->types)) return true;
    $mime = \Rsi\File::mime($value);
    foreach($this->types as $type)
      if(preg_match(substr($type,0,1) == '/' ? $type : '/^' . str_replace('*','.*',$type) . '$/',$mime)) return true;
    return false;
  }

  public function check($value,$index = null){
    if(!$this->_multiRaw) $error = parent::check($value,$index);
    else foreach($this->_multiRaw as $this->_raw) if($error = parent::check($this->_raw['tmp_name'],$index)) break;
    if(!$error && $value && !is_array($value) && $this->filename && $this->_raw){
      if(!move_uploaded_file($value,$this->filename))
        throw new \Exception("Can not move uploaded file from '$value' to '{$this->filename}'");
      else $error = $this->uploadEvent($this->_raw['name']);
    }
    return $error;
  }
  /**
   * Generate a preview.
   * @param string $filename  File to generate a preview for (empty = fixed upload filename).
   * @param int $count  Will be set to the number of pages in the file.
   * @param bool $rotate  Will be set to true if the image can be rotated.
   * @return array  Preview PNG images.
   */
  public function preview($filename = null,&$count = null,&$rotate = null){
    if(!$filename) $filename = $this->filename;
    $count = $rotate = false;
    $preview = [];
    if($this->previewSize && $filename && is_file($filename)) try{
      $image = imagecreatefromstring(file_get_contents($filename));
      $factor = min($this->previewSize / ($width = imagesx($image)),$this->previewSize / ($height = imagesy($image)));
      $scaled = imagescale($image,round($factor * $width),round($factor * $height));
      imagedestroy($image);
      ob_start();
      imagepng($scaled);
      $preview[] = ob_get_clean();
      imagedestroy($scaled);
      $rotate = in_array(\Rsi\File::ext($filename),['gif','jpg','jpeg','png']);
    }
    catch(\Exception $e){
      $this->log->info($e);
      $temp = \Rsi\File::tempFile('png');
      if(class_exists('Imagick')) try{
        $image = new \Imagick($filename);
        $count = $image->getNumberImages();
        foreach($image as $index => $page){
          $page->setImageBackgroundColor('white');
          $page->setImageFormat('png');
          $page->thumbnailImage($this->previewSize,0);
          $page->writeImage($temp);
          $preview[] = file_get_contents($temp);
          if(++$index >= $this->previewMax) break;
        }
        $image->destroy();
      }
      catch(\Exception $e){
        $this->log->info($e);
      }
      finally{
        \Rsi\File::unlink($temp);
      }
      else try{
        extract($this->services->preview($filename,$this->previewSize,$this->previewMax));
      }
      catch(\Exception $e){
        $this->log->info($e);
      }
    }
    if(!$count) $count = count($preview);
    return $preview;
  }
  /**
   * Rotate a file.
   * @param int $angle  Rotation angle (positive: degrees clockwise; -1: flip horizontal, -2: flip vertical).
   * @param string $filename  File to rotate (empty = fixed upload filename).
   * @return bool  True if the operation was successful (file will be replaced).
   */
  public function rotate($angle = 90,$filename = null){
    if(!$filename) $filename = $this->filename;
    $result = !$angle;
    if($angle && $filename && is_file($filename)) try{
      $image = null;
      switch($ext = \Rsi\File::ext($filename)){
        case 'gif':
          $image = imagecreatefromgif($filename);
          break;
        case 'jpg':
          $ext = 'jpeg';
        case 'jpeg':
          $image = imagecreatefromjpeg($filename);
          break;
        case 'png':
          $image = imagecreatefrompng($filename);
          break;
      }
      if($image){
        if($angle > 0) $image = imagerotate($image,-$angle,imagecolorallocate($image,255,255,255));
        else switch($angle){
          case -1: imageflip($image,IMG_FLIP_HORIZONTAL); break;
          case -2: imageflip($image,IMG_FLIP_VERTICAL); break;
        }
        $result = call_user_func('image' . $ext,$image,$filename);
        imagedestroy($image);
      }
    }
    catch(\Exception $e){
      $this->log->info($e);
    }
    return $result;
  }
  /**
   * Process upload data.
   * @param mixed $data  Uploaded data (binary string).
   * @param string $name  Original filename.
   */
  protected function processUpload($data,$name){
    try{
      $temp = \Rsi\File::tempFile(\Rsi\File::ext($this->filename),$data);
      if($error = $this->check($temp)) \Rsi\File::unlink($temp);
      elseif(!rename($temp,$this->filename)) throw new \Exception("Could not rename('$temp','{$this->filename}')");
      else $error = $this->uploadEvent($name);
      $preview = [];
      foreach($this->preview(null,$count,$rotate) as $image) $preview[] = base64_encode($image);
      $this->request->result = compact('error','name','preview','count','rotate') + ['size' => strlen($data),'fileExists' => is_file($this->filename)];
    }
    finally{
      \Rsi\File::unlink($temp);
    }
  }
  /**
   * Filename for a sideload file.
   * @param string $token  Sideload token.
   * @param int $index  Upload index.
   * @return string
   */
  protected function sideloadFilename($token,$index = null){
    return $this->sideloadPath . $token . ($index === null ? '' : '-' . $index) . $this->sideloadExt;
  }
  /**
   * Sideload URL.
   * @param string $token  Sideload token.
   * @return string  Full URL.
   */
  protected function sideloadUrl($token){
    return \Rsi\Http::host(true) . $this->_controller->component('router')->reverse($this->sideloadControllerName,null,compact('token'));
  }
  /**
   * Clear old sideload tokens.
   */
  protected function sideloadGarbage(){
    if($this->sideloadPath && !rand(0,$this->sideloadGarbageChance)) try{
      foreach((new \GlobIterator($this->sideloadPath . '*' . $this->sideloadExt)) as $filename => $file)
        if($file->getMTime() < time() - 2 * $this->sideloadInterval) \Rsi\File::unlink($filename);
      $session = $this->_controller->session;
      if($tokens = $session->sideloadTokens){
        foreach($tokens as $token => $time) if(!is_file($this->sideloadFilename($token))) unset($tokens[$token]);
        $session->sideloadTokens = $tokens;
      }
    }
    catch(\Exception $e){
      $this->log->error($e);
    }
  }

  protected function actionRotate(){
    if($this->_display >= self::DISPLAY_WRITEABLE){
      session_write_close();
      $this->rotate((int)$this->request->angle);
      $preview = [];
      foreach($this->preview(null,$count,$rotate) as $image) $preview[] = base64_encode($image);
      clearstatcache(false,$this->filename);
      $this->request->result = compact('preview','count','rotate') + ['size' => filesize($this->filename)];
    }
  }

  protected function actionDownload(){
    if(($this->_display >= self::DISPLAY_READABLE) && $this->filename && is_file($this->filename)){
      \Rsi\Http::downloadHeaders($this->filename,null,filesize($this->filename));
      readfile($this->filename);
      $this->fred->halt();
    }
  }

  protected function actionUpload(){
    if(
      ($this->_display >= self::DISPLAY_WRITEABLE) &&
      $this->filename &&
      ($value = \Rsi\Record::get($this->request->file('data'),'tmp_name'))
    ) $this->processUpload(file_get_contents($value),$this->request->name);
  }

  protected function actionDelete(){
    if(($this->_display >= self::DISPLAY_WRITEABLE) && !$this->required && $this->filename)
      $this->request->result = ['deleted' => \Rsi\File::unlink($this->filename)];
  }

  protected function actionUserFiles(){
    if(($this->_display >= self::DISPLAY_WRITEABLE) && $this->userFiles) $this->request->result = [
      'files' => $this->_controller->component('user')->files->list($this->types),
      'preview' => (bool)$this->previewSize
    ];
  }

  protected function actionUserFilePreview(){
    if($data = $this->_controller->component('user')->files->fetch($this->request->name)){
      session_write_close();
      $temp = \Rsi\File::tempFile('tmp',$data);
      $preview = [];
      foreach($this->preview($temp) as $image) $preview[] = base64_encode($image);
      unlink($temp);
      $this->request->result = $preview;
    }
  }

  protected function actionUserFile(){
    if(($this->_display >= self::DISPLAY_WRITEABLE) && $this->filename && $this->userFiles){
      $data = $this->_controller->component('user')->files->fetch($filename = $this->request->name);
      if(($data !== false) && ($data !== null)) $this->processUpload($data,basename($filename));
    }
  }

  protected function actionSideload(){
    if(($this->_display >= self::DISPLAY_WRITEABLE) && $this->filename && $this->sideloadPath && $this->sideloadControllerName){
      $this->sideloadGarbage();
      while(file_exists($filename = $this->sideloadFilename($token = \Rsi\Str::random($this->sideloadTokenLength))));
      \Rsi\File::serialize(
        $filename,
        [
          'token' => $token,
          'config' => array_merge($this->_config,[self::FILENAME => null]),
          'time' => $time = time()
        ],
        $this->sideloadMode
      );
      $session = $this->_controller->session;
      $tokens = $session->sideloadTokens ?: [];
      $tokens[$token] = $time;
      $session->sideloadTokens = $tokens;
      $url = $this->sideloadUrl($token);
      $this->request->result = [
        'token' => $token,
        'controller' => $this->sideloadControllerName,
        'url' => $url,
        'hint' => $this->trans->str($this->sideloadHint,compact('token','url'))
      ];
    }
  }

  protected function actionSideloadImage(){
    if($token = $this->sideloadToken){
      header('Content-Type: image/png');
      imagepng((new Qr(Qr::ECC_MEDIUM,null,10))->dataImage($this->sideloadUrl($token)));
      $this->fred->halt();
    }
  }

  protected function actionSideloadCheck(){
    if(($token = $this->sideloadToken) && is_file($filename = $this->sideloadFilename($token))){
      touch($filename);
      $index = $skip = 0;
      while($skip++ < $this->sideloadSkip)
        if(($data = \Rsi\File::unserialize($filename = $this->sideloadFilename($token,$index++))) !== false) try{
          \Rsi\File::unlink($filename);
          $this->processUpload($data['data'],$data['name']);
          $skip = 0;
        }
        catch(\Exception $e){
          $this->log->warning('Error while processig sideload file: ' . $e->getMessage(),__FILE__,__LINE__);
          \Rsi\File::unlink($filename);
        }
    }
    if(!$this->request->result) $this->sideloadGarbage();
  }

  protected function getSideloadToken(){
    $session = $this->_controller->session;
    if(
      ($tokens = $session->sideloadTokens) &&
      array_key_exists($token = $this->request->token,$tokens) &&
      ($tokens[$token] > ($time = time()) - 2 * $this->sideloadInterval)
    ){
      $tokens[$token] = $time;
      $session->sideloadTokens = $tokens;
      return $token;
    }
  }

}