You are here

file.module in Zircon Profile 8.0

Same filename and directory in other branches
  1. 8 core/modules/file/file.module

Defines a "managed_file" Form API field and a "file" field for Field module.

File

core/modules/file/file.module
View source
<?php

/**
 * @file
 * Defines a "managed_file" Form API field and a "file" field for Field module.
 */
use Drupal\Core\Datetime\Entity\DateFormat;
use Drupal\Core\Field\FieldDefinitionInterface;
use Drupal\Core\Form\FormStateInterface;
use Drupal\Core\Render\BubbleableMetadata;
use Drupal\Core\Render\Element;
use Drupal\Core\Routing\RouteMatchInterface;
use Drupal\Core\Url;
use Drupal\file\Entity\File;
use Drupal\file\FileInterface;
use Drupal\Component\Utility\NestedArray;
use Drupal\Component\Utility\Unicode;
use Drupal\Core\Entity\EntityStorageInterface;
use Drupal\Core\Template\Attribute;

// Load all Field module hooks for File.
require_once __DIR__ . '/file.field.inc';

/**
 * Implements hook_help().
 */
function file_help($route_name, RouteMatchInterface $route_match) {
  switch ($route_name) {
    case 'help.page.file':
      $output = '';
      $output .= '<h3>' . t('About') . '</h3>';
      $output .= '<p>' . t('The File module allows you to create fields that contain files. See the <a href=":field">Field module help</a> and the <a href=":field_ui">Field UI help</a> pages for general information on fields and how to create and manage them. For more information, see the <a href=":file_documentation">online documentation for the File module</a>.', array(
        ':field' => \Drupal::url('help.page', array(
          'name' => 'field',
        )),
        ':field_ui' => \Drupal::moduleHandler()
          ->moduleExists('field_ui') ? \Drupal::url('help.page', array(
          'name' => 'field_ui',
        )) : '#',
        ':file_documentation' => 'https://www.drupal.org/documentation/modules/file',
      )) . '</p>';
      $output .= '<h3>' . t('Uses') . '</h3>';
      $output .= '<dl>';
      $output .= '<dt>' . t('Managing and displaying file fields') . '</dt>';
      $output .= '<dd>' . t('The <em>settings</em> and the <em>display</em> of the file field can be configured separately. See the <a href=":field_ui">Field UI help</a> for more information on how to manage fields and their display.', array(
        ':field_ui' => \Drupal::moduleHandler()
          ->moduleExists('field_ui') ? \Drupal::url('help.page', array(
          'name' => 'field_ui',
        )) : '#',
      )) . '</dd>';
      $output .= '<dt>' . t('Allowing file extensions') . '</dt>';
      $output .= '<dd>' . t('In the field settings, you can define the allowed file extensions (for example <em>pdf docx psd</em>) for the files that will be uploaded with the file field.') . '</dd>';
      $output .= '<dt>' . t('Storing files ') . '</dt>';
      $output .= '<dd>' . t('Uploaded files can either be stored as <em>public</em> or <em>private</em>, depending on the <a href=":file-system">File system settings</a>. For more information, see the <a href=":system-help">System module help page</a>.', array(
        ':file-system' => \Drupal::url('system.file_system_settings'),
        ':system-help' => \Drupal::url('help.page', array(
          'name' => 'system',
        )),
      )) . '</dd>';
      $output .= '<dt>' . t('Restricting the maximum file size') . '</dt>';
      $output .= '<dd>' . t('The maximum file size that users can upload is limited by PHP settings of the server, but you can restrict by entering the desired value as the <em>Maximum upload size</em> setting. The maximum file size is automatically displayed to users in the help text of the file field.') . '</dd>';
      $output .= '<dt>' . t('Displaying files and descriptions') . '<dt>';
      $output .= '<dd>' . t('In the field settings, you can allow users to toggle whether individual files are displayed. In the display settings, you can then choose one of the following formats: <ul><li><em>Generic file</em> displays links to the files and adds icons that symbolize the file extensions. If <em>descriptions</em> are enabled and have been submitted, then the description is displayed instead of the file name.</li><li><em>URL to file</em> displays the full path to the file as plain text.</li><li><em>Table of files</em> lists links to the files and the file sizes in a table.</li><li><em>RSS enclosure</em> only displays the first file, and only in a RSS feed, formatted according to the RSS 2.0 syntax for enclosures.</li></ul> A file can still be linked to directly by its URI even if it is not displayed.') . '</dd>';
      $output .= '</dl>';
      return $output;
  }
}

/**
 * Loads file entities from the database.
 *
 * @param array $fids
 *   (optional) An array of entity IDs. If omitted, all entities are loaded.
 * @param bool $reset
 *   Whether to reset the internal file_load_multiple() cache.
 *
 * @return array
 *   An array of file entities, indexed by fid.
 *
 * @deprecated in Drupal 8.x, will be removed before Drupal 9.0.
 *   Use \Drupal\file\Entity\File::loadMultiple().
 *
 * @see hook_ENTITY_TYPE_load()
 * @see file_load()
 * @see entity_load()
 * @see \Drupal\Core\Entity\Query\EntityQueryInterface
 */
function file_load_multiple(array $fids = NULL, $reset = FALSE) {
  if ($reset) {
    \Drupal::entityManager()
      ->getStorage('file')
      ->resetCache($fids);
  }
  return File::loadMultiple($fids);
}

/**
 * Loads a single file entity from the database.
 *
 * @param int $fid
 *   A file ID.
 * @param bool $reset
 *   Whether to reset the internal file_load_multiple() cache.
 *
 * @return \Drupal\file\FileInterface
 *   A file entity or NULL if the file was not found.
 *
 * @deprecated in Drupal 8.x, will be removed before Drupal 9.0.
 *   Use \Drupal\file\Entity\File::load().
 *
 * @see hook_ENTITY_TYPE_load()
 * @see file_load_multiple()
 */
function file_load($fid, $reset = FALSE) {
  if ($reset) {
    \Drupal::entityManager()
      ->getStorage('file')
      ->resetCache(array(
      $fid,
    ));
  }
  return File::load($fid);
}

/**
 * Copies a file to a new location and adds a file record to the database.
 *
 * This function should be used when manipulating files that have records
 * stored in the database. This is a powerful function that in many ways
 * performs like an advanced version of copy().
 * - Checks if $source and $destination are valid and readable/writable.
 * - If file already exists in $destination either the call will error out,
 *   replace the file or rename the file based on the $replace parameter.
 * - If the $source and $destination are equal, the behavior depends on the
 *   $replace parameter. FILE_EXISTS_REPLACE will error out. FILE_EXISTS_RENAME
 *   will rename the file until the $destination is unique.
 * - Adds the new file to the files database. If the source file is a
 *   temporary file, the resulting file will also be a temporary file. See
 *   file_save_upload() for details on temporary files.
 *
 * @param \Drupal\file\FileInterface $source
 *   A file entity.
 * @param string $destination
 *   A string containing the destination that $source should be copied to.
 *   This must be a stream wrapper URI.
 * @param int $replace
 *   Replace behavior when the destination file already exists:
 *   - FILE_EXISTS_REPLACE - Replace the existing file. If a managed file with
 *       the destination name exists then its database entry will be updated. If
 *       no database entry is found then a new one will be created.
 *   - FILE_EXISTS_RENAME - Append _{incrementing number} until the filename is
 *       unique.
 *   - FILE_EXISTS_ERROR - Do nothing and return FALSE.
 *
 * @return \Drupal\file\FileInterface|FALSE
 *   File object if the copy is successful, or FALSE in the event of an error.
 *
 * @see file_unmanaged_copy()
 * @see hook_file_copy()
 */
