View source
<?php
use Drupal\Component\Utility\Environment;
use Drupal\Core\Datetime\Entity\DateFormat;
use Drupal\Core\Field\FieldDefinitionInterface;
use Drupal\Core\File\Exception\FileException;
use Drupal\Core\File\FileSystemInterface;
use Drupal\Core\Form\FormStateInterface;
use Drupal\Core\Messenger\MessengerInterface;
use Drupal\Core\Render\BubbleableMetadata;
use Drupal\Core\Render\Element;
use Drupal\Core\Routing\RouteMatchInterface;
use Drupal\Core\Link;
use Drupal\Core\Url;
use Drupal\file\Entity\File;
use Drupal\Core\File\Event\FileUploadSanitizeNameEvent;
use Drupal\file\FileInterface;
use Drupal\Component\Utility\NestedArray;
use Drupal\Core\Entity\EntityStorageInterface;
use Drupal\Core\Template\Attribute;
use Symfony\Component\Mime\MimeTypeGuesserInterface;
define('FILE_INSECURE_EXTENSION_REGEX', FileSystemInterface::INSECURE_EXTENSION_REGEX);
require_once __DIR__ . '/file.field.inc';
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>.', [
':field' => Url::fromRoute('help.page', [
'name' => 'field',
])
->toString(),
':field_ui' => \Drupal::moduleHandler()
->moduleExists('field_ui') ? Url::fromRoute('help.page', [
'name' => 'field_ui',
])
->toString() : '#',
':file_documentation' => 'https://www.drupal.org/documentation/modules/file',
]) . '</p>';
$output .= '<h3>' . t('Uses') . '</h3>';
$output .= '<dl>';
$output .= '<dt>' . t('Managing and displaying file fields') . '</dt>';
$output .= '<dd>' . t('The <em>settings</em> and the <em>display</em> of the file field can be configured separately. See the <a href=":field_ui">Field UI help</a> for more information on how to manage fields and their display.', [
':field_ui' => \Drupal::moduleHandler()
->moduleExists('field_ui') ? Url::fromRoute('help.page', [
'name' => 'field_ui',
])
->toString() : '#',
]) . '</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>.', [
':file-system' => Url::fromRoute('system.file_system_settings')
->toString(),
':system-help' => Url::fromRoute('help.page', [
'name' => 'system',
])
->toString(),
]) . '</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;
}
}
function file_field_widget_info_alter(array &$info) {
$info['uri']['field_types'][] = 'file_uri';
}
function file_copy(FileInterface $source, $destination = NULL, $replace = FileSystemInterface::EXISTS_RENAME) {
$file_system = \Drupal::service('file_system');
$stream_wrapper_manager = \Drupal::service('stream_wrapper_manager');
if (!$stream_wrapper_manager
->isValidUri($destination)) {
if (($realpath = $file_system
->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.', [
'%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.', [
'%file' => $source
->getFileUri(),
'%destination' => $destination,
]);
}
\Drupal::messenger()
->addError(t('The specified file %file could not be copied because the destination is invalid. More information is available in the system log.', [
'%file' => $source
->getFileUri(),
]));
return FALSE;
}
try {
$uri = $file_system
->copy($source
->getFileUri(), $destination, $replace);
$file = $source
->createDuplicate();
$file
->setFileUri($uri);
$file
->setFilename($file_system
->basename($uri));
if ($replace == FileSystemInterface::EXISTS_REPLACE) {
$existing_files = \Drupal::entityTypeManager()
->getStorage('file')
->loadByProperties([
'uri' => $uri,
]);
if (count($existing_files)) {
$existing = reset($existing_files);
$file->fid = $existing
->id();
$file
->setOriginalId($existing
->id());
$file
->setFilename($existing
->getFilename());
}
}
elseif ($replace == FileSystemInterface::EXISTS_RENAME && is_file($destination)) {
$file
->setFilename($file_system
->basename($destination));
}
$file
->save();
\Drupal::moduleHandler()
->invokeAll('file_copy', [
$file,
$source,
]);
return $file;
} catch (FileException $e) {
return FALSE;
}
}
function file_move(FileInterface $source, $destination = NULL, $replace = FileSystemInterface::EXISTS_RENAME) {
$file_system = \Drupal::service('file_system');
$stream_wrapper_manager = \Drupal::service('stream_wrapper_manager');
if (!$stream_wrapper_manager
->isValidUri($destination)) {
if (($realpath = $file_system
->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.', [
'%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.', [
'%file' => $source
->getFileUri(),
'%destination' => $destination,
]);
}
\Drupal::messenger()
->addError(t('The specified file %file could not be moved because the destination is invalid. More information is available in the system log.', [
'%file' => $source
->getFileUri(),
]));
return FALSE;
}
try {
$uri = $file_system
->move($source
->getFileUri(), $destination, $replace);
$delete_source = FALSE;
$file = clone $source;
$file
->setFileUri($uri);
if ($replace == FileSystemInterface::EXISTS_REPLACE) {
$existing_files = \Drupal::entityTypeManager()
->getStorage('file')
->loadByProperties([
'uri' => $uri,
]);
if (count($existing_files)) {
$existing = reset($existing_files);
$delete_source = TRUE;
$file->fid = $existing
->id();
$file->uuid = $existing
->uuid();
}
}
elseif ($replace == FileSystemInterface::EXISTS_RENAME && is_file($destination)) {
$file
->setFilename(\Drupal::service('file_system')
->basename($destination));
}
$file
->save();
\Drupal::moduleHandler()
->invokeAll('file_move', [
$file,
$source,
]);
if ($delete_source && !\Drupal::service('file.usage')
->listUsage($source)) {
$source
->delete();
}
return $file;
} catch (FileException $e) {
return FALSE;
}
}
function file_validate(FileInterface $file, $validators = []) {
$errors = [];
foreach ($validators as $function => $args) {
if (function_exists($function)) {
array_unshift($args, $file);
$errors = array_merge($errors, call_user_func_array($function, $args));
}
}
$errors = array_merge($errors, \Drupal::moduleHandler()
->invokeAll('file_validate', [
$file,
]));
if (empty($errors) && !\Drupal::config('system.file')
->get('allow_insecure_uploads') && preg_match(FileSystemInterface::INSECURE_EXTENSION_REGEX, $file
->getFilename())) {
$errors[] = t('For security reasons, your upload has been rejected.');
}
return $errors;
}
function file_validate_name_length(FileInterface $file) {
$errors = [];
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;
}
function file_validate_extensions(FileInterface $file, $extensions) {
$errors = [];
$regex = '/\\.(' . preg_replace('/ +/', '|', preg_quote($extensions)) . ')$/i';
$subject = $file
->isTemporary() ? $file
->getFilename() : $file
->getFileUri();
if (!preg_match($regex, $subject)) {
$errors[] = t('Only files with the following extensions are allowed: %files-allowed.', [
'%files-allowed' => $extensions,
]);
}
return $errors;
}
function file_validate_size(FileInterface $file, $file_limit = 0, $user_limit = 0) {
$user = \Drupal::currentUser();
$errors = [];
if ($file_limit && $file
->getSize() > $file_limit) {
$errors[] = t('The file is %filesize exceeding the maximum file size of %maxsize.', [
'%filesize' => format_size($file
->getSize()),
'%maxsize' => format_size($file_limit),
]);
}
if ($user_limit && \Drupal::entityTypeManager()
->getStorage('file')
->spaceUsed($user
->id()) + $file
->getSize() > $user_limit) {
$errors[] = t('The file is %filesize which would exceed your disk quota of %quota.', [
'%filesize' => format_size($file
->getSize()),
'%quota' => format_size($user_limit),
]);
}
return $errors;
}
function file_validate_is_image(FileInterface $file) {
$errors = [];
$image_factory = \Drupal::service('image.factory');
$image = $image_factory
->get($file
->getFileUri());
if (!$image
->isValid()) {
$supported_extensions = $image_factory
->getSupportedExtensions();
$errors[] = t('The image file is invalid or the image type is not allowed. Allowed types: %types', [
'%types' => implode(', ', $supported_extensions),
]);
}
return $errors;
}
function file_validate_image_resolution(FileInterface $file, $maximum_dimensions = 0, $minimum_dimensions = 0) {
$errors = [];
$image_factory = \Drupal::service('image.factory');
$image = $image_factory
->get($file
->getFileUri());
if ($image
->isValid()) {
$scaling = FALSE;
if ($maximum_dimensions) {
list($width, $height) = explode('x', $maximum_dimensions);
if ($image
->getWidth() > $width || $image
->getHeight() > $height) {
if ($image
->scale($width, $height)) {
$scaling = TRUE;
$image
->save();
if (!empty($width) && !empty($height)) {
$message = t('The image was resized to fit within the maximum allowed dimensions of %dimensions pixels. The new dimensions of the resized image are %new_widthx%new_height pixels.', [
'%dimensions' => $maximum_dimensions,
'%new_width' => $image
->getWidth(),
'%new_height' => $image
->getHeight(),
]);
}
elseif (empty($width)) {
$message = t('The image was resized to fit within the maximum allowed height of %height pixels. The new dimensions of the resized image are %new_widthx%new_height pixels.', [
'%height' => $height,
'%new_width' => $image
->getWidth(),
'%new_height' => $image
->getHeight(),
]);
}
elseif (empty($height)) {
$message = t('The image was resized to fit within the maximum allowed width of %width pixels. The new dimensions of the resized image are %new_widthx%new_height pixels.', [
'%width' => $width,
'%new_width' => $image
->getWidth(),
'%new_height' => $image
->getHeight(),
]);
}
\Drupal::messenger()
->addStatus($message);
}
else {
$errors[] = t('The image exceeds the maximum allowed dimensions and an attempt to resize it failed.');
}
}
}
if ($minimum_dimensions) {
list($width, $height) = explode('x', $minimum_dimensions);
if ($image
->getWidth() < $width || $image
->getHeight() < $height) {
if ($scaling) {
$errors[] = t('The resized image is too small. The minimum dimensions are %dimensions pixels and after resizing, the image size will be %widthx%height pixels.', [
'%dimensions' => $minimum_dimensions,
'%width' => $image
->getWidth(),
'%height' => $image
->getHeight(),
]);
}
else {
$errors[] = t('The image is too small. The minimum dimensions are %dimensions pixels and the image size is %widthx%height pixels.', [
'%dimensions' => $minimum_dimensions,
'%width' => $image
->getWidth(),
'%height' => $image
->getHeight(),
]);
}
}
}
}
return $errors;
}
function file_save_data($data, $destination = NULL, $replace = FileSystemInterface::EXISTS_RENAME) {
$user = \Drupal::currentUser();
if (empty($destination)) {
$destination = \Drupal::config('system.file')
->get('default_scheme') . '://';
}
$stream_wrapper_manager = \Drupal::service('stream_wrapper_manager');
if (!$stream_wrapper_manager
->isValidUri($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.', [
'%destination' => $destination,
]);
\Drupal::messenger()
->addError(t('The data could not be saved because the destination is invalid. More information is available in the system log.'));
return FALSE;
}
try {
$uri = \Drupal::service('file_system')
->saveData($data, $destination, $replace);
$file = File::create([
'uri' => $uri,
'uid' => $user
->id(),
]);
$file
->setPermanent();
if ($replace == FileSystemInterface::EXISTS_REPLACE) {
$existing_files = \Drupal::entityTypeManager()
->getStorage('file')
->loadByProperties([
'uri' => $uri,
]);
if (count($existing_files)) {
$existing = reset($existing_files);
$file->fid = $existing
->id();
$file
->setOriginalId($existing
->id());
$file
->setFilename($existing
->getFilename());
}
}
elseif ($replace == FileSystemInterface::EXISTS_RENAME && is_file($destination)) {
$file
->setFilename(\Drupal::service('file_system')
->basename($destination));
}
$file
->save();
return $file;
} catch (FileException $e) {
return FALSE;
}
}
function file_get_content_headers(FileInterface $file) {
return [
'Content-Type' => $file
->getMimeType(),
'Content-Length' => $file
->getSize(),
'Cache-Control' => 'private',
];
}
function file_theme() {
return [
'file_link' => [
'variables' => [
'file' => NULL,
'description' => NULL,
'attributes' => [],
],
],
'file_managed_file' => [
'render element' => 'element',
],
'file_audio' => [
'variables' => [
'files' => [],
'attributes' => NULL,
],
],
'file_video' => [
'variables' => [
'files' => [],
'attributes' => NULL,
],
],
'file_widget_multiple' => [
'render element' => 'element',
'file' => 'file.field.inc',
],
'file_upload_help' => [
'variables' => [
'description' => NULL,
'upload_validators' => NULL,
'cardinality' => NULL,
],
'file' => 'file.field.inc',
],
];
}
function file_file_download($uri) {
$files = \Drupal::entityTypeManager()
->getStorage('file')
->loadByProperties([
'uri' => $uri,
]);
if (count($files)) {
foreach ($files as $item) {
if ($item
->getFileUri() === $uri) {
$file = $item;
break;
}
}
}
if (!isset($file)) {
return;
}
if ($file
->isTemporary()) {
$usage = \Drupal::service('file.usage')
->listUsage($file);
if (empty($usage) && $file
->getOwnerId() != \Drupal::currentUser()
->id()) {
return -1;
}
}
$references = file_get_file_references($file, NULL, EntityStorageInterface::FIELD_LOAD_CURRENT, NULL);
if (empty($references) && ($file
->isPermanent() || $file
->getOwnerId() != \Drupal::currentUser()
->id())) {
return;
}
if (!$file
->access('download')) {
return -1;
}
$headers = file_get_content_headers($file);
return $headers;
}
function file_cron() {
$age = \Drupal::config('system.file')
->get('temporary_maximum_age');
$file_storage = \Drupal::entityTypeManager()
->getStorage('file');
$stream_wrapper_manager = \Drupal::service('stream_wrapper_manager');
if ($age) {
$fids = Drupal::entityQuery('file')
->accessCheck(FALSE)
->condition('status', FileInterface::STATUS_PERMANENT, '<>')
->condition('changed', REQUEST_TIME - $age, '<')
->range(0, 100)
->execute();
$files = $file_storage
->loadMultiple($fids);
foreach ($files as $file) {
$references = \Drupal::service('file.usage')
->listUsage($file);
if (empty($references)) {
if (!file_exists($file
->getFileUri())) {
if (!$stream_wrapper_manager
->isValidUri($file
->getFileUri())) {
\Drupal::logger('file system')
->warning('Temporary file "%path" that was deleted during garbage collection did not exist on the filesystem. This could be caused by a missing stream wrapper.', [
'%path' => $file
->getFileUri(),
]);
}
else {
\Drupal::logger('file system')
->warning('Temporary file "%path" that was deleted during garbage collection did not exist on the filesystem.', [
'%path' => $file
->getFileUri(),
]);
}
}
$file
->delete();
}
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.', [
'%path' => $file
->getFileUri(),
'%modules' => implode(', ', array_keys($references)),
]);
}
}
}
}
function _file_save_upload_from_form(array $element, FormStateInterface $form_state, $delta = NULL, $replace = FileSystemInterface::EXISTS_RENAME) {
$errors_before = \Drupal::messenger()
->deleteByType(MessengerInterface::TYPE_ERROR);
$upload_location = isset($element['#upload_location']) ? $element['#upload_location'] : FALSE;
$upload_name = implode('_', $element['#parents']);
$upload_validators = isset($element['#upload_validators']) ? $element['#upload_validators'] : [];
$result = file_save_upload($upload_name, $upload_validators, $upload_location, $delta, $replace);
$errors_new = \Drupal::messenger()
->deleteByType(MessengerInterface::TYPE_ERROR);
if (!empty($errors_new)) {
if (count($errors_new) > 1) {
$render_array = [
'error' => [
'#markup' => t('One or more files could not be uploaded.'),
],
'item_list' => [
'#theme' => 'item_list',
'#items' => $errors_new,
],
];
$error_message = \Drupal::service('renderer')
->renderPlain($render_array);
}
else {
$error_message = reset($errors_new);
}
$form_state
->setError($element, $error_message);
}
if (!empty($errors_before)) {
foreach ($errors_before as $error) {
\Drupal::messenger()
->addError($error);
}
}
return $result;
}
function file_save_upload($form_field_name, $validators = [], $destination = FALSE, $delta = NULL, $replace = FileSystemInterface::EXISTS_RENAME) {
static $upload_cache;
$all_files = \Drupal::request()->files
->get('files', []);
if (empty($all_files[$form_field_name])) {
return NULL;
}
$file_upload = $all_files[$form_field_name];
if (isset($upload_cache[$form_field_name])) {
if (isset($delta)) {
return $upload_cache[$form_field_name][$delta];
}
return $upload_cache[$form_field_name];
}
$uploaded_files = $file_upload;
if (!is_array($file_upload)) {
$uploaded_files = [
$file_upload,
];
}
$files = [];
foreach ($uploaded_files as $i => $file_info) {
$files[$i] = _file_save_upload_single($file_info, $form_field_name, $validators, $destination, $replace);
}
$upload_cache[$form_field_name] = $files;
return isset($delta) ? $files[$delta] : $files;
}
function _file_save_upload_single(\SplFileInfo $file_info, $form_field_name, $validators = [], $destination = FALSE, $replace = FileSystemInterface::EXISTS_REPLACE) {
$user = \Drupal::currentUser();
$original_file_name = $file_info
->getClientOriginalName();
switch ($file_info
->getError()) {
case UPLOAD_ERR_INI_SIZE:
case UPLOAD_ERR_FORM_SIZE:
\Drupal::messenger()
->addError(t('The file %file could not be saved because it exceeds %maxsize, the maximum allowed size for uploads.', [
'%file' => $original_file_name,
'%maxsize' => format_size(Environment::getUploadMaxSize()),
]));
return FALSE;
case UPLOAD_ERR_PARTIAL:
case UPLOAD_ERR_NO_FILE:
\Drupal::messenger()
->addError(t('The file %file could not be saved because the upload did not complete.', [
'%file' => $original_file_name,
]));
return FALSE;
case UPLOAD_ERR_OK:
if (is_uploaded_file($file_info
->getRealPath())) {
break;
}
default:
\Drupal::messenger()
->addError(t('The file %file could not be saved. An unknown error has occurred.', [
'%file' => $original_file_name,
]));
return FALSE;
}
$extensions = '';
if (isset($validators['file_validate_extensions'])) {
if (isset($validators['file_validate_extensions'][0])) {
$extensions = $validators['file_validate_extensions'][0];
}
else {
unset($validators['file_validate_extensions']);
}
}
else {
$extensions = 'jpg jpeg gif png txt doc xls pdf ppt pps odt ods odp';
$validators['file_validate_extensions'] = [];
$validators['file_validate_extensions'][0] = $extensions;
}
if (empty($destination)) {
$destination = 'temporary://';
}
$stream_wrapper_manager = \Drupal::service('stream_wrapper_manager');
$destination_scheme = $stream_wrapper_manager::getScheme($destination);
if (!$stream_wrapper_manager
->isValidScheme($destination_scheme)) {
\Drupal::messenger()
->addError(t('The file could not be uploaded because the destination %destination is invalid.', [
'%destination' => $destination,
]));
return FALSE;
}
if (substr($destination, -1) != '/') {
$destination .= '/';
}
$event = new FileUploadSanitizeNameEvent($original_file_name, $extensions);
\Drupal::service('event_dispatcher')
->dispatch($event);
$values = [
'uid' => $user
->id(),
'status' => 0,
'filename' => $event
->getFilename(),
'uri' => $file_info
->getRealPath(),
'filesize' => $file_info
->getSize(),
];
$file = File::create($values);
$file_system = \Drupal::service('file_system');
try {
$file->destination = $file_system
->getDestinationFilename($destination . $event
->getFilename(), $replace);
} catch (FileException $e) {
\Drupal::messenger()
->addError(t('The file %filename could not be uploaded because the name is invalid.', [
'%filename' => $file
->getFilename(),
]));
return FALSE;
}
$guesser = \Drupal::service('file.mime_type.guesser');
if ($guesser instanceof MimeTypeGuesserInterface) {
$file
->setMimeType($guesser
->guessMimeType($values['filename']));
}
else {
$file
->setMimeType($guesser
->guess($values['filename']));
@trigger_error('\\Symfony\\Component\\HttpFoundation\\File\\MimeType\\MimeTypeGuesserInterface is deprecated in drupal:9.1.0 and is removed from drupal:10.0.0. Implement \\Symfony\\Component\\Mime\\MimeTypeGuesserInterface instead. See https://www.drupal.org/node/3133341', E_USER_DEPRECATED);
}
$file->source = $form_field_name;
if ($file->destination === FALSE) {
\Drupal::messenger()
->addError(t('The file %source could not be uploaded because a file by that name already exists in the destination %directory.', [
'%source' => $form_field_name,
'%directory' => $destination,
]));
return FALSE;
}
$validators['file_validate_name_length'] = [];
$errors = file_validate($file, $validators);
if (!empty($errors)) {
$message = [
'error' => [
'#markup' => t('The specified file %name could not be uploaded.', [
'%name' => $file
->getFilename(),
]),
],
'item_list' => [
'#theme' => 'item_list',
'#items' => $errors,
],
];
\Drupal::messenger()
->addError(\Drupal::service('renderer')
->renderPlain($message));
return FALSE;
}
$file
->setFileUri($file->destination);
if (!$file_system
->moveUploadedFile($file_info
->getRealPath(), $file
->getFileUri())) {
\Drupal::messenger()
->addError(t('File upload error. Could not move uploaded file.'));
\Drupal::logger('file')
->notice('Upload error. Could not move uploaded file %file to destination %destination.', [
'%file' => $file
->getFilename(),
'%destination' => $file
->getFileUri(),
]);
return FALSE;
}
$file
->setFilename(\Drupal::service('file_system')
->basename($file->destination));
if ($file
->getFilename() !== $original_file_name) {
if ($event
->isSecurityRename()) {
$message = t('For security reasons, your upload has been renamed to %filename.', [
'%filename' => $file
->getFilename(),
]);
}
else {
$message = t('Your upload has been renamed to %filename.', [
'%filename' => $file
->getFilename(),
]);
}
\Drupal::messenger()
->addStatus($message);
}
$file_system
->chmod($file
->getFileUri());
if ($replace == FileSystemInterface::EXISTS_REPLACE) {
$existing_files = \Drupal::entityTypeManager()
->getStorage('file')
->loadByProperties([
'uri' => $file
->getFileUri(),
]);
if (count($existing_files)) {
$existing = reset($existing_files);
$file->fid = $existing
->id();
$file
->setOriginalId($existing
->id());
}
}
$file
->setFilename(\Drupal::service('file_system')
->basename($file->destination));
$violations = $file
->validate();
foreach ($violations as $violation) {
$errors[] = $violation
->getMessage();
}
if (!empty($errors)) {
$message = [
'error' => [
'#markup' => t('The specified file %name could not be uploaded.', [
'%name' => $file
->getFilename(),
]),
],
'item_list' => [
'#theme' => 'item_list',
'#items' => $errors,
],
];
\Drupal::messenger()
->addError(\Drupal::service('renderer')
->renderPlain($message));
return FALSE;
}
$file
->save();
if ($user
->isAnonymous() && $destination_scheme !== 'public') {
$session = \Drupal::request()
->getSession();
$allowed_temp_files = $session
->get('anonymous_allowed_file_ids', []);
$allowed_temp_files[$file
->id()] = $file
->id();
$session
->set('anonymous_allowed_file_ids', $allowed_temp_files);
}
return $file;
}
function file_progress_implementation() {
static $implementation;
if (!isset($implementation)) {
$implementation = FALSE;
if (extension_loaded('uploadprogress')) {
$implementation = 'uploadprogress';
}
}
return $implementation;
}
function file_file_predelete(File $file) {
}
function file_tokens($type, $tokens, array $data, array $options, BubbleableMetadata $bubbleable_metadata) {
$token_service = \Drupal::token();
$url_options = [
'absolute' => TRUE,
];
if (isset($options['langcode'])) {
$url_options['language'] = \Drupal::languageManager()
->getLanguage($options['langcode']);
$langcode = $options['langcode'];
}
else {
$langcode = NULL;
}
$replacements = [];
if ($type == 'file' && !empty($data['file'])) {
$file = $data['file'];
foreach ($tokens as $name => $original) {
switch ($name) {
case 'fid':
$replacements[$original] = $file
->id();
break;
case 'name':
$replacements[$original] = $file
->getFilename();
break;
case 'path':
$replacements[$original] = $file
->getFileUri();
break;
case 'mime':
$replacements[$original] = $file
->getMimeType();
break;
case 'size':
$replacements[$original] = format_size($file
->getSize());
break;
case 'url':
$replacements[$original] = $file
->createFileUrl(FALSE);
$bubbleable_metadata
->addCacheContexts([
'url.site',
]);
break;
case 'created':
$date_format = DateFormat::load('medium');
$bubbleable_metadata
->addCacheableDependency($date_format);
$replacements[$original] = \Drupal::service('date.formatter')
->format($file
->getCreatedTime(), 'medium', '', NULL, $langcode);
break;
case 'changed':
$date_format = DateFormat::load('medium');
$bubbleable_metadata = $bubbleable_metadata
->addCacheableDependency($date_format);
$replacements[$original] = \Drupal::service('date.formatter')
->format($file
->getChangedTime(), 'medium', '', NULL, $langcode);
break;
case 'owner':
$owner = $file
->getOwner();
$bubbleable_metadata
->addCacheableDependency($owner);
$name = $owner
->label();
$replacements[$original] = $name;
break;
}
}
if ($date_tokens = $token_service
->findWithPrefix($tokens, 'created')) {
$replacements += $token_service
->generate('date', $date_tokens, [
'date' => $file
->getCreatedTime(),
], $options, $bubbleable_metadata);
}
if ($date_tokens = $token_service
->findWithPrefix($tokens, 'changed')) {
$replacements += $token_service
->generate('date', $date_tokens, [
'date' => $file
->getChangedTime(),
], $options, $bubbleable_metadata);
}
if (($owner_tokens = $token_service
->findWithPrefix($tokens, 'owner')) && $file
->getOwner()) {
$replacements += $token_service
->generate('user', $owner_tokens, [
'user' => $file
->getOwner(),
], $options, $bubbleable_metadata);
}
}
return $replacements;
}
function file_token_info() {
$types['file'] = [
'name' => t("Files"),
'description' => t("Tokens related to uploaded files."),
'needs-data' => 'file',
];
$file['fid'] = [
'name' => t("File ID"),
'description' => t("The unique ID of the uploaded file."),
];
$file['name'] = [
'name' => t("File name"),
'description' => t("The name of the file on disk."),
];
$file['path'] = [
'name' => t("Path"),
'description' => t("The location of the file relative to Drupal root."),
];
$file['mime'] = [
'name' => t("MIME type"),
'description' => t("The MIME type of the file."),
];
$file['size'] = [
'name' => t("File size"),
'description' => t("The size of the file."),
];
$file['url'] = [
'name' => t("URL"),
'description' => t("The web-accessible URL for the file."),
];
$file['created'] = [
'name' => t("Created"),
'description' => t("The date the file created."),
'type' => 'date',
];
$file['changed'] = [
'name' => t("Changed"),
'description' => t("The date the file was most recently changed."),
'type' => 'date',
];
$file['owner'] = [
'name' => t("Owner"),
'description' => t("The user who originally uploaded the file."),
'type' => 'user',
];
return [
'types' => $types,
'tokens' => [
'file' => $file,
],
];
}
function file_managed_file_submit($form, FormStateInterface $form_state) {
$parents = $form_state
->getTriggeringElement()['#array_parents'];
$button_key = array_pop($parents);
$element = NestedArray::getValue($form, $parents);
if ($button_key == 'remove_button') {
$fids = array_keys($element['#files']);
if ($element['#multiple']) {
$remove_fids = [];
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 {
$remove_fids = $fids;
$fids = [];
}
foreach ($remove_fids as $fid) {
if ($element['#files'][$fid] && $element['#files'][$fid]
->isTemporary()) {
$element['#files'][$fid]
->delete();
}
}
$form_state
->setValueForElement($element['fids'], implode(' ', $fids));
NestedArray::setValue($form_state
->getUserInput(), $element['fids']['#parents'], implode(' ', $fids));
}
$form_state
->setRebuild();
}
function file_managed_file_save_upload($element, FormStateInterface $form_state) {
$upload_name = implode('_', $element['#parents']);
$all_files = \Drupal::request()->files
->get('files', []);
if (empty($all_files[$upload_name])) {
return FALSE;
}
$file_upload = $all_files[$upload_name];
$destination = isset($element['#upload_location']) ? $element['#upload_location'] : NULL;
if (isset($destination) && !\Drupal::service('file_system')
->prepareDirectory($destination, FileSystemInterface::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.', [
'%directory' => $destination,
'%name' => $element['#field_name'],
]);
$form_state
->setError($element, t('The file could not be uploaded.'));
return FALSE;
}
$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_from_form($element, $form_state))) {
\Drupal::logger('file')
->notice('The file upload failed. %upload', [
'%upload' => $upload_name,
]);
return [];
}
$files = array_filter($files);
$fids = array_map(function ($file) {
return $file
->id();
}, $files);
return empty($files) ? [] : array_combine($fids, $files);
}
return [];
}
function template_preprocess_file_managed_file(&$variables) {
$element = $variables['element'];
$variables['attributes'] = [];
if (isset($element['#id'])) {
$variables['attributes']['id'] = $element['#id'];
}
if (!empty($element['#attributes']['class'])) {
$variables['attributes']['class'] = (array) $element['#attributes']['class'];
}
}
function template_preprocess_file_link(&$variables) {
$file = $variables['file'];
$options = [];
$file_url_generator = \Drupal::service('file_url_generator');
$url = $file_url_generator
->generate($file
->getFileUri());
$mime_type = $file
->getMimeType();
$options['attributes']['type'] = $mime_type;
if (empty($variables['description'])) {
$link_text = $file
->getFilename();
}
else {
$link_text = $variables['description'];
$options['attributes']['title'] = $file
->getFilename();
}
$classes = [
'file',
'file--mime-' . strtr($mime_type, [
'/' => '-',
'.' => '-',
]),
'file--' . file_icon_class($mime_type),
];
$variables['attributes'] = new Attribute($variables['attributes']);
$variables['attributes']
->addClass($classes);
$variables['file_size'] = format_size($file
->getSize());
$variables['link'] = Link::fromTextAndUrl($link_text, $url
->setOptions($options))
->toRenderable();
}
function file_icon_class($mime_type) {
$generic_mime = (string) file_icon_map($mime_type);
if (!empty($generic_mime)) {
return $generic_mime;
}
foreach ([
'audio',
'image',
'text',
'video',
] as $category) {
if (strpos($mime_type, $category) === 0) {
return $category;
}
}
return 'general';
}
function file_icon_map($mime_type) {
switch ($mime_type) {
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';
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';
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';
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';
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';
case 'application/xhtml+xml':
return 'text-html';
case 'application/x-macbinary':
case 'application/x-ms-dos-executable':
case 'application/x-pef-executable':
return 'application-x-executable';
case 'application/pdf':
case 'application/x-pdf':
case 'applications/vnd.pdf':
case 'text/pdf':
case 'text/x-pdf':
return 'application-pdf';
default:
return FALSE;
}
}
function file_get_file_references(FileInterface $file, FieldDefinitionInterface $field = NULL, $age = EntityStorageInterface::FIELD_LOAD_REVISION, $field_type = 'file') {
$references =& drupal_static(__FUNCTION__, []);
$field_columns =& drupal_static(__FUNCTION__ . ':field_columns', []);
if (!isset($references[$file
->id()][$age])) {
$references[$file
->id()][$age] = [];
$usage_list = \Drupal::service('file.usage')
->listUsage($file);
$file_usage_list = isset($usage_list['file']) ? $usage_list['file'] : [];
foreach ($file_usage_list as $entity_type_id => $entity_ids) {
$entities = \Drupal::entityTypeManager()
->getStorage($entity_type_id)
->loadMultiple(array_keys($entity_ids));
foreach ($entities as $entity) {
$bundle = $entity
->bundle();
if (!isset($file_fields[$entity_type_id][$bundle])) {
$file_fields[$entity_type_id][$bundle] = [];
foreach ($entity
->getFieldDefinitions() as $field_name => $field_definition) {
if (!isset($field_columns[$field_definition
->getType()])) {
$field_columns[$field_definition
->getType()] = file_field_find_file_reference_column($field_definition);
}
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) {
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];
$entity_field_manager = \Drupal::service('entity_field.manager');
if ($field || $field_type) {
foreach ($return as $field_name => $data) {
foreach (array_keys($data) as $entity_type_id) {
$field_storage_definitions = $entity_field_manager
->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;
}
function _views_file_status($choice = NULL) {
@trigger_error('_views_file_status() is deprecated in drupal:9.3.0 and is removed from drupal:10.0.0. There is no replacement. See https://www.drupal.org/node/3227228', E_USER_DEPRECATED);
$status = [
0 => t('Temporary'),
FileInterface::STATUS_PERMANENT => t('Permanent'),
];
if (isset($choice)) {
return isset($status[$choice]) ? $status[$choice] : t('Unknown');
}
return $status;
}
