class elFinderVolumeDrupal in elFinder file manager 7.2

@file

elFinder driver for Drupal filesystem.

@author Alexey Sukhotin

Hierarchy

• class \elFinderVolumeDrupal extends \elFinderVolumeLocalFileSystem

File

inc/elfinder.drupalfs.driver.inc, line 15

elFinder driver for Drupal filesystem.

class elFinderVolumeDrupal extends elFinderVolumeLocalFileSystem {
  protected $DrupalFilesACL = NULL;

  /**
   * Create Drupal file object
   *
   * @param  string $path file path
   * @return object
   * @author Alexey Sukhotin
   * */
  protected function _drupalfileobject($path) {
    $uri = $this
      ->drupalpathtouri($path);
    return elfinder_get_drupal_file_obj($uri);
  }

  /**
   * Convert path to Drupal file URI
   *
   * @param  string $path file path
   * @return string
   * @author Alexey Sukhotin
   * */
  public function drupalpathtouri($path) {
    $pvtpath = drupal_realpath('private://');
    $pubpath = drupal_realpath('public://');
    $tmppath = drupal_realpath('temporary://');
    $uri = '';
    if (strpos($path, $pvtpath) === 0) {
      $uri = 'private://' . substr($path, strlen($pvtpath) + 1);
    }
    elseif (strpos($path, $tmppath) === 0) {
      $uri = 'temporary://' . substr($path, strlen($tmppath) + 1);
    }
    else {
      $uri = 'public://' . substr($path, strlen($pubpath) + 1);
    }
    return @file_stream_wrapper_uri_normalize($uri);
  }

  /**
   * Check if file extension is allowed
   *
   * @param stdClass $file file object
   * @return array
   * @author Alexey Sukhotin
   **/
  protected function CheckExtension(stdClass $file) {
    $allowed_extensions = variable_get('elfinder_settings_filesystem_allowed_extensions', '');
    if (!empty($allowed_extensions)) {
      $errors = file_validate_extensions($file, $allowed_extensions);
      if (!empty($errors)) {
        $this
          ->setError(strip_tags(implode(' ', $errors)));
        return FALSE;
      }
    }
    return TRUE;
  }

  /**
   * Create dir
   *
   * @param  string $path parent dir path
   * @param string $name new directory name
   * @return bool
   * @author Alexey Sukhotin
   * */
  protected function _mkdir($path, $name) {
    $path = $path . DIRECTORY_SEPARATOR . $name;
    if (@drupal_mkdir($path)) {
      return $path;
    }
    return FALSE;
  }

  /**
   * Create file
   *
   * @param  string $path parent dir path
   * @param string $name new file name
   * @return bool
   * @author Alexey Sukhotin
   * */
  protected function _mkfile($path, $name) {
    $path = $path . DIRECTORY_SEPARATOR . $name;
    $uri = $this
      ->drupalpathtouri($path);
    if (!$this
      ->CheckExtension($this
      ->_drupalfileobject($path))) {
      return FALSE;
    }
    $file = file_save_data("", $uri);
    $this
      ->FileUsageAdd($file);
    if (isset($file->fid)) {
      return $path;
    }
    return FALSE;
  }

  /**
   * Copy file into another file
   *
   * @param  string $source source file path
   * @param  string $targetDir target directory path
   * @param  string $name new file name
   * @return bool
   * @author Alexey Sukhotin
   * */
  protected function _copy($source, $targetDir, $name) {
    $target = $targetDir . DIRECTORY_SEPARATOR . (!empty($name) ? $name : basename($source));
    if (!is_dir($target) && !$this
      ->CheckExtension($this
      ->_drupalfileobject($target))) {
      return FALSE;
    }
    if (!$this
      ->CheckUserQuota()) {
      return FALSE;
    }
    if (file_copy($this
      ->_drupalfileobject($source), $this
      ->drupalpathtouri($target))) {
      $this
        ->FileUsageAdd($this
        ->_drupalfileobject($target));
      return TRUE;
    }
    return FALSE;
  }