function file_copy(FileInterface $source, $destination = NULL, $replace = FILE_EXISTS_RENAME) {
  if (!file_valid_uri($destination)) {
    if (($realpath = drupal_realpath($source
      ->getFileUri())) !== FALSE) {
      \Drupal::logger('file')
        ->notice('File %file (%realpath) could not be copied because the destination %destination is invalid. This is often caused by improper use of file_copy() or a missing stream wrapper.', array(
        '%file' => $source
          ->getFileUri(),
        '%realpath' => $realpath,
        '%destination' => $destination,
      ));
    }
    else {
      \Drupal::logger('file')
        ->notice('File %file could not be copied because the destination %destination is invalid. This is often caused by improper use of file_copy() or a missing stream wrapper.', array(
        '%file' => $source
          ->getFileUri(),
        '%destination' => $destination,
      ));
    }
    drupal_set_message(t('The specified file %file could not be copied because the destination is invalid. More information is available in the system log.', array(
      '%file' => $source
        ->getFileUri(),
    )), 'error');
    return FALSE;
  }
  if ($uri = file_unmanaged_copy($source
    ->getFileUri(), $destination, $replace)) {
    $file = $source
      ->createDuplicate();
    $file
      ->setFileUri($uri);
    $file
      ->setFilename(drupal_basename($uri));

    // If we are replacing an existing file re-use its database record.
    // @todo Do not create a new entity in order to update it. See
    //   https://www.drupal.org/node/2241865.
    if ($replace == FILE_EXISTS_REPLACE) {
      $existing_files = entity_load_multiple_by_properties('file', array(
        'uri' => $uri,
      ));
      if (count($existing_files)) {
        $existing = reset($existing_files);
        $file->fid = $existing
          ->id();
        $file
          ->setOriginalId($existing
          ->id());
        $file
          ->setFilename($existing
          ->getFilename());
      }
    }
    elseif ($replace == FILE_EXISTS_RENAME && is_file($destination)) {
      $file
        ->setFilename(drupal_basename($destination));
    }
    $file
      ->save();

    // Inform modules that the file has been copied.
    \Drupal::moduleHandler()
      ->invokeAll('file_copy', array(
      $file,
      $source,
    ));
    return $file;
  }
  return FALSE;
}

/**
 * Moves a file to a new location and update the file's database entry.
 *
 * Moving a file is performed by copying the file to the new location and then
 * deleting the original.
 * - Checks if $source and $destination are valid and readable/writable.
 * - Performs a file move if $source is not equal to $destination.
 * - If file already exists in $destination either the call will error out,
 *   replace the file or rename the file based on the $replace parameter.
 * - Adds the new file to the files database.
 *
 * @param \Drupal\file\FileInterface $source
 *   A file entity.
 * @param string $destination
 *   A string containing the destination that $source should be moved to.
 *   This must be a stream wrapper URI.
 * @param int $replace
 *   Replace behavior when the destination file already exists:
 *   - FILE_EXISTS_REPLACE - Replace the existing file. If a managed file with
 *       the destination name exists then its database entry will be updated and
 *       $source->delete() called after invoking hook_file_move().
 *       If no database entry is found then the source files record will be
 *       updated.
 *   - FILE_EXISTS_RENAME - Append _{incrementing number} until the filename is
 *       unique.
 *   - FILE_EXISTS_ERROR - Do nothing and return FALSE.
 *
 * @return \Drupal\file\FileInterface
 *   Resulting file entity for success, or FALSE in the event of an error.
 *
 * @see file_unmanaged_move()
 * @see hook_file_move()
 */
function file_move(FileInterface $source, $destination = NULL, $replace = FILE_EXISTS_RENAME) {
  if (!file_valid_uri($destination)) {
    if (($realpath = drupal_realpath($source
      ->getFileUri())) !== FALSE) {
      \Drupal::logger('file')
        ->notice('File %file (%realpath) could not be moved because the destination %destination is invalid. This may be caused by improper use of file_move() or a missing stream wrapper.', array(
        '%file' => $source
          ->getFileUri(),
        '%realpath' => $realpath,
        '%destination' => $destination,
      ));
    }
    else {
      \Drupal::logger('file')
        ->notice('File %file could not be moved because the destination %destination is invalid. This may be caused by improper use of file_move() or a missing stream wrapper.', array(
        '%file' => $source
          ->getFileUri(),
        '%destination' => $destination,
      ));
    }
    drupal_set_message(t('The specified file %file could not be moved because the destination is invalid. More information is available in the system log.', array(
      '%file' => $source
        ->getFileUri(),
    )), 'error');
    return FALSE;
  }
  if ($uri = file_unmanaged_move($source
    ->getFileUri(), $destination, $replace)) {
    $delete_source = FALSE;
    $file = clone $source;
    $file
      ->setFileUri($uri);

    // If we are replacing an existing file re-use its database record.
    if ($replace == FILE_EXISTS_REPLACE) {
      $existing_files = entity_load_multiple_by_properties('file', array(
        'uri' => $uri,
      ));
      if (count($existing_files)) {
        $existing = reset($existing_files);
        $delete_source = TRUE;
        $file->fid = $existing
          ->id();
        $file->uuid = $existing
          ->uuid();
      }
    }
    elseif ($replace == FILE_EXISTS_RENAME && is_file($destination)) {
      $file
        ->setFilename(drupal_basename($destination));
    }
    $file
      ->save();

    // Inform modules that the file has been moved.
    \Drupal::moduleHandler()
      ->invokeAll('file_move', array(
      $file,
      $source,
    ));

    // Delete the original if it's not in use elsewhere.
    if ($delete_source && !\Drupal::service('file.usage')
      ->listUsage($source)) {
      $source
        ->delete();
    }
    return $file;
  }
  return FALSE;
}

/**
 * Checks that a file meets the criteria specified by the validators.
 *
 * After executing the validator callbacks specified hook_file_validate() will
 * also be called to allow other modules to report errors about the file.
 *
 * @param \Drupal\file\FileInterface $file
 *   A file entity.
 * @param array $validators
 *   An optional, associative array of callback functions used to validate the
 *   file. The keys are function names and the values arrays of callback
 *   parameters which will be passed in after the file entity. The
 *   functions should return an array of error messages; an empty array
 *   indicates that the file passed validation. The functions will be called in
 *   the order specified.
 *
 * @return array
 *   An array containing validation error messages.
 *
 * @see hook_file_validate()
 */
function file_validate(FileInterface $file, $validators = array()) {

  // Call the validation functions specified by this function's caller.
  $errors = array();
  foreach ($validators as $function => $args) {
    if (function_exists($function)) {
      array_unshift($args, $file);
      $errors = array_merge($errors, call_user_func_array($function, $args));
    }
  }

  // Let other modules perform validation on the new file.
  return array_merge($errors, \Drupal::moduleHandler()
    ->invokeAll('file_validate', array(
    $file,
  )));
}

/**
 * Checks for files with names longer than can be stored in the database.
 *
 * @param \Drupal\file\FileInterface $file
 *   A file entity.
 *
 * @return array
 *   An array. If the file name is too long, it will contain an error message.
 */
function file_validate_name_length(FileInterface $file) {
  $errors = array();
  if (!$file
    ->getFilename()) {
    $errors[] = t("The file's name is empty. Please give a name to the file.");
  }
  if (strlen($file
    ->getFilename()) > 240) {
    $errors[] = t("The file's name exceeds the 240 characters limit. Please rename the file and try again.");
  }
  return $errors;
}

/**
 * Checks that the filename ends with an allowed extension.
 *
 * @param \Drupal\file\FileInterface $file
 *   A file entity.
 * @param string $extensions
 *   A string with a space separated list of allowed extensions.
 *
 * @return array
 *   An array. If the file extension is not allowed, it will contain an error
 *   message.
 *
 * @see hook_file_validate()
 */
