1995 lines
75 KiB
Plaintext
1995 lines
75 KiB
Plaintext
<?php
|
|
|
|
/**
|
|
* @file
|
|
* Defines a "managed_file" Form API field and a "file" field for Field module.
|
|
*/
|
|
|
|
use Drupal\Core\Field\FieldDefinitionInterface;
|
|
use Drupal\Core\Render\Element;
|
|
use Drupal\file\Entity\File;
|
|
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;
|
|
use Symfony\Component\HttpFoundation\Request;
|
|
|
|
// Load all Field module hooks for File.
|
|
require_once __DIR__ . '/file.field.inc';
|
|
|
|
/**
|
|
* Implements hook_help().
|
|
*/
|
|
function file_help($route_name, Request $request) {
|
|
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;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Implements hook_element_info().
|
|
*
|
|
* The managed file element may be used anywhere in Drupal.
|
|
*/
|
|
function file_element_info() {
|
|
$types['managed_file'] = array(
|
|
'#input' => TRUE,
|
|
'#process' => array('file_managed_file_process'),
|
|
'#value_callback' => 'file_managed_file_value',
|
|
'#element_validate' => array('file_managed_file_validate'),
|
|
'#pre_render' => array('file_managed_file_pre_render'),
|
|
'#theme' => 'file_managed_file',
|
|
'#theme_wrappers' => array('form_element'),
|
|
'#progress_indicator' => 'throbber',
|
|
'#progress_message' => NULL,
|
|
'#upload_validators' => array(),
|
|
'#upload_location' => NULL,
|
|
'#size' => 22,
|
|
'#multiple' => FALSE,
|
|
'#extended' => FALSE,
|
|
'#attached' => array(
|
|
'library' => array('file/drupal.file'),
|
|
),
|
|
);
|
|
return $types;
|
|
}
|
|
|
|
/**
|
|
* 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.
|
|
*
|
|
* @see hook_file_load()
|
|
* @see file_load()
|
|
* @see entity_load()
|
|
* @see \Drupal\Core\Entity\Query\EntityQueryInterface
|
|
*/
|
|
function file_load_multiple(array $fids = NULL, $reset = FALSE) {
|
|
return entity_load_multiple('file', $fids, $reset);
|
|
}
|
|
|
|
/**
|
|
* 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.
|
|
*
|
|
* @see hook_file_load()
|
|
* @see file_load_multiple()
|
|
*/
|
|
function file_load($fid, $reset = FALSE) {
|
|
return entity_load('file', $fid, $reset);
|
|
}
|
|
|
|
/**
|
|
* Returns the file usage service.
|
|
*
|
|
* @deprecated in Drupal 8.x-dev, will be removed before Drupal 8.0.
|
|
* Use \Drupal::service('file.usage').
|
|
*
|
|
* @return \Drupal\file\FileUsage\FileUsageInterface.
|
|
*/
|
|
function file_usage() {
|
|
return \Drupal::service('file.usage');
|
|
}
|
|
|
|
/**
|
|
* 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\File $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(File $source, $destination = NULL, $replace = FILE_EXISTS_RENAME) {
|
|
if (!file_valid_uri($destination)) {
|
|
if (($realpath = drupal_realpath($source->getFileUri())) !== FALSE) {
|
|
watchdog('file', '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 {
|
|
watchdog('file', '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\File $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\File
|
|
* Resulting file entity for success, or FALSE in the event of an error.
|
|
*
|
|
* @see file_unmanaged_move()
|
|
* @see hook_file_move()
|
|
*/
|
|
function file_move(File $source, $destination = NULL, $replace = FILE_EXISTS_RENAME) {
|
|
if (!file_valid_uri($destination)) {
|
|
if (($realpath = drupal_realpath($source->getFileUri())) !== FALSE) {
|
|
watchdog('file', '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 {
|
|
watchdog('file', '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\File $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(File $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\File $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(File $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\File $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(File $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\File $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(File $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 by Image::getInfo() as an image.
|
|
*
|
|
* @param \Drupal\file\File $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(File $file) {
|
|
$errors = array();
|
|
|
|
$image = \Drupal::service('image.factory')->get($file->getFileUri());
|
|
if (!$image->isSupported()) {
|
|
$extensions = array();
|
|
foreach ($image->getToolkit()->supportedTypes() as $image_type) {
|
|
$extensions[] = Unicode::strtoupper(image_type_to_extension($image_type));
|
|
}
|
|
$errors[] = t('Image type not supported. Allowed types: @types.', array('@types' => implode(', ', $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\File $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(File $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->isSupported()) {
|
|
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.
|
|
$image = $image_factory->get($file->getFileUri());
|
|
if ($image->isExisting()) {
|
|
$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 is too large; the maximum dimensions are %dimensions pixels.', array('%dimensions' => $maximum_dimensions));
|
|
}
|
|
}
|
|
}
|
|
|
|
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)) {
|
|
watchdog('file', '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\File $file
|
|
* A file entity.
|
|
*
|
|
* @return
|
|
* An associative array of headers, as expected by
|
|
* \Symfony\Component\HttpFoundation\StreamedResponse.
|
|
*/
|
|
function file_get_content_headers(File $file) {
|
|
$type = mime_header_encode($file->getMimeType());
|
|
|
|
return array(
|
|
'Content-Type' => $type,
|
|
'Content-Length' => $file->getSize(),
|
|
'Cache-Control' => 'private',
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Implements hook_theme().
|
|
*/
|
|
function file_theme() {
|
|
return array(
|
|
// file.module.
|
|
'file_link' => array(
|
|
'variables' => array('file' => NULL, 'icon_directory' => NULL, 'description' => NULL, 'attributes' => array()),
|
|
),
|
|
'file_icon' => array(
|
|
'variables' => array('file' => NULL, 'icon_directory' => NULL),
|
|
),
|
|
'file_managed_file' => array(
|
|
'render element' => 'element',
|
|
),
|
|
|
|
// file.field.inc.
|
|
'file_widget' => array(
|
|
'render element' => 'element',
|
|
),
|
|
'file_widget_multiple' => array(
|
|
'render element' => 'element',
|
|
),
|
|
'file_formatter_table' => array(
|
|
'variables' => array('items' => NULL),
|
|
),
|
|
'file_upload_help' => array(
|
|
'variables' => array('description' => NULL, 'upload_validators' => NULL, 'cardinality' => NULL),
|
|
),
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Implements hook_file_download().
|
|
*
|
|
* This function takes an extra parameter $field_type so that it may
|
|
* be re-used by other File-like modules, such as Image.
|
|
*/
|
|
function file_file_download($uri, $field_type = 'file') {
|
|
$user = \Drupal::currentUser();
|
|
|
|
// 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, $field_type);
|
|
|
|
// 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() != $user->id())) {
|
|
return;
|
|
}
|
|
|
|
// Default to allow access.
|
|
$denied = FALSE;
|
|
// Loop through all references of this file. If a reference explicitly allows
|
|
// access to the field to which this file belongs, no further checks are done
|
|
// and download access is granted. If a reference denies access, eventually
|
|
// existing additional references are checked. If all references were checked
|
|
// and no reference denied access, access is granted as well. If at least one
|
|
// reference denied access, access is denied.
|
|
foreach ($references as $field_name => $field_references) {
|
|
foreach ($field_references as $entity_type => $entities) {
|
|
$field_storage_definitions = \Drupal::entityManager()->getFieldStorageDefinitions($entity_type);
|
|
$field = $field_storage_definitions[$field_name];
|
|
foreach ($entities as $entity) {
|
|
// Check if access to this field is not disallowed.
|
|
if (!$entity->get($field_name)->access('view')) {
|
|
$denied = TRUE;
|
|
continue;
|
|
}
|
|
|
|
// Invoke hook and collect grants/denies for download access.
|
|
// Default to FALSE and let entities overrule this ruling.
|
|
$grants = array('system' => FALSE);
|
|
foreach (\Drupal::moduleHandler()->getImplementations('file_download_access') as $module) {
|
|
$grants = array_merge($grants, array($module => \Drupal::moduleHandler()->invoke($module, 'file_download_access', array($field, $entity, $file))));
|
|
}
|
|
// Allow other modules to alter the returned grants/denies.
|
|
$context = array(
|
|
'entity' => $entity,
|
|
'field' => $field,
|
|
'file' => $file,
|
|
);
|
|
\Drupal::moduleHandler()->alter('file_download_access', $grants, $context);
|
|
|
|
if (in_array(TRUE, $grants)) {
|
|
// If TRUE is returned, access is granted and no further checks are
|
|
// necessary.
|
|
$denied = FALSE;
|
|
break 3;
|
|
}
|
|
|
|
if (in_array(FALSE, $grants)) {
|
|
// If an implementation returns FALSE, access to this entity is denied
|
|
// but the file could belong to another entity to which the user might
|
|
// have access. Continue with these.
|
|
$denied = TRUE;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Access specifically denied.
|
|
if ($denied) {
|
|
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 {
|
|
watchdog('file system', 'Could not delete temporary file "%path" during garbage collection', array('%path' => $file->getFileUri()), WATCHDOG_ERROR);
|
|
}
|
|
}
|
|
else {
|
|
watchdog('file system', '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))), WATCHDOG_INFO);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 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 array $form_state
|
|
* An associative array containing 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 .= drupal_render($item_list);
|
|
}
|
|
else {
|
|
$message .= ' ' . 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');
|
|
watchdog('file', '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_file_predelete().
|
|
*/
|
|
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 ? check_plain($file->getFilename()) : $file->getFilename();
|
|
break;
|
|
|
|
case 'path':
|
|
$replacements[$original] = $sanitize ? check_plain($file->getFileUri()) : $file->getFileUri();
|
|
break;
|
|
|
|
case 'mime':
|
|
$replacements[$original] = $sanitize ? check_plain($file->getMimeType()) : $file->getMimeType();
|
|
break;
|
|
|
|
case 'size':
|
|
$replacements[$original] = format_size($file->getSize());
|
|
break;
|
|
|
|
case 'url':
|
|
$replacements[$original] = $sanitize ? check_plain(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 ? check_plain($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,
|
|
),
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Render API callback: Expands the managed_file element type.
|
|
*
|
|
* Expands the file type to include Upload and Remove buttons, as well as
|
|
* support for a default value.
|
|
*
|
|
* This function is assigned as a #process callback in file_element_info().
|
|
*/
|
|
function file_managed_file_process($element, &$form_state, $form) {
|
|
// Append the '-upload' to the #id so the field label's 'for' attribute
|
|
// corresponds with the file element.
|
|
$element['#id'] .= '-upload';
|
|
|
|
// This is used sometimes so let's implode it just once.
|
|
$parents_prefix = implode('_', $element['#parents']);
|
|
|
|
$fids = isset($element['#value']['fids']) ? $element['#value']['fids'] : array();
|
|
|
|
// Set some default element properties.
|
|
$element['#progress_indicator'] = empty($element['#progress_indicator']) ? 'none' : $element['#progress_indicator'];
|
|
$element['#files'] = !empty($fids) ? file_load_multiple($fids) : FALSE;
|
|
$element['#tree'] = TRUE;
|
|
|
|
$ajax_settings = array(
|
|
'path' => 'file/ajax',
|
|
'options' => array(
|
|
'query' => array(
|
|
'element_parents' => implode('/', $element['#array_parents']),
|
|
'form_build_id' => $form['form_build_id']['#value'],
|
|
),
|
|
),
|
|
'wrapper' => $element['#id'] . '-ajax-wrapper',
|
|
'effect' => 'fade',
|
|
'progress' => array(
|
|
'type' => $element['#progress_indicator'],
|
|
'message' => $element['#progress_message'],
|
|
),
|
|
);
|
|
|
|
// Set up the buttons first since we need to check if they were clicked.
|
|
$element['upload_button'] = array(
|
|
'#name' => $parents_prefix . '_upload_button',
|
|
'#type' => 'submit',
|
|
'#value' => t('Upload'),
|
|
'#attributes' => array('class' => array('js-hide')),
|
|
'#validate' => array(),
|
|
'#submit' => array('file_managed_file_submit'),
|
|
'#limit_validation_errors' => array($element['#parents']),
|
|
'#ajax' => $ajax_settings,
|
|
'#weight' => -5,
|
|
);
|
|
|
|
// Force the progress indicator for the remove button to be either 'none' or
|
|
// 'throbber', even if the upload button is using something else.
|
|
$ajax_settings['progress']['type'] = ($element['#progress_indicator'] == 'none') ? 'none' : 'throbber';
|
|
$ajax_settings['progress']['message'] = NULL;
|
|
$ajax_settings['effect'] = 'none';
|
|
$element['remove_button'] = array(
|
|
'#name' => $parents_prefix . '_remove_button',
|
|
'#type' => 'submit',
|
|
'#value' => $element['#multiple'] ? t('Remove selected') : t('Remove'),
|
|
'#validate' => array(),
|
|
'#submit' => array('file_managed_file_submit'),
|
|
'#limit_validation_errors' => array($element['#parents']),
|
|
'#ajax' => $ajax_settings,
|
|
'#weight' => 1,
|
|
);
|
|
|
|
$element['fids'] = array(
|
|
'#type' => 'hidden',
|
|
'#value' => $fids,
|
|
);
|
|
|
|
// Add progress bar support to the upload if possible.
|
|
if ($element['#progress_indicator'] == 'bar' && $implementation = file_progress_implementation()) {
|
|
$upload_progress_key = mt_rand();
|
|
|
|
if ($implementation == 'uploadprogress') {
|
|
$element['UPLOAD_IDENTIFIER'] = array(
|
|
'#type' => 'hidden',
|
|
'#value' => $upload_progress_key,
|
|
'#attributes' => array('class' => array('file-progress')),
|
|
// Uploadprogress extension requires this field to be at the top of the
|
|
// form.
|
|
'#weight' => -20,
|
|
);
|
|
}
|
|
elseif ($implementation == 'apc') {
|
|
$element['APC_UPLOAD_PROGRESS'] = array(
|
|
'#type' => 'hidden',
|
|
'#value' => $upload_progress_key,
|
|
'#attributes' => array('class' => array('file-progress')),
|
|
// Uploadprogress extension requires this field to be at the top of the
|
|
// form.
|
|
'#weight' => -20,
|
|
);
|
|
}
|
|
|
|
// Add the upload progress callback.
|
|
$element['upload_button']['#ajax']['progress']['path'] = 'file/progress/' . $upload_progress_key;
|
|
}
|
|
|
|
// The file upload field itself.
|
|
$element['upload'] = array(
|
|
'#name' => 'files[' . $parents_prefix . ']',
|
|
'#type' => 'file',
|
|
'#title' => t('Choose a file'),
|
|
'#title_display' => 'invisible',
|
|
'#size' => $element['#size'],
|
|
'#multiple' => $element['#multiple'],
|
|
'#theme_wrappers' => array(),
|
|
'#weight' => -10,
|
|
);
|
|
|
|
if (!empty($fids) && $element['#files']) {
|
|
foreach ($element['#files'] as $delta => $file) {
|
|
$file_link = array(
|
|
'#theme' => 'file_link',
|
|
'#file' => $file,
|
|
);
|
|
if ($element['#multiple']) {
|
|
$element['file_' . $delta]['selected'] = array(
|
|
'#type' => 'checkbox',
|
|
'#title' => drupal_render($file_link),
|
|
);
|
|
}
|
|
else {
|
|
$element['file_' . $delta]['filename'] = $file_link += array('#weight' => -10);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Add the extension list to the page as JavaScript settings.
|
|
if (isset($element['#upload_validators']['file_validate_extensions'][0])) {
|
|
$extension_list = implode(',', array_filter(explode(' ', $element['#upload_validators']['file_validate_extensions'][0])));
|
|
$element['upload']['#attached']['js'] = array(
|
|
array(
|
|
'type' => 'setting',
|
|
'data' => array('file' => array('elements' => array('#' . $element['#id'] => $extension_list)))
|
|
)
|
|
);
|
|
}
|
|
|
|
// Prefix and suffix used for Ajax replacement.
|
|
$element['#prefix'] = '<div id="' . $element['#id'] . '-ajax-wrapper">';
|
|
$element['#suffix'] = '</div>';
|
|
|
|
return $element;
|
|
}
|
|
|
|
/**
|
|
* Render API callback: Determines the value for a managed_file type element.
|
|
*
|
|
* This function is assigned as a #value_callback in file_element_info().
|
|
*/
|
|
function file_managed_file_value(&$element, $input, &$form_state) {
|
|
// Find the current value of this field.
|
|
$fids = !empty($input['fids']) ? explode(' ', $input['fids']) : array();
|
|
foreach ($fids as $key => $fid) {
|
|
$fids[$key] = (int) $fid;
|
|
}
|
|
|
|
// Process any input and save new uploads.
|
|
if ($input !== FALSE) {
|
|
$input['fids'] = $fids;
|
|
$return = $input;
|
|
|
|
// Uploads take priority over all other values.
|
|
if ($files = file_managed_file_save_upload($element, $form_state)) {
|
|
if ($element['#multiple']) {
|
|
$fids = array_merge($fids, array_keys($files));
|
|
}
|
|
else {
|
|
$fids = array_keys($files);
|
|
}
|
|
}
|
|
else {
|
|
// Check for #filefield_value_callback values.
|
|
// Because FAPI does not allow multiple #value_callback values like it
|
|
// does for #element_validate and #process, this fills the missing
|
|
// functionality to allow File fields to be extended through FAPI.
|
|
if (isset($element['#file_value_callbacks'])) {
|
|
foreach ($element['#file_value_callbacks'] as $callback) {
|
|
$callback($element, $input, $form_state);
|
|
}
|
|
}
|
|
|
|
// Load files if the FIDs have changed to confirm they exist.
|
|
if (!empty($input['fids'])) {
|
|
$fids = array();
|
|
foreach ($input['fids'] as $fid) {
|
|
if ($file = file_load($fid)) {
|
|
$fids[] = $file->id();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// If there is no input, set the default value.
|
|
else {
|
|
if ($element['#extended']) {
|
|
$default_fids = isset($element['#default_value']['fids']) ? $element['#default_value']['fids'] : array();
|
|
$return = isset($element['#default_value']) ? $element['#default_value'] : array('fids' => array());
|
|
}
|
|
else {
|
|
$default_fids = isset($element['#default_value']) ? $element['#default_value'] : array();
|
|
$return = array('fids' => array());
|
|
}
|
|
|
|
// Confirm that the file exists when used as a default value.
|
|
if (!empty($default_fids)) {
|
|
$fids = array();
|
|
foreach ($default_fids as $fid) {
|
|
if ($file = file_load($fid)) {
|
|
$fids[] = $file->id();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
$return['fids'] = $fids;
|
|
return $return;
|
|
}
|
|
|
|
/**
|
|
* Render API callback: Validates the managed_file element.
|
|
*
|
|
* This function is assigned as a #element_validate callback in
|
|
* file_element_info().
|
|
*/
|
|
function file_managed_file_validate(&$element, &$form_state) {
|
|
// If referencing an existing file, only allow if there are existing
|
|
// references. This prevents unmanaged files from being deleted if this
|
|
// item were to be deleted.
|
|
$clicked_button = end($form_state['triggering_element']['#parents']);
|
|
if ($clicked_button != 'remove_button' && !empty($element['fids']['#value'])) {
|
|
$fids = $element['fids']['#value'];
|
|
foreach ($fids as $fid) {
|
|
if ($file = file_load($fid)) {
|
|
if ($file->isPermanent()) {
|
|
$references = \Drupal::service('file.usage')->listUsage($file);
|
|
if (empty($references)) {
|
|
form_error($element, $form_state, t('The file used in the !name field may not be referenced.', array('!name' => $element['#title'])));
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
form_error($element, $form_state, t('The file referenced by the !name field does not exist.', array('!name' => $element['#title'])));
|
|
}
|
|
}
|
|
}
|
|
|
|
// Check required property based on the FID.
|
|
if ($element['#required'] && empty($element['fids']['#value']) && !in_array($clicked_button, array('upload_button', 'remove_button'))) {
|
|
form_error($element['upload'], $form_state, t('!name field is required.', array('!name' => $element['#title'])));
|
|
}
|
|
|
|
// Consolidate the array value of this field to array of FIDs.
|
|
if (!$element['#extended']) {
|
|
form_set_value($element, $element['fids']['#value'], $form_state);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Form submission handler for upload / remove buttons of managed_file elements.
|
|
*
|
|
* @see file_managed_file_process()
|
|
*/
|
|
function file_managed_file_submit($form, &$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['triggering_element']['#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 file_managed_file_value() 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['values'] and $form_state['input'] to reflect
|
|
// that the file has been removed, so that the form is rebuilt correctly.
|
|
// $form_state['values'] 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.
|
|
// $form_state['input'] must be updated so that file_managed_file_value()
|
|
// has correct information during the rebuild.
|
|
form_set_value($element['fids'], implode(' ', $fids), $form_state);
|
|
NestedArray::setValue($form_state['input'], $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 setting $form_state['redirect'] to FALSE would suffice.
|
|
// However, we choose to always rebuild, to keep the form processing workflow
|
|
// consistent between the two buttons.
|
|
$form_state['rebuild'] = TRUE;
|
|
}
|
|
|
|
/**
|
|
* Saves any files that have been uploaded into a managed_file element.
|
|
*
|
|
* @param $element
|
|
* The FAPI element whose values are being saved.
|
|
* @param array $form_state
|
|
* An associative array containing 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, array &$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)) {
|
|
watchdog('file', '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_set_error($upload_name, $form_state, 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)) {
|
|
watchdog('file', 'The file upload failed. %upload', array('%upload' => $upload_name));
|
|
form_set_error($upload_name, $form_state, 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();
|
|
}
|
|
|
|
/**
|
|
* Returns HTML for a managed file element.
|
|
*
|
|
* @param $variables
|
|
* An associative array containing:
|
|
* - element: A render element representing the file.
|
|
*
|
|
* @ingroup themeable
|
|
*/
|
|
function theme_file_managed_file($variables) {
|
|
$element = $variables['element'];
|
|
|
|
$attributes = array();
|
|
if (isset($element['#id'])) {
|
|
$attributes['id'] = $element['#id'];
|
|
}
|
|
if (!empty($element['#attributes']['class'])) {
|
|
$attributes['class'] = (array) $element['#attributes']['class'];
|
|
}
|
|
$attributes['class'][] = 'form-managed-file';
|
|
|
|
// This wrapper is required to apply JS behaviors and CSS styling.
|
|
$output = '';
|
|
$output .= '<div' . new Attribute($attributes) . '>';
|
|
$output .= drupal_render_children($element);
|
|
$output .= '</div>';
|
|
return $output;
|
|
}
|
|
|
|
/**
|
|
* Render API callback: Hides display of the upload or remove controls.
|
|
*
|
|
* Upload controls are hidden when a file is already uploaded. Remove controls
|
|
* are hidden when there is no file attached. Controls are hidden here instead
|
|
* of in file_managed_file_process(), because #access for these buttons depends
|
|
* on the managed_file element's #value. See the documentation of form_builder()
|
|
* for more detailed information about the relationship between #process,
|
|
* #value, and #access.
|
|
*
|
|
* Because #access is set here, it affects display only and does not prevent
|
|
* JavaScript or other untrusted code from submitting the form as though access
|
|
* were enabled. The form processing functions for these elements should not
|
|
* assume that the buttons can't be "clicked" just because they are not
|
|
* displayed.
|
|
*
|
|
* This function is assigned as a #pre_render callback in file_element_info().
|
|
*
|
|
* @see file_managed_file_process()
|
|
*/
|
|
function file_managed_file_pre_render($element) {
|
|
// If we already have a file, we don't want to show the upload controls.
|
|
if (!empty($element['#value']['fids'])) {
|
|
if (!$element['#multiple']) {
|
|
$element['upload']['#access'] = FALSE;
|
|
$element['upload_button']['#access'] = FALSE;
|
|
}
|
|
}
|
|
// If we don't already have a file, there is nothing to remove.
|
|
else {
|
|
$element['remove_button']['#access'] = FALSE;
|
|
}
|
|
return $element;
|
|
}
|
|
|
|
/**
|
|
* Returns HTML for a link to a file.
|
|
*
|
|
* @param $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.
|
|
*
|
|
* @ingroup themeable
|
|
*/
|
|
function theme_file_link($variables) {
|
|
$file = $variables['file'];
|
|
$options = array(
|
|
'attributes' => $variables['attributes'],
|
|
);
|
|
|
|
// 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->getFilename();
|
|
}
|
|
else {
|
|
$link_text = $variables['description'];
|
|
$options['attributes']['title'] = check_plain($file->getFilename());
|
|
}
|
|
|
|
$file_icon = array(
|
|
'#theme' => 'file_icon',
|
|
'#file' => $file,
|
|
'#icon_directory' => $variables['icon_directory'],
|
|
);
|
|
|
|
return '<span class="file">' . drupal_render($file_icon) . ' ' . l($link_text, file_create_url($file->getFileUri()), $options) . '</span>';
|
|
}
|
|
|
|
/**
|
|
* Returns HTML for an image with an appropriate icon for the given file.
|
|
*
|
|
* @param $variables
|
|
* An associative array containing:
|
|
* - file: A file entity for which to make an icon.
|
|
* - icon_directory: (optional) A path to a directory of icons to be used for
|
|
* files. Defaults to the value of the "icon.directory"
|
|
* variable.
|
|
*
|
|
* @ingroup themeable
|
|
*/
|
|
function theme_file_icon($variables) {
|
|
$file = $variables['file'];
|
|
$icon_directory = $variables['icon_directory'];
|
|
|
|
$mime = check_plain($file->getMimeType());
|
|
$icon_url = file_icon_url($file, $icon_directory);
|
|
return '<img class="file-icon" alt="" title="' . $mime . '" src="' . $icon_url . '" />';
|
|
}
|
|
|
|
/**
|
|
* Creates a URL to the icon for a file entity.
|
|
*
|
|
* @param \Drupal\file\File $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(File $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\File $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(File $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\File $file
|
|
* A file entity.
|
|
*
|
|
* @return
|
|
* The generic icon MIME package expected for this file.
|
|
*/
|
|
function file_icon_map(File $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;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @defgroup file-module-api File module public API functions
|
|
* @{
|
|
* These functions may be used to determine if and where a file is in use.
|
|
*/
|
|
|
|
/**
|
|
* Retrieves a list of references to a file.
|
|
*
|
|
* @param \Drupal\file\File $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.
|
|
*/
|
|
function file_get_file_references(File $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) {
|
|
$entity_type = \Drupal::entityManager()->getDefinition($entity_type_id);
|
|
// The usage table contains usage of every revision. If we are looking
|
|
// for every revision or the entity does not support revisions then
|
|
// every usage is already a match.
|
|
$match_entity_type = $age == EntityStorageInterface::FIELD_LOAD_REVISION || !$entity_type->hasKey('revision');
|
|
$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) {
|
|
$field_type = $field_definition->getType();
|
|
// If this is the first time this field type is seen, check
|
|
// whether it references files.
|
|
if (!isset($field_columns[$field_type])) {
|
|
$field_columns[$field_type] = file_field_find_file_reference_column($field_definition);
|
|
}
|
|
// If the field type does reference files then record it.
|
|
if ($field_columns[$field_type]) {
|
|
$file_fields[$entity_type_id][$bundle][$field_name] = $field_columns[$field_type];
|
|
}
|
|
}
|
|
}
|
|
foreach ($file_fields[$entity_type_id][$bundle] as $field_name => $field_column) {
|
|
$match = $match_entity_type;
|
|
// If we didn't match yet then iterate over the field items to find
|
|
// the referenced file. This will fail if the usage checked is in a
|
|
// non-current revision because field items are from the current
|
|
// revision.
|
|
if (!$match && ($items = $entity->get($field_name))) {
|
|
foreach ($items as $item) {
|
|
if ($file->id() == $item->{$field_column}) {
|
|
$match = TRUE;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if ($match) {
|
|
$references[$file->id()][$age][$field_name][$entity_type_id][$entity->id()] = $entity;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
$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;
|
|
}
|
|
|
|
/**
|
|
* @} End of "defgroup file-module-api".
|
|
*/
|
|
|
|
/**
|
|
* Implements hook_permission().
|
|
*/
|
|
function file_permission() {
|
|
$perms = array(
|
|
'access files overview' => array(
|
|
'title' => t('Access the Files overview page'),
|
|
'description' => user_access('access files overview')
|
|
? t('Get an overview of <a href="@url">all files</a>.', array('@url' => url('admin/content/files')))
|
|
: t('Get an overview of all files.'),
|
|
),
|
|
);
|
|
|
|
return $perms;
|
|
}
|
|
|
|
/**
|
|
* 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;
|
|
}
|