  /**
   * Move file into another parent dir
   * Return new file path or false
   *
   * @param  string $source source file path
   * @param  string $target target dir path
   * @param  string $name new name
   * @return bool|string
   * @author Alexey Sukhotin
   * */
  protected function _move($source, $targetDir, $name) {
    $target = $targetDir . DIRECTORY_SEPARATOR . (!empty($name) ? $name : basename($source));
    if (!is_dir($target) && !$this
      ->CheckExtension($this
      ->_drupalfileobject($target))) {
      return FALSE;
    }
    if (is_dir($source)) {
      $srcuri = $this
        ->drupalpathtouri($source);
      $dsturi = $this
        ->drupalpathtouri($target);
      $children = db_select('file_managed', 'f')
        ->condition('uri', $srcuri . '/%', 'LIKE')
        ->fields('f', array(
        'fid',
        'uri',
      ))
        ->execute()
        ->fetchAll();
      foreach ($children as $child) {
        $newuri = str_replace("{$srcuri}/", "{$dsturi}/", $child->uri);
        db_update('file_managed')
          ->fields(array(
          'uri' => $newuri,
        ))
          ->condition('fid', $child->fid)
          ->execute();
      }
      return @rename($source, $target);
    }
    elseif (@file_move($this
      ->_drupalfileobject($source), $this
      ->drupalpathtouri($target))) {
      return TRUE;
    }
    return FALSE;
  }

  /**
   * Remove file
   *
   * @param  string $path file path
   * @return bool
   * @author Alexey Sukhotin
   * */
  protected function _unlink($path) {
    $file = $this
      ->_drupalfileobject($path);
    $this
      ->FileUsageDelete($file);
    $result = @file_delete($file);
    if ($result === TRUE) {
      return TRUE;
    }
    if (is_array($result)) {
      return $result['file'];
    }
    else {
      return FALSE;
    }
  }

  /**
   * Remove dir
   *
   * @param  string $path dir path
   * @return bool
   * @author Alexey Sukhotin
   * */
  protected function _rmdir($path) {
    return @drupal_rmdir($path);
  }

  /**
   * Delete dirctory trees and included files.
   *
   * Clone of elfinderVolumeDriver::delTree().
   *
   * Using elFinderVolumeLocalFileSystem::delTree to delete a folder with files
   * in it would not update file_usage and file_managed tables. Using
   * elfinderVolumeDriver::delTree makes it work better.
   */
  protected function delTree($localpath) {
    foreach ($this
      ->_scandir($localpath) as $p) {
      elFinder::extendTimeLimit();
      $stat = $this
        ->stat($this
        ->convEncOut($p));
      $this
        ->convEncIn();
      $stat['mime'] === 'directory' ? $this
        ->delTree($p) : $this
        ->_unlink($p);
    }
    $res = $this
      ->_rmdir($localpath);
    $res && $this
      ->clearstatcache();
    return $res;
  }

  /**
   * Create new file and write into it from file pointer.
   * Return new file path or false on error.
   *
   * @param  resource $fp file pointer
   * @param  string $dir target dir path
   * @param  string $name file name
   * @return bool|string
   * @author Dmitry (dio) Levashov, Alexey Sukhotin
   * */
  protected function _save($fp, $dir, $name, $stat) {
    $tmpname = $name;
    $bu_ret = module_invoke_all('elfinder_beforeupload', array(
      'name' => $name,
      'dir' => $dir,
      'stat' => $stat,
    ));
    if (isset($bu_ret)) {
      if (!is_array($bu_ret)) {
        $bu_ret = array(
          $bu_ret,
        );
      }
      $tmpname = end($bu_ret);
    }
    $path = $dir . DIRECTORY_SEPARATOR . (!empty($tmpname) ? $tmpname : $name);
    if (!$this
      ->CheckUserQuota()) {
      return FALSE;
    }
    if (!$this
      ->CheckFolderCount($dir)) {
      return FALSE;
    }
    if (!$this
      ->CheckExtension($this
      ->_drupalfileobject($path))) {
      return FALSE;
    }
    if (!$this
      ->FileValidate($name)) {
      return FALSE;
    }
    if (!($target = @fopen($path, 'wb'))) {
      return FALSE;
    }
    while (!feof($fp)) {
      fwrite($target, fread($fp, 8192));
    }
    fclose($target);
    @chmod($path, $this->options['fileMode']);
    $file = $this
      ->_drupalfileobject($path);
    @file_save($file);
    $this
      ->FileUsageAdd($file);
    return $path;
  }
  protected function CheckUserQuota() {
    $space = $this
      ->CalculateUserAllowedSpace();
    if ($space == 0) {
      $this
        ->setError(t('Quota exceeded'));
      return FALSE;
    }
    return TRUE;
  }
  protected function CheckFolderCount($dir) {
    $max_allowed = variable_get('elfinder_settings_filesystem_maxfilecount', 0);
    if ($max_allowed > 0) {
      $options = array(
        'recurse' => FALSE,
      );

      // Match name.extension. This won't count files with no extension.
      $files = file_scan_directory($dir, '/.*\\..*/', $options);
      if (count($files) >= $max_allowed) {
        $this
          ->setError(t('Max directory file count of %count reached', array(
          '%count' => $max_allowed,
        )));
        return FALSE;
      }
    }
    return TRUE;
  }