function file_validate_extensions(FileInterface $file, $extensions) {
  $errors = array();
  $regex = '/\\.(' . preg_replace('/ +/', '|', preg_quote($extensions)) . ')$/i';
  if (!preg_match($regex, $file
    ->getFilename())) {
    $errors[] = t('Only files with the following extensions are allowed: %files-allowed.', array(
      '%files-allowed' => $extensions,
    ));
  }
  return $errors;
}

/**
 * Checks that the file's size is below certain limits.
 *
 * @param \Drupal\file\FileInterface $file
 *   A file entity.
 * @param int $file_limit
 *   An integer specifying the maximum file size in bytes. Zero indicates that
 *   no limit should be enforced.
 * @param int $user_limit
 *   An integer specifying the maximum number of bytes the user is allowed.
 *   Zero indicates that no limit should be enforced.
 *
 * @return array
 *   An array. If the file size exceeds limits, it will contain an error
 *   message.
 *
 * @see hook_file_validate()
 */
function file_validate_size(FileInterface $file, $file_limit = 0, $user_limit = 0) {
  $user = \Drupal::currentUser();
  $errors = array();
  if ($file_limit && $file
    ->getSize() > $file_limit) {
    $errors[] = t('The file is %filesize exceeding the maximum file size of %maxsize.', array(
      '%filesize' => format_size($file
        ->getSize()),
      '%maxsize' => format_size($file_limit),
    ));
  }

  // Save a query by only calling spaceUsed() when a limit is provided.
  if ($user_limit && \Drupal::entityManager()
    ->getStorage('file')
    ->spaceUsed($user
    ->id()) + $file
    ->getSize() > $user_limit) {
    $errors[] = t('The file is %filesize which would exceed your disk quota of %quota.', array(
      '%filesize' => format_size($file
        ->getSize()),
      '%quota' => format_size($user_limit),
    ));
  }
  return $errors;
}

/**
 * Checks that the file is recognized as a valid image.
 *
 * @param \Drupal\file\FileInterface $file
 *   A file entity.
 *
 * @return array
 *   An array. If the file is not an image, it will contain an error message.
 *
 * @see hook_file_validate()
 */
function file_validate_is_image(FileInterface $file) {
  $errors = array();
  $image_factory = \Drupal::service('image.factory');
  $image = $image_factory
    ->get($file
    ->getFileUri());
  if (!$image
    ->isValid()) {
    $supported_extensions = $image_factory
      ->getSupportedExtensions();
    $errors[] = t('Image type not supported. Allowed types: %types', array(
      '%types' => implode(' ', $supported_extensions),
    ));
  }
  return $errors;
}

/**
 * Verifies that image dimensions are within the specified maximum and minimum.
 *
 * Non-image files will be ignored. If an image toolkit is available the image
 * will be scaled to fit within the desired maximum dimensions.
 *
 * @param \Drupal\file\FileInterface $file
 *   A file entity. This function may resize the file affecting its size.
 * @param string $maximum_dimensions
 *   An optional string in the form WIDTHxHEIGHT e.g. '640x480' or '85x85'. If
 *   an image toolkit is installed the image will be resized down to these
 *   dimensions. A value of 0 indicates no restriction on size, so resizing
 *   will be attempted.
 * @param string $minimum_dimensions
 *   An optional string in the form WIDTHxHEIGHT. This will check that the
 *   image meets a minimum size. A value of 0 indicates no restriction.
 *
 * @return
 *   An array. If the file is an image and did not meet the requirements, it
 *   will contain an error message.
 *
 * @see hook_file_validate()
 */
function file_validate_image_resolution(FileInterface $file, $maximum_dimensions = 0, $minimum_dimensions = 0) {
  $errors = array();

  // Check first that the file is an image.
  $image_factory = \Drupal::service('image.factory');
  $image = $image_factory
    ->get($file
    ->getFileUri());
  if ($image
    ->isValid()) {
    if ($maximum_dimensions) {

      // Check that it is smaller than the given dimensions.
      list($width, $height) = explode('x', $maximum_dimensions);
      if ($image
        ->getWidth() > $width || $image
        ->getHeight() > $height) {

        // Try to resize the image to fit the dimensions.
        if ($image
          ->scale($width, $height)) {
          $image
            ->save();
          $file->filesize = $image
            ->getFileSize();
          drupal_set_message(t('The image was resized to fit within the maximum allowed dimensions of %dimensions pixels.', array(
            '%dimensions' => $maximum_dimensions,
          )));
        }
        else {
          $errors[] = t('The image exceeds the maximum allowed dimensions and an attempt to resize it failed.');
        }
      }
    }
    if ($minimum_dimensions) {

      // Check that it is larger than the given dimensions.
      list($width, $height) = explode('x', $minimum_dimensions);
      if ($image
        ->getWidth() < $width || $image
        ->getHeight() < $height) {
        $errors[] = t('The image is too small; the minimum dimensions are %dimensions pixels.', array(
          '%dimensions' => $minimum_dimensions,
        ));
      }
    }
  }
  return $errors;
}

/**
 * Saves a file to the specified destination and creates a database entry.
 *
 * @param string $data
 *   A string containing the contents of the file.
 * @param string $destination
 *   A string containing the destination URI. This must be a stream wrapper URI.
 *   If no value is provided, a randomized name will be generated and the file
 *   will be saved using Drupal's default files scheme, usually "public://".
 * @param int $replace
 *   Replace behavior when the destination file already exists:
 *   - FILE_EXISTS_REPLACE - Replace the existing file. If a managed file with
 *       the destination name exists then its database entry will be updated. If
 *       no database entry is found then a new one will be created.
 *   - FILE_EXISTS_RENAME - Append _{incrementing number} until the filename is
 *       unique.
 *   - FILE_EXISTS_ERROR - Do nothing and return FALSE.
 *
 * @return \Drupal\file\FileInterface
 *   A file entity, or FALSE on error.
 *
 * @see file_unmanaged_save_data()
 */
function file_save_data($data, $destination = NULL, $replace = FILE_EXISTS_RENAME) {
  $user = \Drupal::currentUser();
  if (empty($destination)) {
    $destination = file_default_scheme() . '://';
  }
  if (!file_valid_uri($destination)) {
    \Drupal::logger('file')
      ->notice('The data could not be saved because the destination %destination is invalid. This may be caused by improper use of file_save_data() or a missing stream wrapper.', array(
      '%destination' => $destination,
    ));
    drupal_set_message(t('The data could not be saved because the destination is invalid. More information is available in the system log.'), 'error');
    return FALSE;
  }
  if ($uri = file_unmanaged_save_data($data, $destination, $replace)) {

    // Create a file entity.
    $file = entity_create('file', array(
      'uri' => $uri,
      'uid' => $user
        ->id(),
      'status' => FILE_STATUS_PERMANENT,
    ));

    // If we are replacing an existing file re-use its database record.
    // @todo Do not create a new entity in order to update it. See
    //   https://www.drupal.org/node/2241865.
    if ($replace == FILE_EXISTS_REPLACE) {
      $existing_files = entity_load_multiple_by_properties('file', array(
        'uri' => $uri,
      ));
      if (count($existing_files)) {
        $existing = reset($existing_files);
        $file->fid = $existing
          ->id();
        $file
          ->setOriginalId($existing
          ->id());
        $file
          ->setFilename($existing
          ->getFilename());
      }
    }
    elseif ($replace == FILE_EXISTS_RENAME && is_file($destination)) {
      $file
        ->setFilename(drupal_basename($destination));
    }
    $file
      ->save();
    return $file;
  }
  return FALSE;
}

