PHP FileInterface::getName方法代码示例

 /**
  * The actual text extraction.
  *
  * @param FileInterface $file
  * @return string
  */
 public function extractText(FileInterface $file)
 {
     $localTempFile = $file->getForLocalProcessing(false);
     // extract text
     $content = file_get_contents($localTempFile);
     // In case of remote storage, the temporary copy of the
     // original file in typo3temp must be removed
     // Simply compare the filenames, because the filename is so unique that
     // it is nearly impossible to have a file with this name in a storage
     if (PathUtility::basename($localTempFile) !== $file->getName()) {
         unlink($localTempFile);
     }
     return $content;
 }

 /**
  * Removes a temporary file.
  *
  * When working with a file, the actual file might be on a remote storage.
  * To work with it it gets copied to local storage, those temporary local
  * copies need to be removed when they're not needed anymore.
  *
  * @param string $localTempFilePath Path to the local file copy
  * @param \TYPO3\CMS\Core\Resource\FileInterface $sourceFile Original file
  */
 protected function cleanupTempFile($localTempFilePath, FileInterface $sourceFile)
 {
     if (PathUtility::basename($localTempFilePath) !== $sourceFile->getName()) {
         unlink($localTempFilePath);
     }
 }

 /**
  * Previously in \TYPO3\CMS\Core\Utility\File\ExtendedFileUtility::func_rename()
  *
  * @param FileInterface $file
  * @param string $targetFileName
  *
  * @throws Exception\InsufficientFileWritePermissionsException
  * @throws Exception\InsufficientFileReadPermissionsException
  * @throws Exception\InsufficientUserPermissionsException
  * @return FileInterface
  */
 public function renameFile($file, $targetFileName)
 {
     // @todo add $conflictMode setting
     // The name should be different from the current.
     if ($file->getName() === $targetFileName) {
         return $file;
     }
     $sanitizedTargetFileName = $this->driver->sanitizeFileName($targetFileName);
     $this->assureFileRenamePermissions($file, $sanitizedTargetFileName);
     $this->emitPreFileRenameSignal($file, $sanitizedTargetFileName);
     // Call driver method to rename the file and update the index entry
     try {
         $newIdentifier = $this->driver->renameFile($file->getIdentifier(), $sanitizedTargetFileName);
         if ($file instanceof File) {
             $file->updateProperties(array('identifier' => $newIdentifier));
         }
         $this->getIndexer()->updateIndexEntry($file);
     } catch (\RuntimeException $e) {
     }
     $this->emitPostFileRenameSignal($file, $sanitizedTargetFileName);
     return $file;
 }

 /**
  * Creates a magic image
  *
  * @param \TYPO3\CMS\Core\Resource\FileInterface $imageFileObject: the original image file
  * @param array $fileConfiguration (width, height, maxW, maxH)
  * @param string $targetFolderCombinedIdentifier: target folder combined identifier
  * @return \TYPO3\CMS\Core\Resource\FileInterface
  */
 public function createMagicImage(\TYPO3\CMS\Core\Resource\FileInterface $imageFileObject, array $fileConfiguration, $targetFolderCombinedIdentifier)
 {
     $magicImage = NULL;
     // Get file for processing
     $imageFilePath = $imageFileObject->getForLocalProcessing(TRUE);
     // Process dimensions
     $maxWidth = \TYPO3\CMS\Core\Utility\MathUtility::forceIntegerInRange($fileConfiguration['width'], 0, $fileConfiguration['maxW']);
     $maxHeight = \TYPO3\CMS\Core\Utility\MathUtility::forceIntegerInRange($fileConfiguration['height'], 0, $fileConfiguration['maxH']);
     if (!$maxWidth) {
         $maxWidth = $fileConfiguration['maxW'];
     }
     if (!$maxHeight) {
         $maxHeight = $fileConfiguration['maxH'];
     }
     // Create the magic image
     $magicImageInfo = $this->getImageObject()->imageMagickConvert($imageFilePath, 'WEB', $maxWidth . 'm', $maxHeight . 'm');
     if ($magicImageInfo[3]) {
         $targetFileName = 'RTEmagicC_' . pathInfo($imageFileObject->getName(), PATHINFO_FILENAME) . '.' . pathinfo($magicImageInfo[3], PATHINFO_EXTENSION);
         $magicFolder = $this->getMagicFolder($targetFolderCombinedIdentifier);
         if ($magicFolder instanceof \TYPO3\CMS\Core\Resource\Folder) {
             $magicImage = $magicFolder->addFile($magicImageInfo[3], $targetFileName, 'changeName');
         }
     }
     return $magicImage;
 }

 /**
  * @return string
  */
 public function getName()
 {
     return $this->resource->getName();
 }

 /**
  * This method actually does the processing of files locally
  *
  * takes the original file (on remote storages this will be fetched from the remote server)
  * does the IM magic on the local server by creating a temporary typo3temp/ file
  * copies the typo3temp/ file to the processingfolder of the target storage
  * removes the typo3temp/ file
  *
  * @param \TYPO3\CMS\Core\Resource\ProcessedFile $processedFile
  * @param \TYPO3\CMS\Core\Resource\FileInterface $file
  * @param array $configuration
  * @return void
  */
 protected function processImagePreview(\TYPO3\CMS\Core\Resource\ProcessedFile $processedFile, \TYPO3\CMS\Core\Resource\FileInterface $file, array $configuration)
 {
     // Merge custom configuration with default configuration
     $configuration = array_merge(array('width' => 64, 'height' => 64), $configuration);
     $configuration['width'] = \TYPO3\CMS\Core\Utility\MathUtility::forceIntegerInRange($configuration['width'], 1, 1000);
     $configuration['height'] = \TYPO3\CMS\Core\Utility\MathUtility::forceIntegerInRange($configuration['height'], 1, 1000);
     $originalFileName = $file->getForLocalProcessing(FALSE);
     // Create a temporary file in typo3temp/
     if ($file->getExtension() === 'jpg') {
         $targetFileExtension = '.jpg';
     } else {
         $targetFileExtension = '.png';
     }
     $targetFolder = $this->storage->getProcessingFolder();
     $targetFileName = 'preview_' . $processedFile->calculateChecksum() . $targetFileExtension;
     // Do the actual processing
     if (!$targetFolder->hasFile($targetFileName)) {
         // Create the thumb filename in typo3temp/preview_....jpg
         $temporaryFileName = \TYPO3\CMS\Core\Utility\GeneralUtility::tempnam('preview_') . $targetFileExtension;
         // Check file extension
         if ($file->getType() != $file::FILETYPE_IMAGE && !\TYPO3\CMS\Core\Utility\GeneralUtility::inList($GLOBALS['TYPO3_CONF_VARS']['GFX']['imagefile_ext'], $file->getExtension())) {
             // Create a default image
             $this->getTemporaryImageWithText($temporaryFileName, 'Not imagefile!', 'No ext!', $file->getName());
         } else {
             // Create the temporary file
             if ($GLOBALS['TYPO3_CONF_VARS']['GFX']['im']) {
                 $parameters = '-sample ' . $configuration['width'] . 'x' . $configuration['height'] . ' ' . $this->wrapFileName($originalFileName) . '[0] ' . $this->wrapFileName($temporaryFileName);
                 $cmd = \TYPO3\CMS\Core\Utility\GeneralUtility::imageMagickCommand('convert', $parameters);
                 \TYPO3\CMS\Core\Utility\CommandUtility::exec($cmd);
                 if (!file_exists($temporaryFileName)) {
                     // Create a error gif
                     $this->getTemporaryImageWithText($temporaryFileName, 'No thumb', 'generated!', $file->getName());
                 }
             }
         }
         // Temporary image could have been created
         if (file_exists($temporaryFileName)) {
             \TYPO3\CMS\Core\Utility\GeneralUtility::fixPermissions($temporaryFileName);
             // Copy the temporary file to the processedFolder
             // this is done here, as the driver can do this without worrying
             // about existing ProcessedFile objects
             // or permissions in the storage
             // for "remote" storages this means "uploading" the file to the storage again
             // for the virtual storage, it is merely a thing of "copying a file from typo3temp/ to typo3temp/_processed_"
             $this->driver->addFile($temporaryFileName, $targetFolder, $targetFileName, $processedFile);
             // Remove the temporary file as it's not needed anymore
             \TYPO3\CMS\Core\Utility\GeneralUtility::unlink_tempfile($temporaryFileName);
             $processedFile->setProcessed(TRUE);
         }
     } else {
         // the file already exists, nothing to do locally, but still mark the file as processed and save the data
         // and update the fields, as they might have not been set
         if ($processedFile->getProperty('identifier') == '') {
             $identifier = $targetFolder->getIdentifier() . $targetFileName;
             $processedFile->updateProperties(array('name' => $targetFileName, 'identifier' => $identifier));
         }
         $processedFile->setProcessed(TRUE);
     }
 }