  /**
   * Let other Drupal modules perform validation on the uploaded file.
   * See hook_file_validate().
   *
   * @param  string    $name file name
   * @return bool
   */
  protected function FileValidate($name) {

    // The uploaded file is still in temp. Fetch it's name & path from $_FILES.
    $index = array_search($name, $_FILES['upload']['name']);
    if ($index !== FALSE) {
      $file = $this
        ->_drupalfileobject($_FILES['upload']['tmp_name'][$index]);
      $validation_errors = module_invoke_all('file_validate', $file);
      if (!empty($validation_errors)) {
        $this
          ->setError(strip_tags(implode(' ', $validation_errors)));
        return FALSE;
      }
    }
    else {
      watchdog('elfinder', 'File upload "' . $name . '" not found in $_FILES');
    }
    return TRUE;
  }

  /**
   * Return files list in directory.
   *
   * @param  string $path dir path
   * @return array
   * @author Dmitry (dio) Levashov
   * */
  protected function _scandir($path) {
    $files = array();
    foreach (scandir($path) as $name) {
      if ($name != '.' && $name != '..') {
        $files[] = $path . DIRECTORY_SEPARATOR . $name;
      }
    }
    return $files;
  }
  public function owner($target) {
    $path = $this
      ->decode($target);
    $file = $this
      ->_drupalfileobject($path);
    if ($file->fid) {
      $owneraccount = user_load($file->uid);

      /* AS */
      $owner = $owneraccount->name;
      $ownerformat = variable_get('elfinder_settings_filesystem_owner_format', '');
      if ($ownerformat != '') {
        $owner = token_replace($ownerformat, array(
          'user' => $owneraccount,
        ));
      }
      return $owner;
    }
    return FALSE;
  }
  public function desc($target, $newdesc = NULL) {
    $path = $this
      ->decode($target);
    $file = $this
      ->_drupalfileobject($path);
    if ($file->fid) {
      $finfo = db_select('elfinder_file_extinfo', 'f')
        ->condition('fid', $file->fid)
        ->fields('f', array(
        'fid',
        'description',
      ))
        ->execute()
        ->fetchObject();
      $descobj = new StdClass();
      $descobj->fid = $file->fid;
      $descobj->description = $newdesc;
      if ($newdesc != NULL && user_access('edit file description')) {
        if (($rc = drupal_write_record('elfinder_file_extinfo', $descobj, isset($finfo->fid) ? array(
          'fid',
        ) : array())) == 0) {
          return -1;
        }
      }
      else {
        return $finfo->description;
      }
    }
    return $newdesc;
  }
  public function downloadcount($target) {
    $path = $this
      ->decode($target);
    $file = $this
      ->_drupalfileobject($path);
    if ($file->fid && module_exists('elfinder_stats')) {
      $downloads = db_select('elfinder_stats', 's')
        ->fields('s', array(
        'fid',
      ))
        ->condition('s.fid', $file->fid)
        ->condition('s.type', 'download')
        ->countQuery()
        ->execute()
        ->fetchField();
      return $downloads ? $downloads : 0;
    }
    return 0;
  }
  protected function _archive($dir, $files, $name, $arc) {
    if (!$this
      ->CheckUserQuota()) {
      return FALSE;
    }
    $ret = parent::_archive($dir, $files, $name, $arc);
    if ($ret != FALSE) {
      $file = $this
        ->_drupalfileobject($ret);
      @file_save($file);
      $this
        ->FileUsageAdd($file);
    }
    return $ret;
  }