/**
 * Examines a file entity and returns appropriate content headers for download.
 *
 * @param \Drupal\file\FileInterface $file
 *   A file entity.
 *
 * @return array
 *   An associative array of headers, as expected by
 *   \Symfony\Component\HttpFoundation\StreamedResponse.
 */
function file_get_content_headers(FileInterface $file) {
  $type = Unicode::mimeHeaderEncode($file
    ->getMimeType());
  return array(
    'Content-Type' => $type,
    'Content-Length' => $file
      ->getSize(),
    'Cache-Control' => 'private',
  );
}

/**
 * Implements hook_theme().
 */
function file_theme() {
  return array(
    // From file.module.
    'file_link' => array(
      'variables' => array(
        'file' => NULL,
        'description' => NULL,
        'attributes' => array(),
      ),
    ),
    'file_managed_file' => array(
      'render element' => 'element',
    ),
    // From file.field.inc.
    'file_widget_multiple' => array(
      'render element' => 'element',
      'file' => 'file.field.inc',
    ),
    'file_upload_help' => array(
      'variables' => array(
        'description' => NULL,
        'upload_validators' => NULL,
        'cardinality' => NULL,
      ),
      'file' => 'file.field.inc',
    ),
  );
}

/**
 * Implements hook_file_download().
 */
function file_file_download($uri) {

  // Get the file record based on the URI. If not in the database just return.

  /** @var \Drupal\file\FileInterface[] $files */
  $files = entity_load_multiple_by_properties('file', array(
    'uri' => $uri,
  ));
  if (count($files)) {
    foreach ($files as $item) {

      // Since some database servers sometimes use a case-insensitive comparison
      // by default, double check that the filename is an exact match.
      if ($item
        ->getFileUri() === $uri) {
        $file = $item;
        break;
      }
    }
  }
  if (!isset($file)) {
    return;
  }

  // Find out if a temporary file is still used in the system.
  if ($file
    ->isTemporary()) {
    $usage = \Drupal::service('file.usage')
      ->listUsage($file);
    if (empty($usage) && $file
      ->getOwnerId() != \Drupal::currentUser()
      ->id()) {

      // Deny access to temporary files without usage that are not owned by the
      // same user. This prevents the security issue that a private file that
      // was protected by field permissions becomes available after its usage
      // was removed and before it is actually deleted from the file system.
      // Modules that depend on this behavior should make the file permanent
      // instead.
      return -1;
    }
  }

  // Find out which (if any) fields of this type contain the file.
  $references = file_get_file_references($file, NULL, EntityStorageInterface::FIELD_LOAD_CURRENT, NULL);

  // Stop processing if there are no references in order to avoid returning
  // headers for files controlled by other modules. Make an exception for
  // temporary files where the host entity has not yet been saved (for example,
  // an image preview on a node/add form) in which case, allow download by the
  // file's owner.
  if (empty($references) && ($file
    ->isPermanent() || $file
    ->getOwnerId() != \Drupal::currentUser()
    ->id())) {
    return;
  }
  if (!$file
    ->access('download')) {
    return -1;
  }

  // Access is granted.
  $headers = file_get_content_headers($file);
  return $headers;
}

/**
 * Implements hook_cron().
 */
function file_cron() {
  $age = \Drupal::config('system.file')
    ->get('temporary_maximum_age');
  $file_storage = \Drupal::entityManager()
    ->getStorage('file');

  // Only delete temporary files if older than $age. Note that automatic cleanup
  // is disabled if $age set to 0.
  if ($age) {
    $fids = Drupal::entityQuery('file')
      ->condition('status', FILE_STATUS_PERMANENT, '<>')
      ->condition('changed', REQUEST_TIME - $age, '<')
      ->range(0, 100)
      ->execute();
    $files = $file_storage
      ->loadMultiple($fids);
    foreach ($files as $file) {
      $references = \Drupal::service('file.usage')
        ->listUsage($file);
      if (empty($references)) {
        if (file_exists($file
          ->getFileUri())) {
          $file
            ->delete();
        }
        else {
          \Drupal::logger('file system')
            ->error('Could not delete temporary file "%path" during garbage collection', array(
            '%path' => $file
              ->getFileUri(),
          ));
        }
      }
      else {
        \Drupal::logger('file system')
          ->info('Did not delete temporary file "%path" during garbage collection because it is in use by the following modules: %modules.', array(
          '%path' => $file
            ->getFileUri(),
          '%modules' => implode(', ', array_keys($references)),
        ));
      }
    }
  }
}

/**
 * Saves file uploads to a new location.
 *
 * The files will be added to the {file_managed} table as temporary files.
 * Temporary files are periodically cleaned. Use the 'file.usage' service to
 * register the usage of the file which will automatically mark it as permanent.
 *
 * @param string $form_field_name
 *   A string that is the associative array key of the upload form element in
 *   the form array.
 * @param array $validators
 *   An optional, associative array of callback functions used to validate the
 *   file. See file_validate() for a full discussion of the array format.
 *   If no extension validator is provided it will default to a limited safe
 *   list of extensions which is as follows: "jpg jpeg gif png txt
 *   doc xls pdf ppt pps odt ods odp". To allow all extensions you must
 *   explicitly set the 'file_validate_extensions' validator to an empty array
 *   (Beware: this is not safe and should only be allowed for trusted users, if
 *   at all).
 * @param string $destination
 *   A string containing the URI that the file should be copied to. This must
 *   be a stream wrapper URI. If this value is omitted, Drupal's temporary
 *   files scheme will be used ("temporary://").
 * @param int $delta
 *   Delta of the file to save or NULL to save all files. Defaults to NULL.
 * @param int $replace
 *   Replace behavior when the destination file already exists:
 *   - FILE_EXISTS_REPLACE: Replace the existing file.
 *   - FILE_EXISTS_RENAME: Append _{incrementing number} until the filename is
 *     unique.
 *   - FILE_EXISTS_ERROR: Do nothing and return FALSE.
 *
 * @return array
 *   Function returns array of files or a single file object if $delta
 *   != NULL. Each file object contains the file information if the
 *   upload succeeded or FALSE in the event of an error. Function
 *   returns NULL if no file was uploaded.
 *
 *   The documentation for the "File interface" group, which you can find under
 *   Related topics, or the header at the top of this file, documents the
 *   components of a file entity. In addition to the standard components,
 *   this function adds:
 *   - source: Path to the file before it is moved.
 *   - destination: Path to the file after it is moved (same as 'uri').
 */
