Skip to content
Snippets Groups Projects
Select Git revision
  • a0a530fd4f3e006995b7eb7f8e4f63fa405c0965
  • 11.x default protected
  • 10.6.x protected
  • 10.5.x protected
  • 11.2.x protected
  • 11.1.x protected
  • 10.4.x protected
  • 11.0.x protected
  • 10.3.x protected
  • 7.x protected
  • 10.2.x protected
  • 10.1.x protected
  • 9.5.x protected
  • 10.0.x protected
  • 9.4.x protected
  • 9.3.x protected
  • 9.2.x protected
  • 9.1.x protected
  • 8.9.x protected
  • 9.0.x protected
  • 8.8.x protected
  • 10.5.1 protected
  • 11.2.2 protected
  • 11.2.1 protected
  • 11.2.0 protected
  • 10.5.0 protected
  • 11.2.0-rc2 protected
  • 10.5.0-rc1 protected
  • 11.2.0-rc1 protected
  • 10.4.8 protected
  • 11.1.8 protected
  • 10.5.0-beta1 protected
  • 11.2.0-beta1 protected
  • 11.2.0-alpha1 protected
  • 10.4.7 protected
  • 11.1.7 protected
  • 10.4.6 protected
  • 11.1.6 protected
  • 10.3.14 protected
  • 10.4.5 protected
  • 11.0.13 protected
41 results

ConfigFactory.php