  /**
   * Extract files from archive.
   *
   * Run the parent extract() then add the files to the Drupal db.
   *
   * @param string $hash
   *    Archive filename hash.
   * @param bool $makedir
   *    Extract the files into a new folder.
   * @return array|bool
   */
  public function extract($hash, $makedir = NULL) {
    if (!$this
      ->CheckUserQuota()) {
      return FALSE;
    }
    $fstat = array();
    if ($makedir == NULL) {
      $fstat = parent::extract($hash);
    }
    else {
      $fstat = parent::extract($hash, $makedir);
    }
    if ($fstat != FALSE) {
      $path = $this
        ->decode($fstat['hash']);
      $this
        ->AddToDrupalDB($path);
      $file = $this
        ->_drupalfileobject($path);
      if ($fstat['mime'] !== 'directory') {
        $this
          ->FileUsageAdd($file);
      }
    }
    return $fstat;
  }

  /**
   * Recursive function to add new files to Drupal's db.
   *
   * TODO: If a file with the same name already exists anywhere else, this will
   * not create a new entry.
   */
  protected function AddToDrupalDB($files) {
    foreach ($files as $file) {
      if ($file['mime'] == 'directory') {
        $newfiles = $this
          ->scandir($file['hash']);
        $this
          ->AddToDrupalDB($newfiles);
      }
      else {
        $filepath = $this
          ->decode($file['hash']);
        $file_object = $this
          ->_drupalfileobject($filepath);
        @file_save($file_object);
        $this
          ->FileUsageAdd($file_object);
      }
    }
    return TRUE;
  }
  protected function CalculateUserAllowedSpace($checkuser = NULL) {
    global $user;
    $realUser = isset($checkuser) ? $checkuser : $user;
    $currentSpace = $this
      ->CalculateUserUsedSpace($realUser);
    $maxSpace = isset($this->options['userProfile']->settings['user_quota']) ? parse_size($this->options['userProfile']->settings['user_quota']) : NULL;
    $diff = $maxSpace - $currentSpace;
    if (isset($maxSpace) && $maxSpace > 0) {
      if ($diff > 0) {
        return $diff;
      }
      else {
        return 0;
      }
    }
    return -1;
  }
  protected function CalculateUserUsedSpace($checkuser = NULL) {
    global $user;
    $realUser = isset($checkuser) ? $checkuser : $user;
    $q = db_query("SELECT sum(filesize) FROM {file_managed} WHERE uid = :uid", array(
      ':uid' => $realUser->uid,
    ));
    $result = $q
      ->fetchField();
    return $result;
  }
  protected function FileUsageAdd($file) {

    // Record that the module elfinder is using the file.
    @file_usage_add($file, 'elfinder', 'elfinderFileFetcher', 0);

    // 0 : means that there is no reference at the moment.
  }
  protected function FileUsageDelete($file) {

    // Delete record that the module elfinder is using the file.
    @file_usage_delete($file, 'elfinder', 'elfinderFileFetcher', 0);

    // 0 : means that there is no reference at the moment.
  }
  protected function _checkArchivers() {
    $this->archivers = variable_get('elfinder_settings_misc_archivers', array());
    if (count($this->archivers) == 0) {
      parent::_checkArchivers();
      variable_set('elfinder_settings_misc_archivers', $this->archivers);
    }
  }

  /**
   * Rename file and return file info
   *
   * @param  string  $hash  file hash
   * @param  string  $name  new file name
   * @return array|false
   **/
  public function rename($hash, $name) {
    $results = parent::rename($hash, $name);

    // Update any fields that point to this file.
    field_cache_clear();
    return $results;
  }