function file_save_upload($form_field_name, $validators = array(), $destination = FALSE, $delta = NULL, $replace = FILE_EXISTS_RENAME) {
  $user = \Drupal::currentUser();
  static $upload_cache;
  $file_upload = \Drupal::request()->files
    ->get("files[{$form_field_name}]", NULL, TRUE);

  // Make sure there's an upload to process.
  if (empty($file_upload)) {
    return NULL;
  }

  // Return cached objects without processing since the file will have
  // already been processed and the paths in $_FILES will be invalid.
  if (isset($upload_cache[$form_field_name])) {
    if (isset($delta)) {
      return $upload_cache[$form_field_name][$delta];
    }
    return $upload_cache[$form_field_name];
  }

  // Prepare uploaded files info. Representation is slightly different
  // for multiple uploads and we fix that here.
  $uploaded_files = $file_upload;
  if (!is_array($file_upload)) {
    $uploaded_files = array(
      $file_upload,
    );
  }
  $files = array();
  foreach ($uploaded_files as $i => $file_info) {

    // Check for file upload errors and return FALSE for this file if a lower
    // level system error occurred. For a complete list of errors:
    // See http://php.net/manual/features.file-upload.errors.php.
    switch ($file_info
      ->getError()) {
      case UPLOAD_ERR_INI_SIZE:
      case UPLOAD_ERR_FORM_SIZE:
        drupal_set_message(t('The file %file could not be saved because it exceeds %maxsize, the maximum allowed size for uploads.', array(
          '%file' => $file_info
            ->getFilename(),
          '%maxsize' => format_size(file_upload_max_size()),
        )), 'error');
        $files[$i] = FALSE;
        continue;
      case UPLOAD_ERR_PARTIAL:
      case UPLOAD_ERR_NO_FILE:
        drupal_set_message(t('The file %file could not be saved because the upload did not complete.', array(
          '%file' => $file_info
            ->getFilename(),
        )), 'error');
        $files[$i] = FALSE;
        continue;
      case UPLOAD_ERR_OK:

        // Final check that this is a valid upload, if it isn't, use the
        // default error handler.
        if (is_uploaded_file($file_info
          ->getRealPath())) {
          break;
        }

      // Unknown error
      default:
        drupal_set_message(t('The file %file could not be saved. An unknown error has occurred.', array(
          '%file' => $file_info
            ->getFilename(),
        )), 'error');
        $files[$i] = FALSE;
        continue;
    }

    // Begin building file entity.
    $values = array(
      'uid' => $user
        ->id(),
      'status' => 0,
      'filename' => $file_info
        ->getClientOriginalName(),
      'uri' => $file_info
        ->getRealPath(),
      'filesize' => $file_info
        ->getSize(),
    );
    $values['filemime'] = \Drupal::service('file.mime_type.guesser')
      ->guess($values['filename']);
    $file = entity_create('file', $values);
    $extensions = '';
    if (isset($validators['file_validate_extensions'])) {
      if (isset($validators['file_validate_extensions'][0])) {

        // Build the list of non-munged extensions if the caller provided them.
        $extensions = $validators['file_validate_extensions'][0];
      }
      else {

        // If 'file_validate_extensions' is set and the list is empty then the
        // caller wants to allow any extension. In this case we have to remove the
        // validator or else it will reject all extensions.
        unset($validators['file_validate_extensions']);
      }
    }
    else {

      // No validator was provided, so add one using the default list.
      // Build a default non-munged safe list for file_munge_filename().
      $extensions = 'jpg jpeg gif png txt doc xls pdf ppt pps odt ods odp';
      $validators['file_validate_extensions'] = array();
      $validators['file_validate_extensions'][0] = $extensions;
    }
    if (!empty($extensions)) {

      // Munge the filename to protect against possible malicious extension
      // hiding within an unknown file type (ie: filename.html.foo).
      $file
        ->setFilename(file_munge_filename($file
        ->getFilename(), $extensions));
    }

    // Rename potentially executable files, to help prevent exploits (i.e. will
    // rename filename.php.foo and filename.php to filename.php.foo.txt and
    // filename.php.txt, respectively). Don't rename if 'allow_insecure_uploads'
    // evaluates to TRUE.
    if (!\Drupal::config('system.file')
      ->get('allow_insecure_uploads') && preg_match('/\\.(php|pl|py|cgi|asp|js)(\\.|$)/i', $file
      ->getFilename()) && substr($file
      ->getFilename(), -4) != '.txt') {
      $file
        ->setMimeType('text/plain');

      // The destination filename will also later be used to create the URI.
      $file
        ->setFilename($file
        ->getFilename() . '.txt');

      // The .txt extension may not be in the allowed list of extensions. We have
      // to add it here or else the file upload will fail.
      if (!empty($extensions)) {
        $validators['file_validate_extensions'][0] .= ' txt';
        drupal_set_message(t('For security reasons, your upload has been renamed to %filename.', array(
          '%filename' => $file
            ->getFilename(),
        )));
      }
    }

    // If the destination is not provided, use the temporary directory.
    if (empty($destination)) {
      $destination = 'temporary://';
    }

    // Assert that the destination contains a valid stream.
    $destination_scheme = file_uri_scheme($destination);
    if (!file_stream_wrapper_valid_scheme($destination_scheme)) {
      drupal_set_message(t('The file could not be uploaded because the destination %destination is invalid.', array(
        '%destination' => $destination,
      )), 'error');
      $files[$i] = FALSE;
      continue;
    }
    $file->source = $form_field_name;

    // A file URI may already have a trailing slash or look like "public://".
    if (substr($destination, -1) != '/') {
      $destination .= '/';
    }
    $file->destination = file_destination($destination . $file
      ->getFilename(), $replace);

    // If file_destination() returns FALSE then $replace === FILE_EXISTS_ERROR and
    // there's an existing file so we need to bail.
    if ($file->destination === FALSE) {
      drupal_set_message(t('The file %source could not be uploaded because a file by that name already exists in the destination %directory.', array(
        '%source' => $form_field_name,
        '%directory' => $destination,
      )), 'error');
      $files[$i] = FALSE;
      continue;
    }

    // Add in our check of the file name length.
    $validators['file_validate_name_length'] = array();

    // Call the validation functions specified by this function's caller.
    $errors = file_validate($file, $validators);

    // Check for errors.
    if (!empty($errors)) {
      $message = array(
        'error' => array(
          '#markup' => t('The specified file %name could not be uploaded.', array(
            '%name' => $file
              ->getFilename(),
          )),
        ),
        'item_list' => array(
          '#theme' => 'item_list',
          '#items' => $errors,
        ),
      );

      // @todo Add support for render arrays in drupal_set_message()? See
      //  https://www.drupal.org/node/2505497.
      drupal_set_message(\Drupal::service('renderer')
        ->renderPlain($message), 'error');
      $files[$i] = FALSE;
      continue;
    }

    // Move uploaded files from PHP's upload_tmp_dir to Drupal's temporary
    // directory. This overcomes open_basedir restrictions for future file
    // operations.
    $file
      ->setFileUri($file->destination);
    if (!drupal_move_uploaded_file($file_info
      ->getRealPath(), $file
      ->getFileUri())) {
      drupal_set_message(t('File upload error. Could not move uploaded file.'), 'error');
      \Drupal::logger('file')
        ->notice('Upload error. Could not move uploaded file %file to destination %destination.', array(
        '%file' => $file
          ->getFilename(),
        '%destination' => $file
          ->getFileUri(),
      ));
      $files[$i] = FALSE;
      continue;
    }

    // Set the permissions on the new file.
    drupal_chmod($file
      ->getFileUri());

    // If we are replacing an existing file re-use its database record.
    // @todo Do not create a new entity in order to update it. See
    //   https://www.drupal.org/node/2241865.
    if ($replace == FILE_EXISTS_REPLACE) {
      $existing_files = entity_load_multiple_by_properties('file', array(
        'uri' => $file
          ->getFileUri(),
      ));
      if (count($existing_files)) {
        $existing = reset($existing_files);
        $file->fid = $existing
          ->id();
        $file
          ->setOriginalId($existing
          ->id());
      }
    }

    // If we made it this far it's safe to record this file in the database.
    $file
      ->save();
    $files[$i] = $file;
  }

  // Add files to the cache.
  $upload_cache[$form_field_name] = $files;
  return isset($delta) ? $files[$delta] : $files;
}

/**
 * Determines the preferred upload progress implementation.
 *
 * @return string|FALSE
 *   A string indicating which upload progress system is available. Either "apc"
 *   or "uploadprogress". If neither are available, returns FALSE.
 */
function file_progress_implementation() {
  static $implementation;
  if (!isset($implementation)) {
    $implementation = FALSE;

    // We prefer the PECL extension uploadprogress because it supports multiple
    // simultaneous uploads. APC only supports one at a time.
    if (extension_loaded('uploadprogress')) {
      $implementation = 'uploadprogress';
    }
    elseif (extension_loaded('apc') && ini_get('apc.rfc1867')) {
      $implementation = 'apc';
    }
  }
  return $implementation;
}

