function TemporaryJsonapiFileFieldUploader::handleFileUploadForField

Same name in other branches
  1. 9 core/modules/jsonapi/src/Controller/TemporaryJsonapiFileFieldUploader.php \Drupal\jsonapi\Controller\TemporaryJsonapiFileFieldUploader::handleFileUploadForField()
  2. 8.9.x core/modules/jsonapi/src/Controller/TemporaryJsonapiFileFieldUploader.php \Drupal\jsonapi\Controller\TemporaryJsonapiFileFieldUploader::handleFileUploadForField()
  3. 11.x core/modules/jsonapi/src/Controller/TemporaryJsonapiFileFieldUploader.php \Drupal\jsonapi\Controller\TemporaryJsonapiFileFieldUploader::handleFileUploadForField()

Creates and validates a file entity for a file field from a file stream.

Parameters

\Drupal\Core\Field\FieldDefinitionInterface $field_definition: The field definition of the field for which the file is to be uploaded.

string $filename: The name of the file.

\Drupal\Core\Session\AccountInterface $owner: The owner of the file. Note, it is the responsibility of the caller to enforce access.

Return value

\Drupal\file\FileInterface|\Drupal\Core\Entity\EntityConstraintViolationListInterface The newly uploaded file entity, or a list of validation constraint violations

Throws

\Symfony\Component\HttpKernel\Exception\HttpException Thrown when temporary files cannot be written, a lock cannot be acquired, or when temporary files cannot be moved to their new location.

File

core/modules/jsonapi/src/Controller/TemporaryJsonapiFileFieldUploader.php, line 211

Class

TemporaryJsonapiFileFieldUploader
Reads data from an upload stream and creates a corresponding file entity.

Namespace

Drupal\jsonapi\Controller

Code

public function handleFileUploadForField(FieldDefinitionInterface $field_definition, $filename, AccountInterface $owner) {
    assert(is_a($field_definition->getClass(), FileFieldItemList::class, TRUE));
    $settings = $field_definition->getSettings();
    $destination = $this->getUploadDestination($field_definition);
    // Check the destination file path is writable.
    if (!$this->fileSystem
        ->prepareDirectory($destination, FileSystemInterface::CREATE_DIRECTORY)) {
        throw new HttpException(500, 'Destination file path is not writable');
    }
    $validators = $this->getFileUploadValidators($field_definition->getSettings());
    $prepared_filename = $this->prepareFilename($filename, $validators);
    // Create the file.
    $file_uri = "{$destination}/{$prepared_filename}";
    if ($destination === $settings['uri_scheme'] . '://') {
        $file_uri = "{$destination}{$prepared_filename}";
    }
    $temp_file_path = $this->streamUploadData();
    $file_uri = $this->fileSystem
        ->getDestinationFilename($file_uri, FileExists::Rename);
    // Lock based on the prepared file URI.
    $lock_id = $this->generateLockIdFromFileUri($file_uri);
    if (!$this->lock
        ->acquire($lock_id)) {
        throw new HttpException(503, sprintf('File "%s" is already locked for writing.', $file_uri), NULL, [
            'Retry-After' => 1,
        ]);
    }
    // Begin building file entity.
    $file = File::create([]);
    $file->setOwnerId($owner->id());
    $file->setFilename($prepared_filename);
    $file->setMimeType($this->mimeTypeGuesser
        ->guessMimeType($prepared_filename));
    $file->setFileUri($temp_file_path);
    // Set the size. This is done in File::preSave() but we validate the file
    // before it is saved.
    $file->setSize(@filesize($temp_file_path));
    // Validate the file against field-level validators first while the file is
    // still a temporary file. Validation is split up in 2 steps to be the same
    // as in \Drupal\file\Upload\FileUploadHandler::handleFileUpload().
    // For backwards compatibility this part is copied from ::validate() to
    // leave that method behavior unchanged.
    // @todo Improve this with a file uploader service in
    //   https://www.drupal.org/project/drupal/issues/2940383
    $violations = $this->fileValidator
        ->validate($file, $validators);
    if (count($violations) > 0) {
        return $violations;
    }
    $file->setFileUri($file_uri);
    // Update the filename with any changes as a result of security or renaming
    // due to an existing file.
    // @todo Remove this duplication by replacing with FileUploadHandler. See
    // https://www.drupal.org/project/drupal/issues/3401734
    $file->setFilename($this->fileSystem
        ->basename($file->getFileUri()));
    // Move the file to the correct location after validation. Use
    // FileExists::Error as the file location has already been
    // determined above in FileSystem::getDestinationFilename().
    try {
        $this->fileSystem
            ->move($temp_file_path, $file_uri, FileExists::Error);
    } catch (FileException $e) {
        throw new HttpException(500, 'Temporary file could not be moved to file location');
    }
    // Second step of the validation on the file object itself now.
    $violations = $file->validate();
    // Remove violations of inaccessible fields as they cannot stem from our
    // changes.
    $violations->filterByFieldAccess();
    if ($violations->count() > 0) {
        return $violations;
    }
    $file->save();
    $this->lock
        ->release($lock_id);
    return $file;
}

Buggy or inaccurate documentation? Please file an issue. Need support? Need help programming? Connect with the Drupal community.