Blame
  • Code owners
    Assign users and groups as approvers for specific file changes. Learn more.
    file.module 61.53 KiB
    <?php
    
    /**
     * @file
     * Defines a "managed_file" Form API field and a "file" field for Field module.
     */
    
    use Drupal\Component\Utility\SafeMarkup;
    use Drupal\Component\Utility\String;
    use Drupal\Core\Field\FieldDefinitionInterface;
    use Drupal\Core\Form\FormStateInterface;
    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;
    use Drupal\file\FileUsage\FileUsageInterface;
    
    // 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::url('help.page', array('name' => 'field_ui')), '!file_documentation' => 'https://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::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 $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 $fid
     *   A file ID.
     * @param $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 $destination
     *   A string containing the destination that $source should be copied to.
     *   This must be a stream wrapper URI.
     * @param $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
     *   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://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());
          }
        }
        // If we are renaming around an existing file (rather than a directory),
        // use its basename for the filename.
        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 $destination
     *   A string containing the destination that $source should be moved to.
     *   This must be a stream wrapper URI.
     * @param $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();
          }
        }
        // If we are renaming around an existing file (rather than a directory),
        // use its basename for the filename.
        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 $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
     *   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
     *   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 $extensions
     *   A string with a space separated list of allowed extensions.
     *
     * @return
     *   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 $file_limit
     *   An integer specifying the maximum file size in bytes. Zero indicates that
     *   no limit should be enforced.
     * @param $user_limit
     *   An integer specifying the maximum number of bytes the user is allowed.
     *   Zero indicates that no limit should be enforced.
     *
     * @return
     *   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
     *   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 a 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 $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 $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 $data
     *   A string containing the contents of the file.
     * @param $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 $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://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());
          }
        }
        // If we are renaming around an existing file (rather than a directory),
        // use its basename for the filename.
        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
     *   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, 'icon_directory' => NULL, 'description' => NULL, 'attributes' => array()),
        ),
        'file_managed_file' => array(
          'render element' => 'element',
        ),
    
        // From file.field.inc.
        'file_widget' => array(
          'render element' => 'element',
          'file' => '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 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 file_cron()
     */
    function file_cron() {
      $age = \Drupal::config('system.file')->get('temporary_maximum_age');
    
      // 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_load_multiple($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 $form_field_name
     *   A string that is the associative array key of the upload form element in
     *   the form array.
     * @param \Drupal\Core\Form\FormStateInterface $form_state
     *   The current state of the form.
     * @param $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 $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 $delta
     *   Delta of the file to save or NULL to save all files. Defaults to NULL.
     * @param $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
     *   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'] = file_get_mimetype($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 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 = t('The specified file %name could not be uploaded.', array('%name' => $file->getFilename()));
          if (count($errors) > 1) {
            $item_list = array(
              '#theme' => 'item_list',
              '#items' => $errors,
            );
            $message = SafeMarkup::set($message . drupal_render($item_list));
          }
          else {
            $message = SafeMarkup::set($message . ' ' . SafeMarkup::escape(array_pop($errors)));
          }
          drupal_set_message($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->uri = $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->filename, '%destination' => $file->uri));
          $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://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
     *   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(), array $options = array()) {
      $token_service = \Drupal::token();
    
      $url_options = array('absolute' => TRUE);
      if (isset($options['langcode'])) {
        $url_options['language'] = language_load($options['langcode']);
        $langcode = $options['langcode'];
      }
      else {
        $langcode = NULL;
      }
      $sanitize = !empty($options['sanitize']);
    
      $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] = $sanitize ? String::checkPlain($file->getFilename()) : $file->getFilename();
              break;
    
            case 'path':
              $replacements[$original] = $sanitize ? String::checkPlain($file->getFileUri()) : $file->getFileUri();
              break;
    
            case 'mime':
              $replacements[$original] = $sanitize ? String::checkPlain($file->getMimeType()) : $file->getMimeType();
              break;
    
            case 'size':
              $replacements[$original] = format_size($file->getSize());
              break;
    
            case 'url':
              $replacements[$original] = $sanitize ? String::checkPlain(file_create_url($file->getFileUri())) : file_create_url($file->getFileUri());
              break;
    
            // These tokens are default variations on the chained tokens handled below.
            case 'created':
              $replacements[$original] = format_date($file->getCreatedTime(), 'medium', '', NULL, $langcode);
              break;
    
            case 'changed':
              $replacements[$original] = format_date($file->getChangedTime(), 'medium', '', NULL, $langcode);
              break;
    
            case 'owner':
              $name = $file->getOwner()->label();
              $replacements[$original] = $sanitize ? String::checkPlain($name) : $name;
              break;
          }
        }
    
        if ($date_tokens = $token_service->findWithPrefix($tokens, 'created')) {
          $replacements += $token_service->generate('date', $date_tokens, array('date' => $file->getCreatedTime()), $options);
        }
    
        if ($date_tokens = $token_service->findWithPrefix($tokens, 'changed')) {
          $replacements += $token_service->generate('date', $date_tokens, array('date' => $file->getChangedTime()), $options);
        }
    
        if (($owner_tokens = $token_service->findWithPrefix($tokens, 'owner')) && $file->getOwner()) {
          $replacements += $token_service->generate('user', $owner_tokens, array('user' => $file->getOwner()), $options);
        }
      }
    
      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 $element
     *   The FAPI element whose values are being saved.
     * @param \Drupal\Core\Form\FormStateInterface $form_state
     *   The current state of the form.
     *
     * @return
     *   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->setErrorByName($upload_name, 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->setErrorByName($upload_name, 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'];
      }
      $variables['attributes']['class'][] = 'form-managed-file';
    }
    
    /**
     * 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(
        'attributes' => $variables['attributes'],
      );
      $icon_directory = $variables['icon_directory'];
    
      $url = file_create_url($file->getFileUri());
      $file_entity = ($file instanceof File) ? $file : file_load($file->fid);
    
      // Human-readable names, for use as text-alternatives to icons.
      $mime_name = array(
        'application/msword' => t('Microsoft Office document icon'),
        'application/vnd.ms-excel' => t('Office spreadsheet icon'),
        'application/vnd.ms-powerpoint' => t('Office presentation icon'),
        'application/pdf' => t('PDF icon'),
        'video/quicktime' => t('Movie icon'),
        'audio/mpeg' => t('Audio icon'),
        'audio/wav' => t('Audio icon'),
        'image/jpeg' => t('Image icon'),
        'image/png' => t('Image icon'),
        'image/gif' => t('Image icon'),
        'application/zip' => t('Package icon'),
        'text/html' => t('HTML icon'),
        'text/plain' => t('Plain text icon'),
        'application/octet-stream' => t('Binary Data'),
      );
    
      $variables['icon'] = array(
        '#theme' => 'image__file_icon',
        '#uri' => file_icon_url($file_entity, $icon_directory),
        '#alt' => (!empty($mime_name[$file->getMimeType()])) ? $mime_name[$file->getMimeType()] : t('File'),
        '#title' => String::checkPlain($file_entity->getFilename()),
        '#attributes' => array('class' => array('file-icon')),
      );
    
      // Set options as per anchor format described at
      // http://microformats.org/wiki/file-format-examples
      $options['attributes']['type'] = $file->getMimeType() . '; 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'] = String::checkPlain($file_entity->getFilename());
      }
    
      $variables['link'] = \Drupal::l($link_text, Url::fromUri($url, $options));
      $variables['attributes'] = array('class' => array('file'));
    }
    
    /**
     * Creates a URL to the icon for a file entity.
     *
     * @param \Drupal\file\FileInterface $file
     *   A file entity.
     * @param $icon_directory
     *   (optional) A path to a directory of icons to be used for files. Defaults to
     *   the value of the "icon.directory" variable.
     *
     * @return
     *   A URL string to the icon, or FALSE if an appropriate icon cannot be found.
     */
    function file_icon_url(FileInterface $file, $icon_directory = NULL) {
      if ($icon_path = file_icon_path($file, $icon_directory)) {
        return base_path() . $icon_path;
      }
      return FALSE;
    }
    
    /**
     * Creates a path to the icon for a file entity.
     *
     * @param \Drupal\file\FileInterface $file
     *   A file entity.
     * @param $icon_directory
     *   (optional) A path to a directory of icons to be used for files. Defaults to
     *   the value of the "icon.directory" variable.
     *
     * @return
     *   A string to the icon as a local path, or FALSE if an appropriate icon could
     *   not be found.
     */
    function file_icon_path(FileInterface $file, $icon_directory = NULL) {
      // Use the default set of icons if none specified.
      if (!isset($icon_directory)) {
        $icon_directory = \Drupal::config('file.settings')->get('icon.directory');
      }
    
      // If there's an icon matching the exact mimetype, go for it.
      $dashed_mime = strtr($file->getMimeType(), array('/' => '-'));
      $icon_path = $icon_directory . '/' . $dashed_mime . '.png';
      if (file_exists($icon_path)) {
        return $icon_path;
      }
    
      // For a few mimetypes, we can "manually" map to a generic icon.
      $generic_mime = (string) file_icon_map($file);
      $icon_path = $icon_directory . '/' . $generic_mime . '.png';
      if ($generic_mime && file_exists($icon_path)) {
        return $icon_path;
      }
    
      // Use generic icons for each category that provides such icons.
      foreach (array('audio', 'image', 'text', 'video') as $category) {
        if (strpos($file->getMimeType(), $category . '/') === 0) {
          $icon_path = $icon_directory . '/' . $category . '-x-generic.png';
          if (file_exists($icon_path)) {
            return $icon_path;
          }
        }
      }
    
      // Try application-octet-stream as last fallback.
      $icon_path = $icon_directory . '/application-octet-stream.png';
      if (file_exists($icon_path)) {
        return $icon_path;
      }
    
      // No icon can be found.
      return FALSE;
    }
    
    /**
     * Determines the generic icon MIME package based on a file's MIME type.
     *
     * @param \Drupal\file\FileInterface $file
     *   A file entity.
     *
     * @return
     *   The generic icon MIME package expected for this file.
     */
    function file_icon_map(FileInterface $file) {
      switch ($file->getMimeType()) {
        // 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';
    
        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 $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 $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
     *   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;
    }