  /**
   * Taken from elFinderVolumeDriver::remove().
   *
   * Adds a message if the file is in use.
   */
  protected function remove($path, $force = false) {
    $stat = $this
      ->stat($path);
    if (empty($stat)) {
      return $this
        ->setError(elFinder::ERROR_RM, $path, elFinder::ERROR_FILE_NOT_FOUND);
    }
    $stat['realpath'] = $path;
    $this
      ->rmTmb($stat);
    $this
      ->clearcache();
    if (!$force && !empty($stat['locked'])) {
      return $this
        ->setError(elFinder::ERROR_LOCKED, $this
        ->path($stat['hash']));
    }
    if ($stat['mime'] == 'directory' && empty($stat['thash'])) {
      $ret = $this
        ->delTree($this
        ->convEncIn($path));
      $this
        ->convEncOut();
      if (!$ret) {
        return $this
          ->setError(elFinder::ERROR_RM, $this
          ->path($stat['hash']));
      }
    }
    else {
      $results = $this
        ->_unlink($this
        ->convEncIn($path));
      if (!$results) {
        return $this
          ->setError(elFinder::ERROR_RM, $this
          ->path($stat['hash']));
      }
      if (is_array($results)) {

        // File is in use and is being protected by Drupal. Fetch the first
        // entity where it's used.
        foreach ($results as $entity_type => $entity) {
          if (is_array($entity)) {
            foreach ($entity as $id => $count) {
              if ($entity_type == 'node' && is_integer($id)) {
                $node = node_load($id);
                if (!empty($node->title)) {
                  return $this
                    ->setError(elFinder::ERROR_RM, $this
                    ->path($stat['hash']), '', t('File is used in @title', array(
                    '@title' => $node->title,
                  )));
                }
              }
            }
          }
        }
        return $this
          ->setError(elFinder::ERROR_RM, $this
          ->path($stat['hash']), t('File is in use.'));
      }
      $this
        ->clearstatcache();
    }
    $this->removed[] = $stat;
    return true;
  }

}

Members

Name	Modifiers	Type	Description	Overrides
elFinderVolumeDrupal::$DrupalFilesACL	protected	property
elFinderVolumeDrupal::AddToDrupalDB	protected	function	Recursive function to add new files to Drupal's db.
elFinderVolumeDrupal::CalculateUserAllowedSpace	protected	function
elFinderVolumeDrupal::CalculateUserUsedSpace	protected	function
elFinderVolumeDrupal::CheckExtension	protected	function	Check if file extension is allowed
elFinderVolumeDrupal::CheckFolderCount	protected	function
elFinderVolumeDrupal::CheckUserQuota	protected	function
elFinderVolumeDrupal::delTree	protected	function	Delete dirctory trees and included files.
elFinderVolumeDrupal::desc	public	function
elFinderVolumeDrupal::downloadcount	public	function
elFinderVolumeDrupal::drupalpathtouri	public	function	Convert path to Drupal file URI
elFinderVolumeDrupal::extract	public	function	Extract files from archive.
elFinderVolumeDrupal::FileUsageAdd	protected	function
elFinderVolumeDrupal::FileUsageDelete	protected	function
elFinderVolumeDrupal::FileValidate	protected	function	Let other Drupal modules perform validation on the uploaded file. See hook_file_validate().
elFinderVolumeDrupal::owner	public	function
elFinderVolumeDrupal::remove	protected	function	Taken from elFinderVolumeDriver::remove().
elFinderVolumeDrupal::rename	public	function	Rename file and return file info
elFinderVolumeDrupal::_archive	protected	function
elFinderVolumeDrupal::_checkArchivers	protected	function
elFinderVolumeDrupal::_copy	protected	function	Copy file into another file
elFinderVolumeDrupal::_drupalfileobject	protected	function	Create Drupal file object
elFinderVolumeDrupal::_mkdir	protected	function	Create dir
elFinderVolumeDrupal::_mkfile	protected	function	Create file
elFinderVolumeDrupal::_move	protected	function	Move file into another parent dir Return new file path or false
elFinderVolumeDrupal::_rmdir	protected	function	Remove dir
elFinderVolumeDrupal::_save	protected	function	Create new file and write into it from file pointer. Return new file path or false on error.
elFinderVolumeDrupal::_scandir	protected	function	Return files list in directory.
elFinderVolumeDrupal::_unlink	protected	function	Remove file