/**
 * Implements hook_ENTITY_TYPE_predelete() for file entities.
 */
function file_file_predelete(File $file) {

  // TODO: Remove references to a file that is in-use.
}

/**
 * Implements hook_tokens().
 */
function file_tokens($type, $tokens, array $data, array $options, BubbleableMetadata $bubbleable_metadata) {
  $token_service = \Drupal::token();
  $url_options = array(
    'absolute' => TRUE,
  );
  if (isset($options['langcode'])) {
    $url_options['language'] = \Drupal::languageManager()
      ->getLanguage($options['langcode']);
    $langcode = $options['langcode'];
  }
  else {
    $langcode = NULL;
  }
  $replacements = array();
  if ($type == 'file' && !empty($data['file'])) {

    /** @var \Drupal\file\FileInterface $file */
    $file = $data['file'];
    foreach ($tokens as $name => $original) {
      switch ($name) {

        // Basic keys and values.
        case 'fid':
          $replacements[$original] = $file
            ->id();
          break;

        // Essential file data
        case 'name':
          $replacements[$original] = $file
            ->getFilename();
          break;
        case 'path':
          $replacements[$original] = $file
            ->getFileUri();
          break;
        case 'mime':
          $replacements[$original] = $file
            ->getMimeType();
          break;
        case 'size':
          $replacements[$original] = format_size($file
            ->getSize());
          break;
        case 'url':
          $replacements[$original] = file_create_url($file
            ->getFileUri());
          break;

        // These tokens are default variations on the chained tokens handled below.
        case 'created':
          $date_format = DateFormat::load('medium');
          $bubbleable_metadata
            ->addCacheableDependency($date_format);
          $replacements[$original] = format_date($file
            ->getCreatedTime(), 'medium', '', NULL, $langcode);
          break;
        case 'changed':
          $date_format = DateFormat::load('medium');
          $bubbleable_metadata = $bubbleable_metadata
            ->addCacheableDependency($date_format);
          $replacements[$original] = format_date($file
            ->getChangedTime(), 'medium', '', NULL, $langcode);
          break;
        case 'owner':
          $owner = $file
            ->getOwner();
          $bubbleable_metadata
            ->addCacheableDependency($owner);
          $name = $owner
            ->label();
          $replacements[$original] = $name;
          break;
      }
    }
    if ($date_tokens = $token_service
      ->findWithPrefix($tokens, 'created')) {
      $replacements += $token_service
        ->generate('date', $date_tokens, array(
        'date' => $file
          ->getCreatedTime(),
      ), $options, $bubbleable_metadata);
    }
    if ($date_tokens = $token_service
      ->findWithPrefix($tokens, 'changed')) {
      $replacements += $token_service
        ->generate('date', $date_tokens, array(
        'date' => $file
          ->getChangedTime(),
      ), $options, $bubbleable_metadata);
    }
    if (($owner_tokens = $token_service
      ->findWithPrefix($tokens, 'owner')) && $file
      ->getOwner()) {
      $replacements += $token_service
        ->generate('user', $owner_tokens, array(
        'user' => $file
          ->getOwner(),
      ), $options, $bubbleable_metadata);
    }
  }
  return $replacements;
}

/**
 * Implements hook_token_info().
 */
function file_token_info() {
  $types['file'] = array(
    'name' => t("Files"),
    'description' => t("Tokens related to uploaded files."),
    'needs-data' => 'file',
  );

  // File related tokens.
  $file['fid'] = array(
    'name' => t("File ID"),
    'description' => t("The unique ID of the uploaded file."),
  );
  $file['name'] = array(
    'name' => t("File name"),
    'description' => t("The name of the file on disk."),
  );
  $file['path'] = array(
    'name' => t("Path"),
    'description' => t("The location of the file relative to Drupal root."),
  );
  $file['mime'] = array(
    'name' => t("MIME type"),
    'description' => t("The MIME type of the file."),
  );
  $file['size'] = array(
    'name' => t("File size"),
    'description' => t("The size of the file."),
  );
  $file['url'] = array(
    'name' => t("URL"),
    'description' => t("The web-accessible URL for the file."),
  );
  $file['created'] = array(
    'name' => t("Created"),
    'description' => t("The date the file created."),
    'type' => 'date',
  );
  $file['changed'] = array(
    'name' => t("Changed"),
    'description' => t("The date the file was most recently changed."),
    'type' => 'date',
  );
  $file['owner'] = array(
    'name' => t("Owner"),
    'description' => t("The user who originally uploaded the file."),
    'type' => 'user',
  );
  return array(
    'types' => $types,
    'tokens' => array(
      'file' => $file,
    ),
  );
}

/**
 * Form submission handler for upload / remove buttons of managed_file elements.
 *
 * @see \Drupal\file\Element\ManagedFile::processManagedFile()
 */
function file_managed_file_submit($form, FormStateInterface $form_state) {

  // Determine whether it was the upload or the remove button that was clicked,
  // and set $element to the managed_file element that contains that button.
  $parents = $form_state
    ->getTriggeringElement()['#array_parents'];
  $button_key = array_pop($parents);
  $element = NestedArray::getValue($form, $parents);

  // No action is needed here for the upload button, because all file uploads on
  // the form are processed by \Drupal\file\Element\ManagedFile::valueCallback()
  // regardless of which button was clicked. Action is needed here for the
  // remove button, because we only remove a file in response to its remove
  // button being clicked.
  if ($button_key == 'remove_button') {
    $fids = array_keys($element['#files']);

    // Get files that will be removed.
    if ($element['#multiple']) {
      $remove_fids = array();
      foreach (Element::children($element) as $name) {
        if (strpos($name, 'file_') === 0 && $element[$name]['selected']['#value']) {
          $remove_fids[] = (int) substr($name, 5);
        }
      }
      $fids = array_diff($fids, $remove_fids);
    }
    else {

      // If we deal with single upload element remove the file and set
      // element's value to empty array (file could not be removed from
      // element if we don't do that).
      $remove_fids = $fids;
      $fids = array();
    }
    foreach ($remove_fids as $fid) {

      // If it's a temporary file we can safely remove it immediately, otherwise
      // it's up to the implementing module to remove usages of files to have them
      // removed.
      if ($element['#files'][$fid] && $element['#files'][$fid]
        ->isTemporary()) {
        $element['#files'][$fid]
          ->delete();
      }
    }

    // Update both $form_state->getValues() and FormState::$input to reflect
    // that the file has been removed, so that the form is rebuilt correctly.
    // $form_state->getValues() must be updated in case additional submit
    // handlers run, and for form building functions that run during the
    // rebuild, such as when the managed_file element is part of a field widget.
    // FormState::$input must be updated so that
    // \Drupal\file\Element\ManagedFile::valueCallback() has correct information
    // during the rebuild.
    $form_state
      ->setValueForElement($element['fids'], implode(' ', $fids));
    NestedArray::setValue($form_state
      ->getUserInput(), $element['fids']['#parents'], implode(' ', $fids));
  }

  // Set the form to rebuild so that $form is correctly updated in response to
  // processing the file removal. Since this function did not change $form_state
  // if the upload button was clicked, a rebuild isn't necessary in that
  // situation and calling $form_state->disableRedirect() would suffice.
  // However, we choose to always rebuild, to keep the form processing workflow
  // consistent between the two buttons.
  $form_state
    ->setRebuild();
}

/**
 * Saves any files that have been uploaded into a managed_file element.
 *
 * @param array $element
 *   The FAPI element whose values are being saved.
 * @param \Drupal\Core\Form\FormStateInterface $form_state
 *   The current state of the form.
 *
 * @return array
 *   An array of file entities for each file that was saved, keyed by its file
 *   ID, or FALSE if no files were saved.
 */
