class File

actions_execute in core/includes/actions.inc

Executes a single action.

admin_bar_library_info in core/modules/admin_bar/admin_bar.module

Implements hook_library_info().

admin_bar_menu in core/modules/admin_bar/admin_bar.module

Implements hook_menu().

admin_bar_theme in core/modules/admin_bar/admin_bar.module

Implements hook_theme().

ajax_example_menu in modules/examples/ajax_example/ajax_example.module

Implements hook_menu().

... See full list

class File extends Entity {

  /**
   * The file ID.
   *
   * @var integer
   */
  public $fid;

  /**
   * The file type (bundle).
   *
   * @var string
   */
  public $type;

  /**
   * The file language code.
   *
   * @var string
   */
  public $langcode = LANGUAGE_NONE;

  /**
   * The uid of the user who is associated with the file.
   *
   * @var integer
   */
  public $uid;

  /**
   * Name of the file with no path components.
   *
   * This may differ from the basename of the URI if the file is renamed to
   * avoid overwriting an existing file.
   *
   * @var string
   */
  public $filename;

  /**
   * The URI to access the file (either local or remote).
   *
   * @var string
   */
  public $uri;

  /**
   * The file's MIME type.
   *
   * @var string
   */
  public $filemime;

  /**
   * The size of the file in bytes.
   *
   * @var integer
   */
  public $filesize;

  /**
   * A field indicating the status of the file.
   *
   * Two status are defined in core: temporary (0) and permanent (1).
   * Temporary files older than BACKDROP_MAXIMUM_TEMP_FILE_AGE will be removed
   * during a cron run.
   *
   * @var integer
   */
  public $status;

  /**
   * UNIX timestamp for when the file was last saved.
   *
   * @var integer
   */
  public $timestamp;

  /**
   * Constructor for file entities.
   */
  public function __construct(array $values = array()) {
    // Automatically detect filename if not set.
    if (!isset($values['filename']) && isset($values['uri'])) {
      $values['filename'] = backdrop_basename($values['uri']);
    }

    // Automatically detect filemime if not set.
    if (!isset($values['filemime']) && isset($values['uri'])) {
      $values['filemime'] = file_get_mimetype($values['uri']);
    }

    parent::__construct($values);
  }

  /**
   * Implements EntityInterface::id().
   */
  public function id() {
    return isset($this->fid) ? $this->fid : NULL;
  }

  /**
   * Implements EntityInterface::entityType().
   */
  public function entityType() {
    return 'file';
  }

  /**
   * Implements EntityInterface::bundle().
   */
  public function bundle() {
    return $this->type;
  }

  /**
   * Implements EntityInterface::label().
   */
  public function label() {
    return $this->filename;
  }

  /**
   * Implements EntityInterface::uri().
   */
  public function uri() {
    return array(
      'path' => 'file/' . $this->fid,
      'options' => array(),
    );
  }

  /**
   * Overrides Entity::createAccess().
   */
  public static function createAccess($bundle = NULL, $account = NULL) {
    $rights = &backdrop_static('file_access', array());

    // If no user object is supplied, the access check is for the current user.
    if (empty($account)) {
      $account = $GLOBALS['user'];
    }

    // If we've already checked access for this file, user and op, return from
    // cache.
    if (isset($rights[$account->uid][$bundle])) {
      return $rights[$account->uid][$bundle];
    }

    if (user_access('bypass file access', $account)) {
      $rights[$account->uid][$bundle] = TRUE;
      return $rights[$account->uid][$bundle];
    }
    if (user_access('create files', $account)) {
      $rights[$account->uid][$bundle] = TRUE;
      return $rights[$account->uid][$bundle];
    }

    // We grant access to the file if both of the following conditions are met:
    // - No modules say to deny access.
    // - At least one module says to grant access.
    $access = module_invoke_all('file_access', $bundle, 'create', $account);
    if (in_array(FILE_ACCESS_DENY, $access, TRUE)) {
      $rights[$account->uid][$bundle] = FALSE;
      return $rights[$account->uid][$bundle];
    }
    elseif (in_array(FILE_ACCESS_ALLOW, $access, TRUE)) {
      $rights[$account->uid][$bundle] = TRUE;
      return $rights[$account->uid][$bundle];
    }

    $rights[$account->uid][$bundle] = FALSE;
    return $rights[$account->uid][$bundle];
  }

  /**
   * Overrides Entity::access().
   *
   * @param string $op
   *   The operation to be performed on the file. Possible values are:
   *   - create
   *   - view
   *   - download
   *   - update
   *   - delete
   * @param User|AnonymousUser|object $account
   *   (optional) The user to check for. Leave it to NULL to check for the
   *   global user.
   *
   * @return bool
   *   TRUE if access is granted, FALSE otherwise.
   */
  public function access($op, $account = NULL) {
    $rights = &backdrop_static('file_access', array());

    if ($op == 'create') {
      return self::createAccess($this->bundle(), $account);
    }
    elseif (!in_array($op, array('view', 'update', 'delete', 'download'), TRUE)) {
      // If the $op was not one of the supported ones, we return access denied.
      return FALSE;
    }

    // If no user object is supplied, the access check is for the current user.
    if (empty($account)) {
      $account = $GLOBALS['user'];
    }

    $cid = $this->id();

    // If we've already checked access for this file, user and op, return from
    // cache.
    if (isset($rights[$account->uid][$cid][$op])) {
      return $rights[$account->uid][$cid][$op];
    }

    if (user_access('bypass file access', $account)) {
      return $rights[$account->uid][$cid][$op] = TRUE;
    }

    // We grant access to the file if both of the following conditions are met:
    // - No modules say to deny access.
    // - At least one module says to grant access.
    $access = module_invoke_all('file_access', $op, $this, $account);
    if (in_array(FILE_ACCESS_DENY, $access, TRUE)) {
      return $rights[$account->uid][$cid][$op] = FALSE;
    }
    elseif (in_array(FILE_ACCESS_ALLOW, $access, TRUE)) {
      return $rights[$account->uid][$cid][$op] = TRUE;
    }

    // Fall back to default behaviors on view.
    if ($op == 'view') {
      $scheme = file_uri_scheme($this->uri);
      $wrapper = file_get_stream_wrapper($scheme);

      if (!empty($wrapper['private'])) {
        // For private files, users can view private files if the
        // user has the 'view private files' permission.
        if (user_access('view private files', $account)) {
          return $rights[$account->uid][$cid][$op] = TRUE;
        }

        // For private files, users can view their own private files if the
        // user is not anonymous, and has the 'view own private files'
        // permission.
        if (!empty($account->uid) && $this->uid == $account->uid && user_access('view own private files', $account)) {
          return $rights[$account->uid][$cid][$op] = TRUE;
        }
      }
      elseif ($this->status == FILE_STATUS_PERMANENT && $this->uid == $account->uid && user_access('view own files', $account)) {
        // For non-private files, allow to see if user owns the file.
        return $rights[$account->uid][$cid][$op] = TRUE;
      }
      elseif ($this->status == FILE_STATUS_PERMANENT && user_access('view files', $account)) {
        // For non-private files, users can view if they have the 'view files'
        // permission.
        return $rights[$account->uid][$cid][$op] = TRUE;
      }
    }

    return FALSE;
  }

}