function file_managed_file_save_upload($element, FormStateInterface $form_state) {
  $upload_name = implode('_', $element['#parents']);
  $file_upload = \Drupal::request()->files
    ->get("files[{$upload_name}]", NULL, TRUE);
  if (empty($file_upload)) {
    return FALSE;
  }
  $destination = isset($element['#upload_location']) ? $element['#upload_location'] : NULL;
  if (isset($destination) && !file_prepare_directory($destination, FILE_CREATE_DIRECTORY)) {
    \Drupal::logger('file')
      ->notice('The upload directory %directory for the file field !name could not be created or is not accessible. A newly uploaded file could not be saved in this directory as a consequence, and the upload was canceled.', array(
      '%directory' => $destination,
      '!name' => $element['#field_name'],
    ));
    $form_state
      ->setError($element, t('The file could not be uploaded.'));
    return FALSE;
  }

  // Save attached files to the database.
  $files_uploaded = $element['#multiple'] && count(array_filter($file_upload)) > 0;
  $files_uploaded |= !$element['#multiple'] && !empty($file_upload);
  if ($files_uploaded) {
    if (!($files = file_save_upload($upload_name, $element['#upload_validators'], $destination))) {
      \Drupal::logger('file')
        ->notice('The file upload failed. %upload', array(
        '%upload' => $upload_name,
      ));
      $form_state
        ->setError($element, t('Files in the @name field were unable to be uploaded.', array(
        '@name' => $element['#title'],
      )));
      return array();
    }

    // Value callback expects FIDs to be keys.
    $files = array_filter($files);
    $fids = array_map(function ($file) {
      return $file
        ->id();
    }, $files);
    return empty($files) ? array() : array_combine($fids, $files);
  }
  return array();
}

/**
 * Prepares variables for file form widget templates.
 *
 * Default template: file-managed-file.html.twig.
 *
 * @param array $variables
 *   An associative array containing:
 *   - element: A render element representing the file.
 */
function template_preprocess_file_managed_file(&$variables) {
  $element = $variables['element'];
  $variables['attributes'] = array();
  if (isset($element['#id'])) {
    $variables['attributes']['id'] = $element['#id'];
  }
  if (!empty($element['#attributes']['class'])) {
    $variables['attributes']['class'] = (array) $element['#attributes']['class'];
  }
}

/**
 * Prepares variables for file link templates.
 *
 * Default template: file-link.html.twig.
 *
 * @param array $variables
 *   An associative array containing:
 *   - file: A file object to which the link will be created.
 *   - icon_directory: (optional) A path to a directory of icons to be used for
 *     files. Defaults to the value of the "icon.directory" variable.
 *   - description: A description to be displayed instead of the filename.
 *   - attributes: An associative array of attributes to be placed in the a tag.
 */
function template_preprocess_file_link(&$variables) {
  $file = $variables['file'];
  $options = array();
  $file_entity = $file instanceof File ? $file : File::load($file->fid);
  $url = file_create_url($file_entity
    ->getFileUri());
  $mime_type = $file
    ->getMimeType();

  // Set options as per anchor format described at
  // http://microformats.org/wiki/file-format-examples
  $options['attributes']['type'] = $mime_type . '; length=' . $file
    ->getSize();

  // Use the description as the link text if available.
  if (empty($variables['description'])) {
    $link_text = $file_entity
      ->getFilename();
  }
  else {
    $link_text = $variables['description'];
    $options['attributes']['title'] = $file_entity
      ->getFilename();
  }

  // Classes to add to the file field for icons.
  $classes = array(
    'file',
    // Add a specific class for each and every mime type.
    'file--mime-' . strtr($mime_type, array(
      '/' => '-',
      '.' => '-',
    )),
    // Add a more general class for groups of well known mime types.
    'file--' . file_icon_class($mime_type),
  );

  // Set file classes to the options array.
  $variables['attributes'] = new Attribute($variables['attributes']);
  $variables['attributes']
    ->addClass($classes);
  $variables['link'] = \Drupal::l($link_text, Url::fromUri($url, $options));
}

/**
 * Gets a class for the icon for a MIME type.
 *
 * @param string $mime_type
 *   A MIME type.
 *
 * @return string
 *   A class associated with the file.
 */
function file_icon_class($mime_type) {

  // Search for a group with the files MIME type.
  $generic_mime = (string) file_icon_map($mime_type);
  if (!empty($generic_mime)) {
    return $generic_mime;
  }

  // Use generic icons for each category that provides such icons.
  foreach (array(
    'audio',
    'image',
    'text',
    'video',
  ) as $category) {
    if (strpos($mime_type, $category) === 0) {
      return $category;
    }
  }

  // If there's no generic icon for the type the general class.
  return 'general';
}

/**
 * Determines the generic icon MIME package based on a file's MIME type.
 *
 * @param string $mime_type
 *   A MIME type.
 *
 * @return string|FALSE
 *   The generic icon MIME package expected for this file.
 */
function file_icon_map($mime_type) {
  switch ($mime_type) {

    // Word document types.
    case 'application/msword':
    case 'application/vnd.ms-word.document.macroEnabled.12':
    case 'application/vnd.oasis.opendocument.text':
    case 'application/vnd.oasis.opendocument.text-template':
    case 'application/vnd.oasis.opendocument.text-master':
    case 'application/vnd.oasis.opendocument.text-web':
    case 'application/vnd.openxmlformats-officedocument.wordprocessingml.document':
    case 'application/vnd.stardivision.writer':
    case 'application/vnd.sun.xml.writer':
    case 'application/vnd.sun.xml.writer.template':
    case 'application/vnd.sun.xml.writer.global':
    case 'application/vnd.wordperfect':
    case 'application/x-abiword':
    case 'application/x-applix-word':
    case 'application/x-kword':
    case 'application/x-kword-crypt':
      return 'x-office-document';

    // Spreadsheet document types.
    case 'application/vnd.ms-excel':
    case 'application/vnd.ms-excel.sheet.macroEnabled.12':
    case 'application/vnd.oasis.opendocument.spreadsheet':
    case 'application/vnd.oasis.opendocument.spreadsheet-template':
    case 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet':
    case 'application/vnd.stardivision.calc':
    case 'application/vnd.sun.xml.calc':
    case 'application/vnd.sun.xml.calc.template':
    case 'application/vnd.lotus-1-2-3':
    case 'application/x-applix-spreadsheet':
    case 'application/x-gnumeric':
    case 'application/x-kspread':
    case 'application/x-kspread-crypt':
      return 'x-office-spreadsheet';

    // Presentation document types.
    case 'application/vnd.ms-powerpoint':
    case 'application/vnd.ms-powerpoint.presentation.macroEnabled.12':
    case 'application/vnd.oasis.opendocument.presentation':
    case 'application/vnd.oasis.opendocument.presentation-template':
    case 'application/vnd.openxmlformats-officedocument.presentationml.presentation':
    case 'application/vnd.stardivision.impress':
    case 'application/vnd.sun.xml.impress':
    case 'application/vnd.sun.xml.impress.template':
    case 'application/x-kpresenter':
      return 'x-office-presentation';

    // Compressed archive types.
    case 'application/zip':
    case 'application/x-zip':
    case 'application/stuffit':
    case 'application/x-stuffit':
    case 'application/x-7z-compressed':
    case 'application/x-ace':
    case 'application/x-arj':
    case 'application/x-bzip':
    case 'application/x-bzip-compressed-tar':
    case 'application/x-compress':
    case 'application/x-compressed-tar':
    case 'application/x-cpio-compressed':
    case 'application/x-deb':
    case 'application/x-gzip':
    case 'application/x-java-archive':
    case 'application/x-lha':
    case 'application/x-lhz':
    case 'application/x-lzop':
    case 'application/x-rar':
    case 'application/x-rpm':
    case 'application/x-tzo':
    case 'application/x-tar':
    case 'application/x-tarz':
    case 'application/x-tgz':
      return 'package-x-generic';

    // Script file types.
    case 'application/ecmascript':
    case 'application/javascript':
    case 'application/mathematica':
    case 'application/vnd.mozilla.xul+xml':
    case 'application/x-asp':
    case 'application/x-awk':
    case 'application/x-cgi':
    case 'application/x-csh':
    case 'application/x-m4':
    case 'application/x-perl':
    case 'application/x-php':
    case 'application/x-ruby':
    case 'application/x-shellscript':
    case 'text/vnd.wap.wmlscript':
    case 'text/x-emacs-lisp':
    case 'text/x-haskell':
    case 'text/x-literate-haskell':
    case 'text/x-lua':
    case 'text/x-makefile':
    case 'text/x-matlab':
    case 'text/x-python':
    case 'text/x-sql':
    case 'text/x-tcl':
      return 'text-x-script';

    // HTML aliases.
    case 'application/xhtml+xml':
      return 'text-html';

    // Executable types.
    case 'application/x-macbinary':
    case 'application/x-ms-dos-executable':
    case 'application/x-pef-executable':
      return 'application-x-executable';

    // Acrobat types
    case 'application/pdf':
    case 'application/x-pdf':
    case 'applications/vnd.pdf':
    case 'text/pdf':
    case 'text/x-pdf':
      return 'application-pdf';
    default:
      return FALSE;
  }
}

/**
 * Retrieves a list of references to a file.
 *
 * @param \Drupal\file\FileInterface $file
 *   A file entity.
 * @param \Drupal\Core\Field\FieldDefinitionInterface $field
 *   (optional) A field definition to be used for this check. If given, limits the
 *   reference check to the given field.
 * @param int $age
 *   (optional) A constant that specifies which references to count. Use
 *   EntityStorageInterface::FIELD_LOAD_REVISION to retrieve all
 *   references within all revisions or
 *   EntityStorageInterface::FIELD_LOAD_CURRENT to retrieve references
 *   only in the current revisions.
 * @param string $field_type
 *   (optional) The name of a field type. If given, limits the reference check
 *   to fields of the given type. If both $field and $field_type is given but
 *   $field is not the same type as $field_type, an empty array will be
 *   returned.
 *
 * @return array
 *   A multidimensional array. The keys are field_name, entity_type,
 *   entity_id and the value is an entity referencing this file.
 *
 * @ingroup file
 */
function file_get_file_references(FileInterface $file, FieldDefinitionInterface $field = NULL, $age = EntityStorageInterface::FIELD_LOAD_REVISION, $field_type = 'file') {
  $references =& drupal_static(__FUNCTION__, array());
  $field_columns =& drupal_static(__FUNCTION__ . ':field_columns', array());

  // Fill the static cache, disregard $field and $field_type for now.
  if (!isset($references[$file
    ->id()][$age])) {
    $references[$file
      ->id()][$age] = array();
    $usage_list = \Drupal::service('file.usage')
      ->listUsage($file);
    $file_usage_list = isset($usage_list['file']) ? $usage_list['file'] : array();
    foreach ($file_usage_list as $entity_type_id => $entity_ids) {
      $entities = entity_load_multiple($entity_type_id, array_keys($entity_ids));
      foreach ($entities as $entity) {
        $bundle = $entity
          ->bundle();

        // We need to find file fields for this entity type and bundle.
        if (!isset($file_fields[$entity_type_id][$bundle])) {
          $file_fields[$entity_type_id][$bundle] = array();

          // This contains the possible field names.
          foreach ($entity
            ->getFieldDefinitions() as $field_name => $field_definition) {

            // If this is the first time this field type is seen, check
            // whether it references files.
            if (!isset($field_columns[$field_definition
              ->getType()])) {
              $field_columns[$field_definition
                ->getType()] = file_field_find_file_reference_column($field_definition);
            }

            // If the field type does reference files then record it.
            if ($field_columns[$field_definition
              ->getType()]) {
              $file_fields[$entity_type_id][$bundle][$field_name] = $field_columns[$field_definition
                ->getType()];
            }
          }
        }
        foreach ($file_fields[$entity_type_id][$bundle] as $field_name => $field_column) {

          // Iterate over the field items to find the referenced file and field
          // name. This will fail if the usage checked is in a non-current
          // revision because field items are from the current
          // revision.
          // We also iterate over all translations because a file can be linked
          // to a language other than the default.
          foreach ($entity
            ->getTranslationLanguages() as $langcode => $language) {
            foreach ($entity
              ->getTranslation($langcode)
              ->get($field_name) as $item) {
              if ($file
                ->id() == $item->{$field_column}) {
                $references[$file
                  ->id()][$age][$field_name][$entity_type_id][$entity
                  ->id()] = $entity;
                break;
              }
            }
          }
        }
      }
    }
  }
  $return = $references[$file
    ->id()][$age];

  // Filter the static cache down to the requested entries. The usual static
  // cache is very small so this will be very fast.
  if ($field || $field_type) {
    foreach ($return as $field_name => $data) {
      foreach (array_keys($data) as $entity_type_id) {
        $field_storage_definitions = \Drupal::entityManager()
          ->getFieldStorageDefinitions($entity_type_id);
        $current_field = $field_storage_definitions[$field_name];
        if ($field_type && $current_field
          ->getType() != $field_type || $field && $field
          ->uuid() != $current_field
          ->uuid()) {
          unset($return[$field_name][$entity_type_id]);
        }
      }
    }
  }
  return $return;
}

/**
 * Formats human-readable version of file status.
 *
 * @param int $choice
 *   integer Status code.
 * @return string
 *   string Text-represented file status.
 */
function _views_file_status($choice = NULL) {
  $status = array(
    0 => t('Temporary'),
    FILE_STATUS_PERMANENT => t('Permanent'),
  );
  if (isset($choice)) {
    return isset($status[$choice]) ? $status[$choice] : t('Unknown');
  }
  return $status;
}

Functions

Namesort descending Description
file_copy Copies a file to a new location and adds a file record to the database.
file_cron Implements hook_cron().
file_file_download Implements hook_file_download().
file_file_predelete Implements hook_ENTITY_TYPE_predelete() for file entities.
file_get_content_headers Examines a file entity and returns appropriate content headers for download.
file_get_file_references Retrieves a list of references to a file.
file_help Implements hook_help().
file_icon_class Gets a class for the icon for a MIME type.
file_icon_map Determines the generic icon MIME package based on a file's MIME type.
file_load Deprecated Loads a single file entity from the database.
file_load_multiple Deprecated Loads file entities from the database.
file_managed_file_save_upload Saves any files that have been uploaded into a managed_file element.
file_managed_file_submit Form submission handler for upload / remove buttons of managed_file elements.
file_move Moves a file to a new location and update the file's database entry.
file_progress_implementation Determines the preferred upload progress implementation.
file_save_data Saves a file to the specified destination and creates a database entry.
file_save_upload Saves file uploads to a new location.
file_theme Implements hook_theme().
file_tokens Implements hook_tokens().
file_token_info Implements hook_token_info().
file_validate Checks that a file meets the criteria specified by the validators.
file_validate_extensions Checks that the filename ends with an allowed extension.
file_validate_image_resolution Verifies that image dimensions are within the specified maximum and minimum.
file_validate_is_image Checks that the file is recognized as a valid image.
file_validate_name_length Checks for files with names longer than can be stored in the database.
file_validate_size Checks that the file's size is below certain limits.
template_preprocess_file_link Prepares variables for file link templates.
template_preprocess_file_managed_file Prepares variables for file form widget templates.
_views_file_status Formats human-readable version of file status.