TYPO3_6-2/_resource_storage_8php_source.html

 <?php
 namespace TYPO3\CMS\Core\Resource;

 use TYPO3\CMS\Core\Resource\Exception\InvalidTargetFolderException;
 use TYPO3\CMS\Core\Resource\Index\FileIndexRepository;
 use TYPO3\CMS\Core\Utility\GeneralUtility;
 use TYPO3\CMS\Core\Utility\PathUtility;

 class ResourceStorage implements ResourceStorageInterface {

     protected $driver;

     protected $storageRecord;

     protected $configuration;

     protected $fileProcessingService;

     protected $evaluatePermissions = FALSE;

     protected $fileMounts = array();

     protected $userPermissions = array();

     protected $capabilities;

     protected $signalSlotDispatcher;

     protected $processingFolder;

     protected $processingFolders;

     protected $isOnline = NULL;

     protected $isDefault = FALSE;

     protected $fileAndFolderNameFilters = array();

     public function __construct(Driver\DriverInterface $driver, array $storageRecord) {
         $this->storageRecord = $storageRecord;
         $this->configuration = ResourceFactory::getInstance()->convertFlexFormDataToConfigurationArray($storageRecord['configuration']);
         $this->capabilities =
             ($this->storageRecord['is_browsable'] ? self::CAPABILITY_BROWSABLE : 0) |
             ($this->storageRecord['is_public'] ? self::CAPABILITY_PUBLIC : 0) |
             ($this->storageRecord['is_writable'] ? self::CAPABILITY_WRITABLE : 0);

         $this->driver = $driver;
         $this->driver->setStorageUid($storageRecord['uid']);
         $this->driver->mergeConfigurationCapabilities($this->capabilities);
         try {
             $this->driver->processConfiguration();
         } catch (Exception\InvalidConfigurationException $e) {
             // configuration error
             // mark this storage as permanently unusable
             $this->markAsPermanentlyOffline();
         }
         $this->driver->initialize();
         $this->capabilities = $this->driver->getCapabilities();

         $this->isDefault = (isset($storageRecord['is_default']) && $storageRecord['is_default'] == 1);
         $this->resetFileAndFolderNameFiltersToDefault();
     }

     public function getConfiguration() {
         return $this->configuration;
     }

     public function setConfiguration(array $configuration) {
         $this->configuration = $configuration;
     }

     public function getStorageRecord() {
         return $this->storageRecord;
     }

     public function setDriver(Driver\DriverInterface $driver) {
         $this->driver = $driver;
         return $this;
     }

     protected function getDriver() {
         return $this->driver;
     }

     public function getFolderByIdentifier($identifier) {
         throw new \BadMethodCallException(
             'Function TYPO3\\CMS\\Core\\Resource\\ResourceStorage::getFolderByIdentifier() has been renamed to just getFolder(). Please fix the method call.',
             1333754514
         );
     }

     public function getFileByIdentifier($identifier) {
         throw new \BadMethodCallException(
             'Function TYPO3\\CMS\\Core\\Resource\\ResourceStorage::getFileByIdentifier() has been renamed to just getFileInfoByIdentifier(). ' . 'Please fix the method call.',
             1333754533
         );
     }

     public function getName() {
         return $this->storageRecord['name'];
     }

     public function getUid() {
         return (int)$this->storageRecord['uid'];
     }

     public function hasChildren() {
         return TRUE;
     }

     /*********************************
      * Capabilities
      ********************************/
     public function getCapabilities() {
         return (int)$this->capabilities;
     }

     protected function hasCapability($capability) {
         return ($this->capabilities & $capability) == $capability;
     }

     public function isPublic() {
         return $this->hasCapability(self::CAPABILITY_PUBLIC);
     }

     public function isWritable() {
         return $this->hasCapability(self::CAPABILITY_WRITABLE);
     }

     public function isBrowsable() {
         return $this->isOnline() && $this->hasCapability(self::CAPABILITY_BROWSABLE);
     }

     public function usesCaseSensitiveIdentifiers() {
         return $this->driver->isCaseSensitiveFileSystem();
     }

     public function isOnline() {
         if ($this->isOnline === NULL) {
             if ($this->getUid() === 0) {
                 $this->isOnline = TRUE;
             }
             // the storage is not marked as online for a longer time
             if ($this->storageRecord['is_online'] == 0) {
                 $this->isOnline = FALSE;
             }
             if ($this->isOnline !== FALSE) {
                 // all files are ALWAYS available in the frontend
                 if (TYPO3_MODE === 'FE') {
                     $this->isOnline = TRUE;
                 } else {
                     // check if the storage is disabled temporary for now
                     $registryObject = GeneralUtility::makeInstance('TYPO3\\CMS\\Core\\Registry');
                     $offlineUntil = $registryObject->get('core', 'sys_file_storage-' . $this->getUid() . '-offline-until');
                     if ($offlineUntil && $offlineUntil > time()) {
                         $this->isOnline = FALSE;
                     } else {
                         $this->isOnline = TRUE;
                     }
                 }
             }
         }
         return $this->isOnline;
     }

     public function markAsPermanentlyOffline() {
         if ($this->getUid() > 0) {
             // @todo: move this to the storage repository
             $GLOBALS['TYPO3_DB']->exec_UPDATEquery('sys_file_storage', 'uid=' . (int)$this->getUid(), array('is_online' => 0));
         }
         $this->storageRecord['is_online'] = 0;
         $this->isOnline = FALSE;
     }

     public function markAsTemporaryOffline() {
         $registryObject = GeneralUtility::makeInstance('TYPO3\\CMS\\Core\\Registry');
         $registryObject->set('core', 'sys_file_storage-' . $this->getUid() . '-offline-until', time() + 60 * 5);
         $this->storageRecord['is_online'] = 0;
         $this->isOnline = FALSE;
     }

     /*********************************
      * User Permissions / File Mounts
      ********************************/
     public function addFileMount($folderIdentifier, $additionalData = array()) {
         // check for the folder before we add it as a filemount
         if ($this->driver->folderExists($folderIdentifier) === FALSE) {
             // if there is an error, this is important and should be handled
             // as otherwise the user would see the whole storage without any restrictions for the filemounts
             throw new Exception\FolderDoesNotExistException('Folder for file mount ' . $folderIdentifier . ' does not exist.', 1334427099);
         }
         $data = $this->driver->getFolderInfoByIdentifier($folderIdentifier);
         $folderObject = ResourceFactory::getInstance()->createFolderObject($this, $data['identifier'], $data['name']);
         // Use the canonical identifier instead of the user provided one!
         $folderIdentifier = $folderObject->getIdentifier();
         if (
             !empty($this->fileMounts[$folderIdentifier])
             && empty($this->fileMounts[$folderIdentifier]['read_only'])
             && !empty($additionalData['read_only'])
         ) {
             // Do not overwrite a regular mount with a read only mount
             return;
         }
         if (empty($additionalData)) {
             $additionalData = array(
                 'path' => $folderIdentifier,
                 'title' => $folderIdentifier,
                 'folder' => $folderObject
             );
         } else {
             $additionalData['folder'] = $folderObject;
             if (!isset($additionalData['title'])) {
                 $additionalData['title'] = $folderIdentifier;
             }
         }
         $this->fileMounts[$folderIdentifier] = $additionalData;
     }

     public function getFileMounts() {
         return $this->fileMounts;
     }

     public function isWithinFileMountBoundaries($subject, $checkWriteAccess = FALSE) {
         if (!$this->evaluatePermissions) {
             return TRUE;
         }
         $isWithinFileMount = FALSE;
         if (!$subject) {
             $subject = $this->getRootLevelFolder();
         }
         $identifier = $subject->getIdentifier();

         // Allow access to processing folder
         if ($this->isWithinProcessingFolder($identifier)) {
             $isWithinFileMount = TRUE;
         } else {
             // Check if the identifier of the subject is within at
             // least one of the file mounts
             $writableFileMountAvailable = FALSE;
             foreach ($this->fileMounts as $fileMount) {
                 if ($this->driver->isWithin($fileMount['folder']->getIdentifier(), $identifier)) {
                     $isWithinFileMount = TRUE;
                     if (!$checkWriteAccess) {
                         break;
                     } elseif (empty($fileMount['read_only'])) {
                         $writableFileMountAvailable = TRUE;
                         break;
                     }
                 }
             }
             $isWithinFileMount = $checkWriteAccess ? $writableFileMountAvailable : $isWithinFileMount;
         }
         return $isWithinFileMount;
     }

     public function setEvaluatePermissions($evaluatePermissions) {
         $this->evaluatePermissions = (bool)$evaluatePermissions;
     }

     public function getEvaluatePermissions() {
         return $this->evaluatePermissions;
     }

     public function setUserPermissions(array $userPermissions) {
         $this->userPermissions = $userPermissions;
     }

     public function checkUserActionPermission($action, $type) {
         if (!$this->evaluatePermissions) {
             return TRUE;
         }

         $allow = FALSE;
         if (!empty($this->userPermissions[strtolower($action) . ucfirst(strtolower($type))])) {
             $allow = TRUE;
         }

         return $allow;
     }

     public function checkFileActionPermission($action, FileInterface $file) {
         $isProcessedFile = $file instanceof ProcessedFile;
         // Check 1: Does the user have permission to perform the action? e.g. "readFile"
         if (!$isProcessedFile && $this->checkUserActionPermission($action, 'File') === FALSE) {
             return FALSE;
         }
         // Check 2: No action allowed on files for denied file extensions
         if (!$this->checkFileExtensionPermission($file->getName())) {
             return FALSE;
         }
         $isReadCheck = FALSE;
         if (in_array($action, array('read', 'copy', 'move'), TRUE)) {
             $isReadCheck = TRUE;
         }
         $isWriteCheck = FALSE;
         if (in_array($action, array('add', 'write', 'move', 'rename', 'unzip', 'delete'), TRUE)) {
             $isWriteCheck = TRUE;
         }
         // Check 3: Does the user have the right to perform the action?
         // (= is he within the file mount borders)
         if (!$isProcessedFile && !$this->isWithinFileMountBoundaries($file, $isWriteCheck)) {
             return FALSE;
         }

         $isMissing = FALSE;
         if (!$isProcessedFile && $file instanceof File) {
             $isMissing = $file->isMissing();
         }

         if ($this->driver->fileExists($file->getIdentifier()) === FALSE) {
             $file->setMissing(TRUE);
             $isMissing = TRUE;
         }

         // Check 4: Check the capabilities of the storage (and the driver)
         if ($isWriteCheck && ($isMissing || !$this->isWritable())) {
             return FALSE;
         }

         // Check 5: "File permissions" of the driver (only when file isn't marked as missing)
         if (!$isMissing) {
             $filePermissions = $this->driver->getPermissions($file->getIdentifier());
             if ($isReadCheck && !$filePermissions['r']) {
                 return FALSE;
             }
             if ($isWriteCheck && !$filePermissions['w']) {
                 return FALSE;
             }
         }
         return TRUE;
     }

     public function checkFolderActionPermission($action, Folder $folder = NULL) {
         // Check 1: Does the user have permission to perform the action? e.g. "writeFolder"
         if ($this->checkUserActionPermission($action, 'Folder') === FALSE) {
             return FALSE;
         }

         // If we do not have a folder here, we cannot do further checks
         if ($folder === NULL) {
             return TRUE;
         }

         $isReadCheck = FALSE;
         if (in_array($action, array('read', 'copy'), TRUE)) {
             $isReadCheck = TRUE;
         }
         $isWriteCheck = FALSE;
         if (in_array($action, array('add', 'move', 'write', 'delete', 'rename'), TRUE)) {
             $isWriteCheck = TRUE;
         }
         // Check 2: Does the user has the right to perform the action?
         // (= is he within the file mount borders)
         if (!$this->isWithinFileMountBoundaries($folder, $isWriteCheck)) {
             return FALSE;
         }
         // Check 3: Check the capabilities of the storage (and the driver)
         if ($isReadCheck && !$this->isBrowsable()) {
             return FALSE;
         }
         if ($isWriteCheck && !$this->isWritable()) {
             return FALSE;
         }

         // Check 4: "Folder permissions" of the driver
         $folderPermissions = $this->driver->getPermissions($folder->getIdentifier());
         if ($isReadCheck && !$folderPermissions['r']) {
             return FALSE;
         }
         if ($isWriteCheck && !$folderPermissions['w']) {
             return FALSE;
         }
         return TRUE;
     }

     protected function checkFileExtensionPermission($fileName) {
         $fileName = $this->driver->sanitizeFileName($fileName);
         $isAllowed = GeneralUtility::verifyFilenameAgainstDenyPattern($fileName);
         if ($isAllowed && $this->evaluatePermissions) {
             $fileExtension = strtolower(PathUtility::pathinfo($fileName, PATHINFO_EXTENSION));
             // Set up the permissions for the file extension
             $fileExtensionPermissions = $GLOBALS['TYPO3_CONF_VARS']['BE']['fileExtensions']['webspace'];
             $fileExtensionPermissions['allow'] = GeneralUtility::uniqueList(strtolower($fileExtensionPermissions['allow']));
             $fileExtensionPermissions['deny'] = GeneralUtility::uniqueList(strtolower($fileExtensionPermissions['deny']));
             if ($fileExtension !== '') {
                 // If the extension is found amongst the allowed types, we return TRUE immediately
                 if ($fileExtensionPermissions['allow'] === '*' || GeneralUtility::inList($fileExtensionPermissions['allow'], $fileExtension)) {
                     return TRUE;
                 }
                 // If the extension is found amongst the denied types, we return FALSE immediately
                 if ($fileExtensionPermissions['deny'] === '*' || GeneralUtility::inList($fileExtensionPermissions['deny'], $fileExtension)) {
                     return FALSE;
                 }
                 // If no match we return TRUE
                 return TRUE;
             } else {
                 if ($fileExtensionPermissions['allow'] === '*') {
                     return TRUE;
                 }
                 if ($fileExtensionPermissions['deny'] === '*') {
                     return FALSE;
                 }
                 return TRUE;
             }
         }
         return $isAllowed;
     }

     protected function assureFolderReadPermission(Folder $folder = NULL) {
         if (!$this->checkFolderActionPermission('read', $folder)) {
             if ($folder === NULL) {
                 throw new Exception\InsufficientFolderAccessPermissionsException(
                     'You are not allowed to read folders',
                     1430657869
                 );
             } else {
                 throw new Exception\InsufficientFolderAccessPermissionsException(
                     'You are not allowed to access the given folder: "' . $folder->getName() . '"',
                     1375955684
                 );
             }
         }
     }

     protected function assureFolderDeletePermission(Folder $folder, $checkDeleteRecursively) {
         // Check user permissions for recursive deletion if it is requested
         if ($checkDeleteRecursively && !$this->checkUserActionPermission('recursivedelete', 'Folder')) {
             throw new Exception\InsufficientUserPermissionsException('You are not allowed to delete folders recursively', 1377779423);
         }
         // Check user action permission
         if (!$this->checkFolderActionPermission('delete', $folder)) {
             throw new Exception\InsufficientFolderAccessPermissionsException('You are not allowed to delete the given folder', 1377779039);
         }
         // Check if the user has write permissions to folders
         // Would be good if we could check for actual write permissions in the containig folder
         // but we cannot since we have no access to the containing folder of this file.
         if (!$this->checkUserActionPermission('write', 'Folder')) {
             throw new Exception\InsufficientFolderWritePermissionsException('Writing to folders is not allowed.', 1377779111);
         }
     }

     protected function assureFileReadPermission(FileInterface $file) {
         if (!$this->checkFileActionPermission('read', $file)) {
             throw new Exception\InsufficientFileAccessPermissionsException('You are not allowed to access that file.', 1375955429);
         }
         if (!$this->checkFileExtensionPermission($file->getName())) {
             throw new Exception\IllegalFileExtensionException('You are not allowed to use that file extension', 1375955430);
         }
     }

     protected function assureFileWritePermissions(FileInterface $file) {
         // Check if user is allowed to write the file and $file is writable
         if (!$this->checkFileActionPermission('write', $file)) {
             throw new Exception\InsufficientFileWritePermissionsException('Writing to file "' . $file->getIdentifier() . '" is not allowed.', 1330121088);
         }
         if (!$this->checkFileExtensionPermission($file->getName())) {
             throw new Exception\IllegalFileExtensionException('You are not allowed to edit a file with extension "' . $file->getExtension() . '"', 1366711933);
         }
     }

     protected function assureFileDeletePermissions(FileInterface $file) {
         // Check for disallowed file extensions
         if (!$this->checkFileExtensionPermission($file->getName())) {
             throw new Exception\IllegalFileExtensionException('You are not allowed to delete a file with extension "' . $file->getExtension() . '"', 1377778916);
         }
         // Check further permissions if file is not a processed file
         if (!$file instanceof ProcessedFile) {
             // Check if user is allowed to delete the file and $file is writable
             if (!$this->checkFileActionPermission('delete', $file)) {
                 throw new Exception\InsufficientFileWritePermissionsException('You are not allowed to delete the file "' . $file->getIdentifier() . '"', 1319550425);
             }
             // Check if the user has write permissions to folders
             // Would be good if we could check for actual write permissions in the containig folder
             // but we cannot since we have no access to the containing folder of this file.
             if (!$this->checkUserActionPermission('write', 'Folder')) {
                 throw new Exception\InsufficientFolderWritePermissionsException('Writing to folders is not allowed.', 1377778702);
             }
         }
     }

     protected function assureFileAddPermissions($localFilePath, $targetFolder, $targetFileName) {
         // Check for a valid file extension
         if (!$this->checkFileExtensionPermission($targetFileName)) {
             throw new Exception\IllegalFileExtensionException('Extension of file name is not allowed in "' . $targetFileName . '"!', 1322120271);
         }
         // Makes sure the user is allowed to upload
         if (!$this->checkUserActionPermission('add', 'File')) {
             throw new Exception\InsufficientUserPermissionsException('You are not allowed to add files to this storage "' . $this->getUid() . '"', 1376992145);
         }
         // Check if targetFolder is writable
         if (!$this->checkFolderActionPermission('write', $targetFolder)) {
             throw new Exception\InsufficientFolderWritePermissionsException('You are not allowed to write to the target folder "' . $targetFolder->getIdentifier() . '"', 1322120356);
         }
     }

     protected function assureFileUploadPermissions($localFilePath, $targetFolder, $targetFileName, $uploadedFileSize) {
         // Makes sure this is an uploaded file
         if (!is_uploaded_file($localFilePath)) {
             throw new Exception\UploadException('The upload has failed, no uploaded file found!', 1322110455);
         }
         // Max upload size (kb) for files.
         $maxUploadFileSize = GeneralUtility::getMaxUploadFileSize() * 1024;
         if ($uploadedFileSize >= $maxUploadFileSize) {
             unlink($localFilePath);
             throw new Exception\UploadSizeException('The uploaded file exceeds the size-limit of ' . $maxUploadFileSize . ' bytes', 1322110041);
         }
         $this->assureFileAddPermissions('', $targetFolder, $targetFileName);
     }

     protected function assureFileMovePermissions(FileInterface $file, Folder $targetFolder, $targetFileName) {
         // Check if targetFolder is within this storage
         if ($this->getUid() !== $targetFolder->getStorage()->getUid()) {
             throw new \RuntimeException();
         }
         // Check for a valid file extension
         if (!$this->checkFileExtensionPermission($targetFileName)) {
             throw new Exception\IllegalFileExtensionException('Extension of file name is not allowed in "' . $targetFileName . '"!', 1378243279);
         }
         // Check if user is allowed to move and $file is readable and writable
         if (!$file->getStorage()->checkFileActionPermission('move', $file)) {
             throw new Exception\InsufficientUserPermissionsException('You are not allowed to move files to storage "' . $this->getUid() . '"', 1319219349);
         }
         // Check if target folder is writable
         if (!$this->checkFolderActionPermission('write', $targetFolder)) {
             throw new Exception\InsufficientFolderAccessPermissionsException('You are not allowed to write to the target folder "' . $targetFolder->getIdentifier() . '"', 1319219350);
         }
     }

     protected function assureFileRenamePermissions(FileInterface $file, $targetFileName) {
         // Check if file extension is allowed
         if (!$this->checkFileExtensionPermission($targetFileName) || !$this->checkFileExtensionPermission($file->getName())) {
             throw new Exception\IllegalFileExtensionException('You are not allowed to rename a file with to this extension', 1371466663);
         }
         // Check if user is allowed to rename
         if (!$this->checkFileActionPermission('rename', $file)) {
             throw new Exception\InsufficientUserPermissionsException('You are not allowed to rename files."', 1319219351);
         }
         // Check if the user is allowed to write to folders
         // Although it would be good to check, we cannot check here if the folder actually is writable
         // because we do not know in which folder the file resides.
         // So we rely on the driver to throw an exception in case the renaming failed.
         if (!$this->checkFolderActionPermission('write')) {
             throw new Exception\InsufficientFileWritePermissionsException('You are not allowed to write to folders', 1319219352);
         }
     }

     protected function assureFileCopyPermissions(FileInterface $file, Folder $targetFolder, $targetFileName) {
         // Check if targetFolder is within this storage, this should never happen
         if ($this->getUid() != $targetFolder->getStorage()->getUid()) {
             throw new Exception('The operation of the folder cannot be called by this storage "' . $this->getUid() . '"', 1319550405);
         }
         // Check if user is allowed to copy
         if (!$file->getStorage()->checkFileActionPermission('copy', $file)) {
             throw new Exception\InsufficientFileReadPermissionsException('You are not allowed to copy the file "' . $file->getIdentifier() . '"', 1319550426);
         }
         // Check if targetFolder is writable
         if (!$this->checkFolderActionPermission('write', $targetFolder)) {
             throw new Exception\InsufficientFolderWritePermissionsException('You are not allowed to write to the target folder "' . $targetFolder->getIdentifier() . '"', 1319550435);
         }
         // Check for a valid file extension
         if (!$this->checkFileExtensionPermission($targetFileName) || !$this->checkFileExtensionPermission($file->getName())) {
             throw new Exception\IllegalFileExtensionException('You are not allowed to copy a file of that type.', 1319553317);
         }
     }

     protected function assureFolderCopyPermissions(FolderInterface $folderToCopy, FolderInterface $targetParentFolder) {
         // Check if targetFolder is within this storage, this should never happen
         if ($this->getUid() !== $targetParentFolder->getStorage()->getUid()) {
             throw new Exception('The operation of the folder cannot be called by this storage "' . $this->getUid() . '"', 1377777624);
         }
         if (!$folderToCopy instanceof Folder) {
             throw new \RuntimeException('The folder "' . $folderToCopy->getIdentifier() . '" to copy is not of type Folder.', 1384209020);
         }
         // Check if user is allowed to copy and the folder is readable
         if (!$folderToCopy->getStorage()->checkFolderActionPermission('copy', $folderToCopy)) {
             throw new Exception\InsufficientFileReadPermissionsException('You are not allowed to copy the folder "' . $folderToCopy->getIdentifier() . '"', 1377777629);
         }
         if (!$targetParentFolder instanceof Folder) {
             throw new \RuntimeException('The target folder "' . $targetParentFolder->getIdentifier() . '" is not of type Folder.', 1384209021);
         }
         // Check if targetFolder is writable
         if (!$this->checkFolderActionPermission('write', $targetParentFolder)) {
             throw new Exception\InsufficientFolderWritePermissionsException('You are not allowed to write to the target folder "' . $targetParentFolder->getIdentifier() . '"', 1377777635);
         }
     }

     protected function assureFolderMovePermissions(FolderInterface $folderToMove, FolderInterface $targetParentFolder) {
         // Check if targetFolder is within this storage, this should never happen
         if ($this->getUid() !== $targetParentFolder->getStorage()->getUid()) {
             throw new \InvalidArgumentException('Cannot move a folder into a folder that does not belong to this storage.', 1325777289);
         }
         if (!$folderToMove instanceof Folder) {
             throw new \RuntimeException('The folder "' . $folderToMove->getIdentifier() . '" to move is not of type Folder.', 1384209022);
         }
         // Check if user is allowed to move and the folder is writable
         // In fact we would need to check if the parent folder of the folder to move is writable also
         // But as of now we cannot extract the parent folder from this folder
         if (!$folderToMove->getStorage()->checkFolderActionPermission('move', $folderToMove)) {
             throw new Exception\InsufficientFileReadPermissionsException('You are not allowed to copy the folder "' . $folderToMove->getIdentifier() . '"', 1377778045);
         }
         if (!$targetParentFolder instanceof Folder) {
             throw new \RuntimeException('The target folder "' . $targetParentFolder->getIdentifier() . '" is not of type Folder.', 1384209023);
         }
         // Check if targetFolder is writable
         if (!$this->checkFolderActionPermission('write', $targetParentFolder)) {
             throw new Exception\InsufficientFolderWritePermissionsException('You are not allowed to write to the target folder "' . $targetParentFolder->getIdentifier() . '"', 1377778049);
         }
     }

     /********************
      * FILE ACTIONS
      ********************/
     public function addFile($localFilePath, Folder $targetFolder, $targetFileName = '', $conflictMode = 'changeName') {
         $localFilePath = PathUtility::getCanonicalPath($localFilePath);
         // File is not available locally NOR is it an uploaded file
         if (!is_uploaded_file($localFilePath) && !file_exists($localFilePath)) {
             throw new \InvalidArgumentException('File "' . $localFilePath . '" does not exist.', 1319552745);
         }
         $targetFolder = $targetFolder ?: $this->getDefaultFolder();
         $targetFileName = $this->driver->sanitizeFileName($targetFileName ?: PathUtility::basename($localFilePath));
         $this->assureFileAddPermissions('', $targetFolder, $targetFileName);

         // We do not care whether the file exists yet because $targetFileName may be changed by an
         // external slot and only then we should check how to proceed according to $conflictMode
         $targetFileName = $this->emitPreFileAddSignal($targetFileName, $targetFolder, $localFilePath);

         if ($conflictMode === 'cancel' && $this->driver->fileExistsInFolder($targetFileName, $targetFolder->getIdentifier())) {
             throw new Exception\ExistingTargetFileNameException('File "' . $targetFileName . '" already exists in folder ' . $targetFolder->getIdentifier(), 1322121068);
         } elseif ($conflictMode === 'changeName') {
             $targetFileName = $this->getUniqueName($targetFolder, $targetFileName);
         }

         $fileIdentifier = $this->driver->addFile($localFilePath, $targetFolder->getIdentifier(), $targetFileName);
         $file = ResourceFactory::getInstance()->getFileObjectByStorageAndIdentifier($this->getUid(), $fileIdentifier);

         $this->emitPostFileAddSignal($file, $targetFolder);

         return $file;
     }

     public function updateProcessedFile($localFilePath, ProcessedFile $processedFile, Folder $processingFolder = NULL) {
         if (!file_exists($localFilePath)) {
             throw new \InvalidArgumentException('File "' . $localFilePath . '" does not exist.', 1319552746);
         }
         if ($processingFolder === NULL) {
             $processingFolder = $this->getProcessingFolder();
         }
         $fileIdentifier = $this->driver->addFile($localFilePath, $processingFolder->getIdentifier(), $processedFile->getName());

         // @todo check if we have to update the processed file other then the identifier
         $processedFile->setIdentifier($fileIdentifier);
         return $processedFile;
     }

     public function hashFile(FileInterface $fileObject, $hash) {
         return $this->hashFileByIdentifier($fileObject->getIdentifier(), $hash);
     }

     public function hashFileByIdentifier($fileIdentifier, $hash) {
         return $this->driver->hash($fileIdentifier, $hash);
     }

     public function hashFileIdentifier($file) {
         if (is_object($file) && $file instanceof FileInterface) {
             $file = $file->getIdentifier();
         }
         return $this->driver->hashIdentifier($file);
     }

     public function getPublicUrl(ResourceInterface $resourceObject, $relativeToCurrentScript = FALSE) {
         $publicUrl = NULL;
         if ($this->isOnline()) {
             // Pre-process the public URL by an accordant slot
             $this->emitPreGeneratePublicUrlSignal($resourceObject, $relativeToCurrentScript, array('publicUrl' => &$publicUrl));
             // If slot did not handle the signal, use the default way to determine public URL
             if ($publicUrl === NULL) {

                 if ($this->hasCapability(self::CAPABILITY_PUBLIC)) {
                     $publicUrl = $this->driver->getPublicUrl($resourceObject->getIdentifier());
                 }

                 if ($publicUrl === NULL && $resourceObject instanceof FileInterface) {
                     $queryParameterArray = array('eID' => 'dumpFile', 't' => '');
                     if ($resourceObject instanceof File) {
                         $queryParameterArray['f'] = $resourceObject->getUid();
                         $queryParameterArray['t'] = 'f';
                     } elseif ($resourceObject instanceof ProcessedFile) {
                         $queryParameterArray['p'] = $resourceObject->getUid();
                         $queryParameterArray['t'] = 'p';
                     }

                     $queryParameterArray['token'] = GeneralUtility::hmac(implode('|', $queryParameterArray), 'resourceStorageDumpFile');
                     $publicUrl = 'index.php?' . str_replace('+', '%20', http_build_query($queryParameterArray));
                 }

                 // If requested, make the path relative to the current script in order to make it possible
                 // to use the relative file
                 if ($publicUrl !== NULL && $relativeToCurrentScript && !GeneralUtility::isValidUrl($publicUrl)) {
                     $absolutePathToContainingFolder = PathUtility::dirname(PATH_site . $publicUrl);
                     $pathPart = PathUtility::getRelativePathTo($absolutePathToContainingFolder);
                     $filePart = substr(PATH_site . $publicUrl, strlen($absolutePathToContainingFolder) + 1);
                     $publicUrl = $pathPart . $filePart;
                 }
             }
         }
         return $publicUrl;
     }

     public function processFile(FileInterface $fileObject, $context, array $configuration) {
         if ($fileObject->getStorage() !== $this) {
             throw new \InvalidArgumentException('Cannot process files of foreign storage', 1353401835);
         }
         $processedFile = $this->getFileProcessingService()->processFile($fileObject, $this, $context, $configuration);

         return $processedFile;
     }

     public function getFileForLocalProcessing(FileInterface $fileObject, $writable = TRUE) {
         $filePath = $this->driver->getFileForLocalProcessing($fileObject->getIdentifier(), $writable);
         return $filePath;
     }

     public function getFile($identifier) {
         $file = $this->getFileFactory()->getFileObjectByStorageAndIdentifier($this->getUid(), $identifier);
         if (!$this->driver->fileExists($identifier)) {
             $file->setMissing(TRUE);
         }
         return $file;
     }

     public function getFileInfo(FileInterface $fileObject) {
         return $this->getFileInfoByIdentifier($fileObject->getIdentifier());
     }

     public function getFileInfoByIdentifier($identifier, array $propertiesToExtract = array()) {
         return $this->driver->getFileInfoByIdentifier($identifier, $propertiesToExtract);
     }

     public function unsetFileAndFolderNameFilters() {
         $this->fileAndFolderNameFilters = array();
     }

     public function resetFileAndFolderNameFiltersToDefault() {
         $this->fileAndFolderNameFilters = $GLOBALS['TYPO3_CONF_VARS']['SYS']['fal']['defaultFilterCallbacks'];
     }

     public function getFileAndFolderNameFilters() {
         return $this->fileAndFolderNameFilters;
     }

     public function setFileAndFolderNameFilters(array $filters) {
         $this->fileAndFolderNameFilters = $filters;
         return $this;
     }

     public function addFileAndFolderNameFilter($filter) {
         $this->fileAndFolderNameFilters[] = $filter;
     }

     public function getFolderIdentifierFromFileIdentifier($fileIdentifier) {
         return $this->driver->getParentFolderIdentifierOfIdentifier($fileIdentifier);
     }

     public function getFileList($path, $start = 0, $numberOfItems = 0, $useFilters = TRUE, $loadIndexRecords = TRUE, $recursive = FALSE) {
         GeneralUtility::logDeprecatedFunction();
         return $this->getFilesInFolder($this->getFolder($path), $start, $numberOfItems, $useFilters, $recursive);
     }

     public function getFilesInFolder(Folder $folder, $start = 0, $maxNumberOfItems = 0, $useFilters = TRUE, $recursive = FALSE) {
         $this->assureFolderReadPermission($folder);

         $rows = $this->getFileIndexRepository()->findByFolder($folder);

         $filters = $useFilters == TRUE ? $this->fileAndFolderNameFilters : array();
         $fileIdentifiers = array_values($this->driver->getFilesInFolder($folder->getIdentifier(), $start, $maxNumberOfItems, $recursive, $filters));
         $fileIdentifiersCount = count($fileIdentifiers);
         $items = array();
         if ($maxNumberOfItems === 0) {
             $maxNumberOfItems = $fileIdentifiersCount;
         }
         $end = min($fileIdentifiersCount, $start + $maxNumberOfItems);
         for ($i = $start; $i < $end; $i++) {
             $identifier = $fileIdentifiers[$i];
             if (isset($rows[$identifier])) {
                 $fileObject = $this->getFileFactory()->getFileObject($rows[$identifier]['uid'], $rows[$identifier]);
             } else {
                 $fileObject = $this->getFileFactory()->getFileObjectByStorageAndIdentifier($this->getUid(), $identifier);
             }
             if ($fileObject instanceof FileInterface) {
                 $key = $fileObject->getName();
                 while (isset($items[$key])) {
                     $key .= 'z';
                 }
                 $items[$key] = $fileObject;
             }
         }
         uksort($items, 'strnatcasecmp');

         return $items;
     }

     public function getFileIdentifiersInFolder($folderIdentifier, $useFilters = TRUE, $recursive = FALSE) {
         $filters = $useFilters == TRUE ? $this->fileAndFolderNameFilters : array();
         return $this->driver->getFilesInFolder($folderIdentifier, 0, 0, $recursive, $filters);
     }

     public function getFolderIdentifiersInFolder($folderIdentifier, $useFilters = TRUE, $recursive = FALSE) {
         $filters = $useFilters == TRUE ? $this->fileAndFolderNameFilters : array();
         return $this->driver->getFoldersInFolder($folderIdentifier, 0, 0, $recursive, $filters);
     }

     public function hasFile($identifier) {
         // Allow if identifier is in processing folder
         if (!$this->isWithinProcessingFolder($identifier)) {
             $this->assureFolderReadPermission();
         }
         return $this->driver->fileExists($identifier);
     }

     public function getProcessingFolders() {
         if ($this->processingFolders === NULL) {
             $this->processingFolders = array();
             $this->processingFolders[] = $this->getProcessingFolder();
             $storageRepository = GeneralUtility::makeInstance('TYPO3\\CMS\\Core\\Resource\\StorageRepository');
             $allStorages = $storageRepository->findAll();
             foreach ($allStorages as $storage) {
                 // To circumvent the permission check of the folder, we use the factory to create it "manually" instead of directly using $storage->getProcessingFolder()
                 // See #66695 for details
                 $storageRecord = $storage->getStorageRecord();
                 list($storageUid, $processingFolderIdentifier) = GeneralUtility::trimExplode(':', $storageRecord['processingfolder']);
                 if (empty($processingFolderIdentifier) || (int)$storageUid !== $this->getUid()) {
                     continue;
                 }
                 $potentialProcessingFolder = ResourceFactory::getInstance()->getInstance()->createFolderObject($this, $processingFolderIdentifier, $processingFolderIdentifier);
                 if ($potentialProcessingFolder->getStorage() === $this && $potentialProcessingFolder->getIdentifier() !== $this->getProcessingFolder()->getIdentifier()) {
                     $this->processingFolders[] = $potentialProcessingFolder;
                 }
             }
         }

         return $this->processingFolders;
     }

     public function isProcessingFolder(Folder $folder) {
         $isProcessingFolder = FALSE;
         foreach ($this->getProcessingFolders() as $processingFolder) {
             if ($folder->getCombinedIdentifier() === $processingFolder->getCombinedIdentifier()) {
                 $isProcessingFolder = TRUE;
                 break;
             }
         }
         return $isProcessingFolder;
     }

     public function hasFileInFolder($fileName, Folder $folder) {
         $this->assureFolderReadPermission($folder);
         return $this->driver->fileExistsInFolder($fileName, $folder->getIdentifier());
     }

     public function getFileContents($file) {
         $this->assureFileReadPermission($file);
         return $this->driver->getFileContents($file->getIdentifier());
     }

     public function dumpFileContents(FileInterface $file, $asDownload = FALSE, $alternativeFilename = NULL) {
         $downloadName = $alternativeFilename ?: $file->getName();
         $contentDisposition = $asDownload ? 'attachment' : 'inline';
         header('Content-Disposition: ' . $contentDisposition . '; filename="' . $downloadName . '"');
         header('Content-Type: ' . $file->getMimeType());
         header('Content-Length: ' . $file->getSize());

         // Cache-Control header is needed here to solve an issue with browser IE8 and lower
         // See for more information: http://support.microsoft.com/kb/323308
         header("Cache-Control: ''");
         header('Last-Modified: ' .
             gmdate('D, d M Y H:i:s', array_pop($this->driver->getFileInfoByIdentifier($file->getIdentifier(), array('mtime')))) . ' GMT',
             TRUE,
             200
         );
         ob_clean();
         flush();
         while (ob_get_level() > 0) {
             ob_end_clean();
         }
         $this->driver->dumpFileContents($file->getIdentifier());
     }

     public function setFileContents(AbstractFile $file, $contents) {
         // Check if user is allowed to edit
         $this->assureFileWritePermissions($file);
         // Call driver method to update the file and update file index entry afterwards
         $result = $this->driver->setFileContents($file->getIdentifier(), $contents);
         $this->getIndexer()->updateIndexEntry($file);
         $this->emitPostFileSetContentsSignal($file, $contents);
         return $result;
     }

     public function createFile($fileName, Folder $targetFolderObject) {
         $this->assureFileAddPermissions('', $targetFolderObject, $fileName);
         $newFileIdentifier = $this->driver->createFile($fileName, $targetFolderObject->getIdentifier());
         $this->emitPostFileCreateSignal($newFileIdentifier, $targetFolderObject);
         return ResourceFactory::getInstance()->getFileObjectByStorageAndIdentifier($this->getUid(), $newFileIdentifier);
     }

     public function deleteFile($fileObject) {
         $this->assureFileDeletePermissions($fileObject);

         $this->emitPreFileDeleteSignal($fileObject);

         if ($this->driver->fileExists($fileObject->getIdentifier())) {
             $result = $this->driver->deleteFile($fileObject->getIdentifier());
             if (!$result) {
                 throw new Exception\FileOperationErrorException('Deleting the file "' . $fileObject->getIdentifier() . '\' failed.', 1329831691);
             }
         }
         // Mark the file object as deleted
         if ($fileObject instanceof File) {
             $fileObject->setDeleted();
         }

         $this->emitPostFileDeleteSignal($fileObject);

         return TRUE;
     }

     public function copyFile(FileInterface $file, Folder $targetFolder, $targetFileName = NULL, $conflictMode = 'renameNewFile') {
         if ($targetFileName === NULL) {
             $targetFileName = $file->getName();
         }
         $sanitizedTargetFileName = $this->driver->sanitizeFileName($targetFileName);
         $this->assureFileCopyPermissions($file, $targetFolder, $sanitizedTargetFileName);
         $this->emitPreFileCopySignal($file, $targetFolder);
         // File exists and we should abort, let's abort
         if ($conflictMode === 'cancel' && $targetFolder->hasFile($sanitizedTargetFileName)) {
             throw new Exception\ExistingTargetFileNameException('The target file already exists.', 1320291064);
         }
         // File exists and we should find another name, let's find another one
         if ($conflictMode === 'renameNewFile' && $targetFolder->hasFile($sanitizedTargetFileName)) {
             $sanitizedTargetFileName = $this->getUniqueName($targetFolder, $sanitizedTargetFileName);
         }
         $sourceStorage = $file->getStorage();
         // Call driver method to create a new file from an existing file object,
         // and return the new file object
         if ($sourceStorage === $this) {
             $newFileObjectIdentifier = $this->driver->copyFileWithinStorage($file->getIdentifier(), $targetFolder->getIdentifier(), $sanitizedTargetFileName);
         } else {
             $tempPath = $file->getForLocalProcessing();
             $newFileObjectIdentifier = $this->driver->addFile($tempPath, $targetFolder->getIdentifier(), $sanitizedTargetFileName);
         }
         $newFileObject = ResourceFactory::getInstance()->getFileObjectByStorageAndIdentifier($this->getUid(), $newFileObjectIdentifier);
         $this->emitPostFileCopySignal($file, $targetFolder);
         return $newFileObject;
     }

     public function moveFile($file, $targetFolder, $targetFileName = NULL, $conflictMode = 'renameNewFile') {
         if ($targetFileName === NULL) {
             $targetFileName = $file->getName();
         }
         $originalFolder = $file->getParentFolder();
         $sanitizedTargetFileName = $this->driver->sanitizeFileName($targetFileName);
         $this->assureFileMovePermissions($file, $targetFolder, $sanitizedTargetFileName);
         if ($targetFolder->hasFile($sanitizedTargetFileName)) {
             // File exists and we should abort, let's abort
             if ($conflictMode === 'renameNewFile') {
                 $sanitizedTargetFileName = $this->getUniqueName($targetFolder, $sanitizedTargetFileName);
             } elseif ($conflictMode === 'cancel') {
                 throw new Exception\ExistingTargetFileNameException('The target file already exists', 1329850997);
             }
         }
         $this->emitPreFileMoveSignal($file, $targetFolder);
         $sourceStorage = $file->getStorage();
         // Call driver method to move the file and update the index entry
         try {
             if ($sourceStorage === $this) {
                 $newIdentifier = $this->driver->moveFileWithinStorage($file->getIdentifier(), $targetFolder->getIdentifier(), $sanitizedTargetFileName);
                 if (!$file instanceof AbstractFile) {
                     throw new \RuntimeException('The given file is not of type AbstractFile.', 1384209025);
                 }
                 $file->updateProperties(array('identifier' => $newIdentifier));
             } else {
                 $tempPath = $file->getForLocalProcessing();
                 $newIdentifier = $this->driver->addFile($tempPath, $targetFolder->getIdentifier(), $sanitizedTargetFileName);
                 $sourceStorage->driver->deleteFile($file->getIdentifier());
                 if ($file instanceof File) {
                     $file->updateProperties(array('storage' => $this->getUid(), 'identifier' => $newIdentifier));
                 }
             }
             $this->getIndexer()->updateIndexEntry($file);
         } catch (\TYPO3\CMS\Core\Exception $e) {
             echo $e->getMessage();
         }
         $this->emitPostFileMoveSignal($file, $targetFolder, $originalFolder);
         return $file;
     }

     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;
     }

     public function replaceFile(FileInterface $file, $localFilePath) {
         $this->assureFileWritePermissions($file);
         if (!file_exists($localFilePath)) {
             throw new \InvalidArgumentException('File "' . $localFilePath . '" does not exist.', 1325842622);
         }
         $this->emitPreFileReplaceSignal($file, $localFilePath);
         $result = $this->driver->replaceFile($file->getIdentifier(), $localFilePath);
         if ($file instanceof File) {
             $this->getIndexer()->updateIndexEntry($file);
         }
         $this->emitPostFileReplaceSignal($file, $localFilePath);
         return $result;
     }

     public function addUploadedFile(array $uploadedFileData, Folder $targetFolder = NULL, $targetFileName = NULL, $conflictMode = 'cancel') {
         $localFilePath = $uploadedFileData['tmp_name'];
         if ($targetFolder === NULL) {
             $targetFolder = $this->getDefaultFolder();
         }
         if ($targetFileName === NULL) {
             $targetFileName = $uploadedFileData['name'];
         }
         // Handling $conflictMode is delegated to addFile()
         $this->assureFileUploadPermissions($localFilePath, $targetFolder, $targetFileName, $uploadedFileData['size']);
         $resultObject = $this->addFile($localFilePath, $targetFolder, $targetFileName, $conflictMode);
         return $resultObject;
     }

     /********************
      * FOLDER ACTIONS
      ********************/
     protected function getAllFileObjectsInFolder(Folder $folder) {
         $files = array();
         $folderQueue = array($folder);
         while (!empty($folderQueue)) {
             $folder = array_shift($folderQueue);
             foreach ($folder->getSubfolders() as $subfolder) {
                 $folderQueue[] = $subfolder;
             }
             foreach ($folder->getFiles() as $file) {
                 $files[$file->getIdentifier()] = $file;
             }
         }

         return $files;
     }

     public function moveFolder(Folder $folderToMove, Folder $targetParentFolder, $newFolderName = NULL, $conflictMode = 'renameNewFolder') {
         // TODO add tests
         $originalFolder = $folderToMove->getParentFolder();
         $this->assureFolderMovePermissions($folderToMove, $targetParentFolder);
         $sourceStorage = $folderToMove->getStorage();
         $returnObject = NULL;
         $sanitizedNewFolderName = $this->driver->sanitizeFileName($newFolderName ?: $folderToMove->getName());
         // TODO check if folder already exists in $targetParentFolder, handle this conflict then
         $this->emitPreFolderMoveSignal($folderToMove, $targetParentFolder, $sanitizedNewFolderName);
         // Get all file objects now so we are able to update them after moving the folder
         $fileObjects = $this->getAllFileObjectsInFolder($folderToMove);
         if ($sourceStorage === $this) {
             if ($this->isWithinFolder($folderToMove, $targetParentFolder)) {
                 throw new InvalidTargetFolderException(
                     sprintf(
                         'Cannot move folder "%s" into target folder "%s", because the target folder is already within the folder to be moved!',
                         $folderToMove->getName(),
                         $targetParentFolder->getName()
                     ),
                     1422723050
                 );
             }
             $fileMappings = $this->driver->moveFolderWithinStorage($folderToMove->getIdentifier(), $targetParentFolder->getIdentifier(), $sanitizedNewFolderName);
         } else {
             $fileMappings = $this->moveFolderBetweenStorages($folderToMove, $targetParentFolder, $sanitizedNewFolderName);
         }
         // Update the identifier and storage of all file objects
         foreach ($fileObjects as $oldIdentifier => $fileObject) {
             $newIdentifier = $fileMappings[$oldIdentifier];
             $fileObject->updateProperties(array('storage' => $this->getUid(), 'identifier' => $newIdentifier));
             $this->getIndexer()->updateIndexEntry($fileObject);
         }
         $returnObject = $this->getFolder($fileMappings[$folderToMove->getIdentifier()]);
         $this->emitPostFolderMoveSignal($folderToMove, $targetParentFolder, $returnObject->getName(), $originalFolder);
         return $returnObject;
     }

     protected function moveFolderBetweenStorages(Folder $folderToMove, Folder $targetParentFolder, $newFolderName) {
         throw new \RuntimeException('Not yet implemented');
     }

     public function copyFolder(FolderInterface $folderToCopy, FolderInterface $targetParentFolder, $newFolderName = NULL, $conflictMode = 'renameNewFolder') {
         // TODO implement the $conflictMode handling
         $this->assureFolderCopyPermissions($folderToCopy, $targetParentFolder);
         $returnObject = NULL;
         $sanitizedNewFolderName = $this->driver->sanitizeFileName($newFolderName ?: $folderToCopy->getName());
         if ($folderToCopy instanceof Folder && $targetParentFolder instanceof Folder) {
             $this->emitPreFolderCopySignal($folderToCopy, $targetParentFolder, $sanitizedNewFolderName);
         }
         $sourceStorage = $folderToCopy->getStorage();
         // call driver method to move the file
         // that also updates the file object properties
         if ($sourceStorage === $this) {
             if ($this->isWithinFolder($folderToCopy, $targetParentFolder)) {
                 throw new InvalidTargetFolderException(
                     sprintf(
                         'Cannot copy folder "%s" into target folder "%s", because the target folder is already within the folder to be copied!',
                         $folderToCopy->getName(),
                         $targetParentFolder->getName()
                     ),
                     1422723059
                 );
             }
             $this->driver->copyFolderWithinStorage($folderToCopy->getIdentifier(), $targetParentFolder->getIdentifier(), $sanitizedNewFolderName);
             $returnObject = $this->getFolder($targetParentFolder->getSubfolder($sanitizedNewFolderName)->getIdentifier());
         } else {
             $this->copyFolderBetweenStorages($folderToCopy, $targetParentFolder, $sanitizedNewFolderName);
         }
         $this->emitPostFolderCopySignal($folderToCopy, $targetParentFolder, $returnObject->getName());
         return $returnObject;
     }

     protected function copyFolderBetweenStorages(Folder $folderToCopy, Folder $targetParentFolder, $newFolderName) {
         throw new \RuntimeException('Not yet implemented.');
     }

     public function renameFolder($folderObject, $newName) {

         // Renaming the folder should check if the parent folder is writable
         // We cannot do this however because we cannot extract the parent folder from a folder currently
         if (!$this->checkFolderActionPermission('rename', $folderObject)) {
             throw new Exception\InsufficientUserPermissionsException('You are not allowed to rename the folder "' . $folderObject->getIdentifier() . '\'', 1357811441);
         }

         $sanitizedNewName = $this->driver->sanitizeFileName($newName);
         $returnObject = NULL;
         if ($this->driver->folderExistsInFolder($sanitizedNewName, $folderObject->getIdentifier())) {
             throw new \InvalidArgumentException('The folder ' . $sanitizedNewName . ' already exists in folder ' . $folderObject->getIdentifier(), 1325418870);
         }

         $this->emitPreFolderRenameSignal($folderObject, $sanitizedNewName);

         $fileObjects = $this->getAllFileObjectsInFolder($folderObject);
         $fileMappings = $this->driver->renameFolder($folderObject->getIdentifier(), $sanitizedNewName);
         // Update the identifier of all file objects
         foreach ($fileObjects as $oldIdentifier => $fileObject) {
             $newIdentifier = $fileMappings[$oldIdentifier];
             $fileObject->updateProperties(array('identifier' => $newIdentifier));
             $this->getIndexer()->updateIndexEntry($fileObject);
         }
         $returnObject = $this->getFolder($fileMappings[$folderObject->getIdentifier()]);

         $this->emitPostFolderRenameSignal($folderObject, $returnObject->getName());

         return $returnObject;
     }

     public function deleteFolder($folderObject, $deleteRecursively = FALSE) {
         $isEmpty = $this->driver->isFolderEmpty($folderObject->getIdentifier());
         $this->assureFolderDeletePermission($folderObject, ($deleteRecursively && !$isEmpty));
         if (!$isEmpty && !$deleteRecursively) {
             throw new \RuntimeException('Could not delete folder "' . $folderObject->getIdentifier() . '" because it is not empty.', 1325952534);
         }

         $this->emitPreFolderDeleteSignal($folderObject);

         foreach ($this->getFilesInFolder($folderObject, 0, 0, FALSE, $deleteRecursively) as $file) {
             $this->deleteFile($file);
         }

         $result = $this->driver->deleteFolder($folderObject->getIdentifier(), $deleteRecursively);

         $this->emitPostFolderDeleteSignal($folderObject);

         return $result;
     }

     public function getFolderList($path, $start = 0, $numberOfItems = 0, $useFilters = TRUE) {
         GeneralUtility::logDeprecatedFunction();
         // Permissions are checked in $this->fetchFolderListFromDriver()
         $filters = $useFilters === TRUE ? $this->fileAndFolderNameFilters : array();
         return $this->fetchFolderListFromDriver($path, $start, $numberOfItems, $filters);
     }

     public function getFoldersInFolder(Folder $folder, $start = 0, $maxNumberOfItems = 0, $useFilters = TRUE, $recursive = FALSE) {
         $filters = $useFilters == TRUE ? $this->fileAndFolderNameFilters : array();
         $folderIdentifiers = $this->driver->getFoldersInFolder($folder->getIdentifier(), $start, $maxNumberOfItems, $recursive, $filters);

         // Exclude processing folders
         foreach ($this->getProcessingFolders() as $processingFolder) {
             $processingIdentifier = $processingFolder->getIdentifier();
             if (isset($folderIdentifiers[$processingIdentifier])) {
                 unset($folderIdentifiers[$processingIdentifier]);
             }
         }
         $folders = array();
         foreach ($folderIdentifiers as $folderIdentifier) {
             $folders[$folderIdentifier] = $this->getFolder($folderIdentifier, TRUE);
         }
         return $folders;
     }

     public function fetchFolderListFromDriver($path, $start = 0, $numberOfItems = 0, array $folderFilterCallbacks = array(), $recursive = FALSE) {
         GeneralUtility::logDeprecatedFunction();
         // This also checks for access to that path and throws exceptions accordingly
         $parentFolder = $this->getFolder($path);
         if ($parentFolder === NULL) {
             return array();
         }
         $folders = $this->getFoldersInFolder($parentFolder, $start, $numberOfItems, count($folderFilterCallbacks) > 0, $recursive);
         $folderInfo = array();
         foreach ($folders as $folder) {
             $folderInfo[$folder->getIdentifier()] = array(
                 'name' => $folder->getName(),
                 'identifier' => $folder->getIdentifier()
             );
         }
         return $folderInfo;
     }

     public function hasFolder($identifier) {
         $this->assureFolderReadPermission();
         return $this->driver->folderExists($identifier);
     }

     public function hasFolderInFolder($folderName, Folder $folder) {
         $this->assureFolderReadPermission($folder);
         return $this->driver->folderExistsInFolder($folderName, $folder->getIdentifier());
     }

     public function createFolder($folderName, Folder $parentFolder = NULL) {
         if ($parentFolder === NULL) {
             $parentFolder = $this->getRootLevelFolder();
         } elseif (!$this->driver->folderExists($parentFolder->getIdentifier())) {
             throw new \InvalidArgumentException('Parent folder "' . $parentFolder->getIdentifier() . '" does not exist.', 1325689164);
         }
         if (!$this->checkFolderActionPermission('add', $parentFolder)) {
             throw new Exception\InsufficientFolderWritePermissionsException('You are not allowed to create directories in the folder "' . $parentFolder->getIdentifier() . '"', 1323059807);
         }

         $this->emitPreFolderAddSignal($parentFolder, $folderName);

         $newFolder = $this->getDriver()->createFolder($folderName, $parentFolder->getIdentifier(), TRUE);
         $newFolder = $this->getFolder($newFolder);

         $this->emitPostFolderAddSignal($newFolder);

         return $newFolder;
     }

     public function getDefaultFolder() {
         return $this->getFolder($this->driver->getDefaultFolder());
     }

     public function getFolder($identifier, $returnInaccessibleFolderObject = FALSE) {

         $data = $this->driver->getFolderInfoByIdentifier($identifier);
         $folder = ResourceFactory::getInstance()->createFolderObject($this, $data['identifier'], $data['name']);

         try {
             $this->assureFolderReadPermission($folder);
         } catch (Exception\InsufficientFolderAccessPermissionsException $e) {
             $folder = NULL;
             if ($returnInaccessibleFolderObject) {
                 // if parent folder is readable return inaccessible folder object
                 $parentPermissions = $this->driver->getPermissions($this->driver->getParentFolderIdentifierOfIdentifier($identifier));
                 if ($parentPermissions['r']) {
                     $folder = GeneralUtility::makeInstance(
                         'TYPO3\\CMS\\Core\\Resource\\InaccessibleFolder', $this, $data['identifier'], $data['name']
                     );
                 }
             }

             if ($folder === NULL) {
                 throw $e;
             }
         }
         return $folder;
     }

     public function isWithinProcessingFolder($identifier) {
         $inProcessingFolder = FALSE;
         foreach ($this->getProcessingFolders() as $processingFolder) {
             if ($this->driver->isWithin($processingFolder->getIdentifier(), $identifier)) {
                 $inProcessingFolder = TRUE;
                 break;
             }
         }
         return $inProcessingFolder;
     }

     public function isWithinFolder(Folder $folder, ResourceInterface $resource) {
         if ($folder->getStorage() !== $this) {
             throw new \InvalidArgumentException('Given folder "' . $folder->getIdentifier() . '" is not part of this storage!', 1422709241);
         }
         if ($folder->getStorage() !== $resource->getStorage()) {
             return FALSE;
         }
         return $this->driver->isWithin($folder->getIdentifier(), $resource->getIdentifier());
     }

     public function getRootLevelFolder($respectFileMounts = TRUE) {
         if ($respectFileMounts && count($this->fileMounts)) {
             $mount = reset($this->fileMounts);
             return $mount['folder'];
         } else {
             return ResourceFactory::getInstance()->createFolderObject($this, $this->driver->getRootLevelFolder(), '');
         }
     }

     protected function emitPreFileAddSignal($targetFileName, Folder $targetFolder, $sourceFilePath) {
         $this->getSignalSlotDispatcher()->dispatch('TYPO3\\CMS\\Core\\Resource\\ResourceStorage', self::SIGNAL_PreFileAdd, array(&$targetFileName, $targetFolder, $sourceFilePath, $this, $this->driver));
         return $targetFileName;
     }

     protected function emitPostFileAddSignal(FileInterface $file, Folder $targetFolder) {
         $this->getSignalSlotDispatcher()->dispatch('TYPO3\\CMS\\Core\\Resource\\ResourceStorage', self::SIGNAL_PostFileAdd, array($file, $targetFolder));
     }

     protected function emitPreFileCopySignal(FileInterface $file, Folder $targetFolder) {
         $this->getSignalSlotDispatcher()->dispatch('TYPO3\\CMS\\Core\\Resource\\ResourceStorage', self::SIGNAL_PreFileCopy, array($file, $targetFolder));
     }

     protected function emitPostFileCopySignal(FileInterface $file, Folder $targetFolder) {
         $this->getSignalSlotDispatcher()->dispatch('TYPO3\\CMS\\Core\\Resource\\ResourceStorage', self::SIGNAL_PostFileCopy, array($file, $targetFolder));
     }

     protected function emitPreFileMoveSignal(FileInterface $file, Folder $targetFolder) {
         $this->getSignalSlotDispatcher()->dispatch('TYPO3\\CMS\\Core\\Resource\\ResourceStorage', self::SIGNAL_PreFileMove, array($file, $targetFolder));
     }

     protected function emitPostFileMoveSignal(FileInterface $file, Folder $targetFolder, Folder $originalFolder) {
         $this->getSignalSlotDispatcher()->dispatch('TYPO3\\CMS\\Core\\Resource\\ResourceStorage', self::SIGNAL_PostFileMove, array($file, $targetFolder, $originalFolder));
     }

     protected function emitPreFileRenameSignal(FileInterface $file, $targetFolder) {
         $this->getSignalSlotDispatcher()->dispatch('TYPO3\\CMS\\Core\\Resource\\ResourceStorage', self::SIGNAL_PreFileRename, array($file, $targetFolder));
     }

     protected function emitPostFileRenameSignal(FileInterface $file, $targetFolder) {
         $this->getSignalSlotDispatcher()->dispatch('TYPO3\\CMS\\Core\\Resource\\ResourceStorage', self::SIGNAL_PostFileRename, array($file, $targetFolder));
     }

     protected function emitPreFileReplaceSignal(FileInterface $file, $localFilePath) {
         $this->getSignalSlotDispatcher()->dispatch('TYPO3\\CMS\\Core\\Resource\\ResourceStorage', self::SIGNAL_PreFileReplace, array($file, $localFilePath));
     }

     protected function emitPostFileReplaceSignal(FileInterface $file, $localFilePath) {
         $this->getSignalSlotDispatcher()->dispatch('TYPO3\\CMS\\Core\\Resource\\ResourceStorage', self::SIGNAL_PostFileReplace, array($file, $localFilePath));
     }

     protected function emitPostFileCreateSignal($newFileIdentifier, Folder $targetFolder) {
         $this->getSignalSlotDispatcher()->dispatch('TYPO3\\CMS\\Core\\Resource\\ResourceStorage', self::SIGNAL_PostFileCreate, array($newFileIdentifier, $targetFolder));
     }

     protected function emitPreFileDeleteSignal(FileInterface $file) {
         $this->getSignalSlotDispatcher()->dispatch('TYPO3\\CMS\\Core\\Resource\\ResourceStorage', self::SIGNAL_PreFileDelete, array($file));
     }

     protected function emitPostFileDeleteSignal(FileInterface $file) {
         $this->getSignalSlotDispatcher()->dispatch('TYPO3\\CMS\\Core\\Resource\\ResourceStorage', self::SIGNAL_PostFileDelete, array($file));
     }

     protected function emitPostFileSetContentsSignal(FileInterface $file, $content) {
         $this->getSignalSlotDispatcher()->dispatch('TYPO3\\CMS\\Core\\Resource\\ResourceStorage', self::SIGNAL_PostFileSetContents, array($file, $content));
     }

     protected function emitPreFolderAddSignal(Folder $targetFolder, $name) {
         $this->getSignalSlotDispatcher()->dispatch('TYPO3\\CMS\\Core\\Resource\\ResourceStorage', self::SIGNAL_PreFolderAdd, array($targetFolder, $name));
     }

     protected function emitPostFolderAddSignal(Folder $folder) {
         $this->getSignalSlotDispatcher()->dispatch('TYPO3\\CMS\\Core\\Resource\\ResourceStorage', self::SIGNAL_PostFolderAdd, array($folder));
     }

     protected function emitPreFolderCopySignal(Folder $folder, Folder $targetFolder, $newName) {
         $this->getSignalSlotDispatcher()->dispatch('TYPO3\\CMS\\Core\\Resource\\ResourceStorage', self::SIGNAL_PreFolderCopy, array($folder, $targetFolder, $newName));
     }

     protected function emitPostFolderCopySignal(Folder $folder, Folder $targetFolder, $newName) {
         $this->getSignalSlotDispatcher()->dispatch('TYPO3\\CMS\\Core\\Resource\\ResourceStorage', self::SIGNAL_PostFolderCopy, array($folder, $targetFolder, $newName));
     }

     protected function emitPreFolderMoveSignal(Folder $folder, Folder $targetFolder, $newName) {
         $this->getSignalSlotDispatcher()->dispatch('TYPO3\\CMS\\Core\\Resource\\ResourceStorage', self::SIGNAL_PreFolderMove, array($folder, $targetFolder, $newName));
     }

     protected function emitPostFolderMoveSignal(Folder $folder, Folder $targetFolder, $newName, Folder $originalFolder) {
         $this->getSignalSlotDispatcher()->dispatch('TYPO3\\CMS\\Core\\Resource\\ResourceStorage', self::SIGNAL_PostFolderMove, array($folder, $targetFolder, $newName, $originalFolder));
     }

     protected function emitPreFolderRenameSignal(Folder $folder, $newName) {
         $this->getSignalSlotDispatcher()->dispatch('TYPO3\\CMS\\Core\\Resource\\ResourceStorage', self::SIGNAL_PreFolderRename, array($folder, $newName));
     }

     protected function emitPostFolderRenameSignal(Folder $folder, $newName) {
         $this->getSignalSlotDispatcher()->dispatch('TYPO3\\CMS\\Core\\Resource\\ResourceStorage', self::SIGNAL_PostFolderRename, array($folder, $newName));
     }

     protected function emitPreFolderDeleteSignal(Folder $folder) {
         $this->getSignalSlotDispatcher()->dispatch('TYPO3\\CMS\\Core\\Resource\\ResourceStorage', self::SIGNAL_PreFolderDelete, array($folder));
     }

     protected function emitPostFolderDeleteSignal(Folder $folder) {
         $this->getSignalSlotDispatcher()->dispatch('TYPO3\\CMS\\Core\\Resource\\ResourceStorage', self::SIGNAL_PostFolderDelete, array($folder));
     }

     protected function emitPreGeneratePublicUrlSignal(ResourceInterface $resourceObject, $relativeToCurrentScript, array $urlData) {
         $this->getSignalSlotDispatcher()->dispatch('TYPO3\\CMS\\Core\\Resource\\ResourceStorage', self::SIGNAL_PreGeneratePublicUrl, array($this, $this->driver, $resourceObject, $relativeToCurrentScript, $urlData));
     }

     protected function getUniqueName(Folder $folder, $theFile, $dontCheckForUnique = FALSE) {
         static $maxNumber = 99, $uniqueNamePrefix = '';
         // Fetches info about path, name, extension of $theFile
         $origFileInfo = PathUtility::pathinfo($theFile);
         // Adds prefix
         if ($uniqueNamePrefix) {
             $origFileInfo['basename'] = $uniqueNamePrefix . $origFileInfo['basename'];
             $origFileInfo['filename'] = $uniqueNamePrefix . $origFileInfo['filename'];
         }
         // Check if the file exists and if not - return the fileName...
         // The destinations file
         $theDestFile = $origFileInfo['basename'];
         // If the file does NOT exist we return this fileName
         if (!$this->driver->fileExistsInFolder($theDestFile, $folder->getIdentifier()) || $dontCheckForUnique) {
             return $theDestFile;
         }
         // Well the fileName in its pure form existed. Now we try to append
         // numbers / unique-strings and see if we can find an available fileName
         // This removes _xx if appended to the file
         $theTempFileBody = preg_replace('/_[0-9][0-9]$/', '', $origFileInfo['filename']);
         $theOrigExt = $origFileInfo['extension'] ? '.' . $origFileInfo['extension'] : '';
         for ($a = 1; $a <= $maxNumber + 1; $a++) {
             // First we try to append numbers
             if ($a <= $maxNumber) {
                 $insert = '_' . sprintf('%02d', $a);
             } else {
                 $insert = '_' . substr(md5(uniqid('', TRUE)), 0, 6);
             }
             $theTestFile = $theTempFileBody . $insert . $theOrigExt;
             // The destinations file
             $theDestFile = $theTestFile;
             // If the file does NOT exist we return this fileName
             if (!$this->driver->fileExistsInFolder($theDestFile, $folder->getIdentifier())) {
                 return $theDestFile;
             }
         }
         throw new \RuntimeException('Last possible name "' . $theDestFile . '" is already taken.', 1325194291);
     }

     protected function getSignalSlotDispatcher() {
         if (!isset($this->signalSlotDispatcher)) {
             $this->signalSlotDispatcher = $this->getObjectManager()->get('TYPO3\\CMS\\Extbase\\SignalSlot\\Dispatcher');
         }
         return $this->signalSlotDispatcher;
     }

     protected function getObjectManager() {
         return GeneralUtility::makeInstance('TYPO3\\CMS\\Extbase\\Object\\ObjectManager');
     }

     protected function getFileFactory() {
         return GeneralUtility::makeInstance('TYPO3\\CMS\\Core\\Resource\\ResourceFactory');
     }

     protected function getFileIndexRepository() {
         return FileIndexRepository::getInstance();
     }

     protected function getFileProcessingService() {
         if (!$this->fileProcessingService) {
             $this->fileProcessingService = GeneralUtility::makeInstance('TYPO3\\CMS\\Core\\Resource\\Service\\FileProcessingService', $this, $this->driver);
         }
         return $this->fileProcessingService;
     }

     public function getRole(FolderInterface $folder) {
         $folderRole = FolderInterface::ROLE_DEFAULT;
         $identifier = $folder->getIdentifier();
         if (method_exists($this->driver, 'getRole')) {
             $folderRole = $this->driver->getRole($folder->getIdentifier());
         }
         if (isset($this->fileMounts[$identifier])) {
             $folderRole = FolderInterface::ROLE_MOUNT;

             if (!empty($this->fileMounts[$identifier]['read_only'])) {
                 $folderRole = FolderInterface::ROLE_READONLY_MOUNT;
             }
             if ($this->fileMounts[$identifier]['user_mount']) {
                 $folderRole = FolderInterface::ROLE_USER_MOUNT;
             }
         }
         if ($folder instanceof Folder && $this->isProcessingFolder($folder)) {
             $folderRole = FolderInterface::ROLE_PROCESSING;
         }

         return $folderRole;
     }

     public function getProcessingFolder() {
         if (!isset($this->processingFolder)) {
             $processingFolder = self::DEFAULT_ProcessingFolder;
             if (!empty($this->storageRecord['processingfolder'])) {
                 $processingFolder = $this->storageRecord['processingfolder'];
             }
             try {
                 if (strpos($processingFolder, ':') !== FALSE) {
                     list ($storageUid, $processingFolderIdentifier) = explode(':', $processingFolder, 2);
                     $storage = ResourceFactory::getInstance()->getStorageObject($storageUid);
                     if ($storage->hasFolder($processingFolderIdentifier)) {
                         $this->processingFolder = $storage->getFolder($processingFolderIdentifier);
                     } else {
                         $this->processingFolder = $storage->createFolder(ltrim($processingFolderIdentifier, '/'));
                     }
                 } else {
                     if ($this->driver->folderExists($processingFolder) === FALSE) {
                         $this->processingFolder = $this->createFolder($processingFolder);
                     } else {
                         $data = $this->driver->getFolderInfoByIdentifier($processingFolder);
                         $this->processingFolder = ResourceFactory::getInstance()->createFolderObject($this, $data['identifier'], $data['name']);
                     }
                 }
             } catch(Exception\InsufficientFolderWritePermissionsException $e) {
                 $this->processingFolder = GeneralUtility::makeInstance(
                     'TYPO3\\CMS\\Core\\Resource\\InaccessibleFolder', $this, $processingFolder, $processingFolder
                 );
             } catch(Exception\ResourcePermissionsUnavailableException $e) {
                 $this->processingFolder = GeneralUtility::makeInstance(
                     'TYPO3\\CMS\\Core\\Resource\\InaccessibleFolder', $this, $processingFolder, $processingFolder
                 );
             }
         }
         return $this->processingFolder;
     }

     public function getDriverType() {
         return $this->storageRecord['driver'];
     }

     protected function getIndexer() {
         return GeneralUtility::makeInstance('TYPO3\\CMS\\Core\\Resource\\Index\\Indexer', $this);
     }

     public function setDefault($isDefault) {
         $this->isDefault = (bool)$isDefault;
     }

     public function isDefault() {
         return $this->isDefault;
     }
 }
TYPO3\CMS\Core\Resource\ResourceStorage\getFolderList
getFolderList($path, $start=0, $numberOfItems=0, $useFilters=TRUE)
Definition: ResourceStorage.php:2024

FileIndexRepository

TYPO3\CMS\Core\Resource\ResourceStorage\assureFolderCopyPermissions
assureFolderCopyPermissions(FolderInterface $folderToCopy, FolderInterface $targetParentFolder)
Definition: ResourceStorage.php:1006

TYPO3\CMS\Core\Resource\ResourceStorage\emitPreFileMoveSignal
emitPreFileMoveSignal(FileInterface $file, Folder $targetFolder)
Definition: ResourceStorage.php:2288

TYPO3\CMS\Core\Resource\ResourceStorage
Definition: ResourceStorage.php:57

TYPO3\CMS\Core\Resource\ResourceStorage\addFileMount
addFileMount($folderIdentifier, $additionalData=array())
Definition: ResourceStorage.php:429

TYPO3\CMS\Core\Resource\ResourceStorage\resetFileAndFolderNameFiltersToDefault
resetFileAndFolderNameFiltersToDefault()
Definition: ResourceStorage.php:1302

InvalidTargetFolderException

TYPO3\CMS\Core\Resource\ResourceStorage\getName
getName()
Definition: ResourceStorage.php:265

TYPO3\CMS\Core\Resource\ResourceStorage\emitPreFileDeleteSignal
emitPreFileDeleteSignal(FileInterface $file)
Definition: ResourceStorage.php:2364

TYPO3\CMS\Core\Resource\ProcessedFile
Definition: ProcessedFile.php:40

TYPO3\CMS\Core\Resource\ResourceStorage\replaceFile
replaceFile(FileInterface $file, $localFilePath)
Definition: ResourceStorage.php:1759

TYPO3\CMS\Core\Resource\ResourceStorage\emitPostFolderAddSignal
emitPostFolderAddSignal(Folder $folder)
Definition: ResourceStorage.php:2406

TYPO3\CMS\Core\Resource\ResourceStorage\checkFolderActionPermission
checkFolderActionPermission($action, Folder $folder=NULL)
Definition: ResourceStorage.php:639

TYPO3\CMS\Core\Resource\ResourceStorage\$configuration
$configuration
Definition: ResourceStorage.php:78

TYPO3\CMS\Core\Resource\ResourceStorage\getFileContents
getFileContents($file)
Definition: ResourceStorage.php:1505

TYPO3\CMS\Core\Resource\ResourceStorage\emitPreFileReplaceSignal
emitPreFileReplaceSignal(FileInterface $file, $localFilePath)
Definition: ResourceStorage.php:2333

TYPO3\CMS\Core\Resource\ResourceStorage\isWithinProcessingFolder
isWithinProcessingFolder($identifier)
Definition: ResourceStorage.php:2189

TYPO3

TYPO3\CMS\Core\Resource\ResourceStorage\getFileList
getFileList($path, $start=0, $numberOfItems=0, $useFilters=TRUE, $loadIndexRecords=TRUE, $recursive=FALSE)
Definition: ResourceStorage.php:1353

TYPO3\CMS\Core\Resource\ResourceStorage\isWithinFolder
isWithinFolder(Folder $folder, ResourceInterface $resource)
Definition: ResourceStorage.php:2208

TYPO3\CMS\Core\Resource\ResourceStorage\getFileFactory
getFileFactory()
Definition: ResourceStorage.php:2588

TYPO3\CMS\Core\Resource\ResourceStorage\hasChildren
hasChildren()
Definition: ResourceStorage.php:283

TYPO3\CMS\Core\Utility\GeneralUtility\uniqueList
static uniqueList($in_list, $secondParameter=NULL)
Definition: GeneralUtility.php:860

TYPO3\CMS\Core\Resource\ResourceStorage\getFolderByIdentifier
getFolderByIdentifier($identifier)
Definition: ResourceStorage.php:239

GeneralUtility

TYPO3\CMS\Core\Resource\ResourceStorage\getFolderIdentifierFromFileIdentifier
getFolderIdentifierFromFileIdentifier($fileIdentifier)
Definition: ResourceStorage.php:1336

TYPO3\CMS\Core\Resource\Folder\getName
getName()
Definition: Folder.php:95

TYPO3\CMS\Core\Resource\ResourceStorage\$isOnline
$isOnline
Definition: ResourceStorage.php:140

TYPO3\CMS\Core\Resource\AbstractFile\getIdentifier
getIdentifier()
Definition: AbstractFile.php:149

TYPO3\CMS\Core\Resource\ProcessedFile\getName
getName()
Definition: ProcessedFile.php:294

TYPO3\CMS\Core\Resource\ResourceStorage\moveFolder
moveFolder(Folder $folderToMove, Folder $targetParentFolder, $newFolderName=NULL, $conflictMode='renameNewFolder')
Definition: ResourceStorage.php:1836

TYPO3\CMS\Core\Resource\ResourceStorage\checkFileActionPermission
checkFileActionPermission($action, FileInterface $file)
Definition: ResourceStorage.php:577

TYPO3\CMS\Core\Resource\ResourceStorage\hasFile
hasFile($identifier)
Definition: ResourceStorage.php:1429

TYPO3\CMS\Core\Resource\ResourceStorage\getIndexer
getIndexer()
Definition: ResourceStorage.php:2694

TYPO3\CMS\Core\Resource\Folder
Definition: Folder.php:34

TYPO3\CMS\Core\Resource\ResourceStorage\setFileContents
setFileContents(AbstractFile $file, $contents)
Definition: ResourceStorage.php:1553

TYPO3\CMS\Core\Resource\ResourceStorage\hasFileInFolder
hasFileInFolder($fileName, Folder $folder)
Definition: ResourceStorage.php:1492

TYPO3\CMS\Core\Resource\Folder\getStorage
getStorage()
Definition: Folder.php:148

TYPO3\CMS\Core\Resource\FolderInterface\ROLE_MOUNT
const ROLE_MOUNT
Definition: FolderInterface.php:31

TYPO3\CMS\Core\Utility\PathUtility\basename
static basename($path)
Definition: PathUtility.php:161

TYPO3\CMS\Core\Resource\ResourceStorage\assureFileAddPermissions
assureFileAddPermissions($localFilePath, $targetFolder, $targetFileName)
Definition: ResourceStorage.php:852

TYPO3\CMS\Core\Resource\ResourceStorage\emitPreFolderMoveSignal
emitPreFolderMoveSignal(Folder $folder, Folder $targetFolder, $newName)
Definition: ResourceStorage.php:2442

TYPO3\CMS\Core\Resource\ResourceStorage\processFile
processFile(FileInterface $fileObject, $context, array $configuration)
Definition: ResourceStorage.php:1230

TYPO3\CMS\Core\Utility\PathUtility\getCanonicalPath
static getCanonicalPath($path)
Definition: PathUtility.php:271

TYPO3\CMS\Core\Utility\PathUtility\getRelativePathTo
static getRelativePathTo($targetPath)
Definition: PathUtility.php:31

TYPO3\CMS\Core\Resource\ResourceStorage\emitPostFileRenameSignal
emitPostFileRenameSignal(FileInterface $file, $targetFolder)
Definition: ResourceStorage.php:2322

TYPO3\CMS\Core\Resource\ResourceStorage\assureFileWritePermissions
assureFileWritePermissions(FileInterface $file)
Definition: ResourceStorage.php:798

TYPO3\CMS\Core\Resource\ResourceStorage\isOnline
isOnline()
Definition: ResourceStorage.php:355

TYPO3\CMS\Core\Resource\Folder\getSubfolders
getSubfolders($start=0, $numberOfItems=0, $filterMode=self::FILTER_MODE_USE_OWN_AND_STORAGE_FILTERS)
Definition: Folder.php:261

TYPO3\CMS\Core\Resource\ResourceStorage\__construct
__construct(Driver\DriverInterface $driver, array $storageRecord)
Definition: ResourceStorage.php:160

TYPO3\CMS\Core\Resource\FileInterface\getSize
getSize()

TYPO3\CMS\Core\Resource\ResourceStorage\emitPostFileCreateSignal
emitPostFileCreateSignal($newFileIdentifier, Folder $targetFolder)
Definition: ResourceStorage.php:2354

TYPO3\CMS\Core\Resource\ResourceStorage\getFileAndFolderNameFilters
getFileAndFolderNameFilters()
Definition: ResourceStorage.php:1311

TYPO3\CMS\Core\Resource\ResourceStorage\$fileMounts
$fileMounts
Definition: ResourceStorage.php:100

TYPO3\CMS\Core\Resource\ResourceStorage\hasFolder
hasFolder($identifier)
Definition: ResourceStorage.php:2091

TYPO3\CMS\Core\Resource\Exception
Definition: Exception.php:20

TYPO3\CMS\Core\Resource\ResourceStorage\getStorageRecord
getStorageRecord()
Definition: ResourceStorage.php:208

TYPO3\CMS\Core\Resource\ResourceStorage\getSignalSlotDispatcher
getSignalSlotDispatcher()
Definition: ResourceStorage.php:2569

TYPO3\CMS\Core\Resource\ResourceStorage\addFileAndFolderNameFilter
addFileAndFolderNameFilter($filter)
Definition: ResourceStorage.php:1327

TYPO3\CMS\Core\Resource\ResourceStorage\emitPreFileCopySignal
emitPreFileCopySignal(FileInterface $file, Folder $targetFolder)
Definition: ResourceStorage.php:2266

TYPO3\CMS\Core\Resource\ResourceStorage\getFileMounts
getFileMounts()
Definition: ResourceStorage.php:468

TYPO3\CMS\Core\Resource\ResourceStorage\hashFileByIdentifier
hashFileByIdentifier($fileIdentifier, $hash)
Definition: ResourceStorage.php:1151

TYPO3\CMS\Core\Resource\ResourceStorage\markAsPermanentlyOffline
markAsPermanentlyOffline()
Definition: ResourceStorage.php:392

TYPO3\CMS\Core\Resource\ResourceStorage\getFilesInFolder
getFilesInFolder(Folder $folder, $start=0, $maxNumberOfItems=0, $useFilters=TRUE, $recursive=FALSE)
Definition: ResourceStorage.php:1366

TYPO3\CMS\Core\Resource\ResourceStorage\getFolderIdentifiersInFolder
getFolderIdentifiersInFolder($folderIdentifier, $useFilters=TRUE, $recursive=FALSE)
Definition: ResourceStorage.php:1418

TYPO3_MODE
const TYPO3_MODE
Definition: init.php:40

TYPO3\CMS\Core\Resource\ResourceStorage\usesCaseSensitiveIdentifiers
usesCaseSensitiveIdentifiers()
Definition: ResourceStorage.php:346

TYPO3\CMS\Core\Resource\ResourceStorage\getFolder
getFolder($identifier, $returnInaccessibleFolderObject=FALSE)
Definition: ResourceStorage.php:2157

TYPO3\CMS\Core\Resource\ResourceStorage\$storageRecord
$storageRecord
Definition: ResourceStorage.php:71

TYPO3\CMS\Core\Resource\FileInterface
Definition: FileInterface.php:21

TYPO3\CMS\Core\Resource\FolderInterface\ROLE_DEFAULT
const ROLE_DEFAULT
Definition: FolderInterface.php:26

TYPO3\CMS\Core\Resource\ResourceStorage\emitPreFolderRenameSignal
emitPreFolderRenameSignal(Folder $folder, $newName)
Definition: ResourceStorage.php:2466

TYPO3\CMS\Core\Resource\ResourceStorage\emitPreFileRenameSignal
emitPreFileRenameSignal(FileInterface $file, $targetFolder)
Definition: ResourceStorage.php:2311

TYPO3\CMS\Core\Resource\ResourceStorage\getDriver
getDriver()
Definition: ResourceStorage.php:228

TYPO3\CMS\Core\Resource\ResourceStorage\getDriverType
getDriverType()
Definition: ResourceStorage.php:2685

TYPO3\CMS\Core\Utility\GeneralUtility\getMaxUploadFileSize
static getMaxUploadFileSize($localLimit=0)
Definition: GeneralUtility.php:3193

TYPO3\CMS\Core\Resource\ResourceStorage\getRootLevelFolder
getRootLevelFolder($respectFileMounts=TRUE)
Definition: ResourceStorage.php:2226

TYPO3\CMS\Core\Utility\GeneralUtility\hmac
static hmac($input, $additionalSecret='')
Definition: GeneralUtility.php:828

TYPO3\CMS\Core\Resource\ResourceStorage\$processingFolders
$processingFolders
Definition: ResourceStorage.php:133

TYPO3\CMS\Core\Resource\ResourceStorage\emitPostFolderDeleteSignal
emitPostFolderDeleteSignal(Folder $folder)
Definition: ResourceStorage.php:2497

TYPO3\CMS\Core\Resource\ResourceStorage\getPublicUrl
getPublicUrl(ResourceInterface $resourceObject, $relativeToCurrentScript=FALSE)
Definition: ResourceStorage.php:1181

TYPO3\CMS\Core\Resource\ResourceStorage\emitPostFolderRenameSignal
emitPostFolderRenameSignal(Folder $folder, $newName)
Definition: ResourceStorage.php:2477

TYPO3\CMS\Core\Resource\ResourceStorage\deleteFile
deleteFile($fileObject)
Definition: ResourceStorage.php:1590

TYPO3\CMS\Core\Utility\GeneralUtility\logDeprecatedFunction
static logDeprecatedFunction()
Definition: GeneralUtility.php:5234

TYPO3\CMS\Core\Resource\ResourceStorage\assureFolderMovePermissions
assureFolderMovePermissions(FolderInterface $folderToMove, FolderInterface $targetParentFolder)
Definition: ResourceStorage.php:1042

TYPO3\CMS\Core\Resource\ResourceStorage\$userPermissions
$userPermissions
Definition: ResourceStorage.php:108

TYPO3\CMS\Core\Resource\ResourceStorage\setUserPermissions
setUserPermissions(array $userPermissions)
Definition: ResourceStorage.php:539

TYPO3\CMS\Core\Resource\AbstractFile\setIdentifier
setIdentifier($identifier)
Definition: AbstractFile.php:394

TYPO3\CMS\Core\Resource\ResourceStorage\isWithinFileMountBoundaries
isWithinFileMountBoundaries($subject, $checkWriteAccess=FALSE)
Definition: ResourceStorage.php:480

TYPO3\CMS\Core\Resource\ResourceStorage\addFile
addFile($localFilePath, Folder $targetFolder, $targetFileName='', $conflictMode='changeName')
Definition: ResourceStorage.php:1080

TYPO3\CMS\Core\Utility\GeneralUtility\makeInstance
static makeInstance($className)
Definition: GeneralUtility.php:4424

TYPO3\CMS\Core\Resource\ResourceStorage\emitPostFileReplaceSignal
emitPostFileReplaceSignal(FileInterface $file, $localFilePath)
Definition: ResourceStorage.php:2344

TYPO3\CMS\Core\Resource\FolderInterface\ROLE_READONLY_MOUNT
const ROLE_READONLY_MOUNT
Definition: FolderInterface.php:32

TYPO3\CMS\Core\Utility\PathUtility\pathinfo
static pathinfo($path, $options=NULL)
Definition: PathUtility.php:204

TYPO3\CMS\Core\Resource\ResourceStorage\copyFolderBetweenStorages
copyFolderBetweenStorages(Folder $folderToCopy, Folder $targetParentFolder, $newFolderName)
Definition: ResourceStorage.php:1938

TYPO3\CMS\Core\Resource\Exception\InvalidTargetFolderException
Definition: InvalidTargetFolderException.php:20

TYPO3\CMS\Core\Resource\ResourceStorage\$processingFolder
$processingFolder
Definition: ResourceStorage.php:126

PathUtility

TYPO3\CMS\Core\Utility\GeneralUtility\trimExplode
static trimExplode($delim, $string, $removeEmptyValues=FALSE, $limit=0)
Definition: GeneralUtility.php:1536

TYPO3\CMS\Core\Resource\ResourceStorage\copyFolder
copyFolder(FolderInterface $folderToCopy, FolderInterface $targetParentFolder, $newFolderName=NULL, $conflictMode='renameNewFolder')
Definition: ResourceStorage.php:1897

TYPO3\CMS\Core\Utility\GeneralUtility\verifyFilenameAgainstDenyPattern
static verifyFilenameAgainstDenyPattern($filename)
Definition: GeneralUtility.php:3911

TYPO3\CMS\Core\Resource\ResourceStorage\assureFolderReadPermission
assureFolderReadPermission(Folder $folder=NULL)
Definition: ResourceStorage.php:729

TYPO3\CMS\Core\Resource\ResourceStorage\unsetFileAndFolderNameFilters
unsetFileAndFolderNameFilters()
Definition: ResourceStorage.php:1293

TYPO3\CMS\Core\Resource\ResourceStorage\renameFile
renameFile($file, $targetFileName)
Definition: ResourceStorage.php:1721

TYPO3\CMS\Core\Resource\ResourceStorage\hashFile
hashFile(FileInterface $fileObject, $hash)
Definition: ResourceStorage.php:1139

TYPO3\CMS\Core\Resource\ResourceStorage\$capabilities
$capabilities
Definition: ResourceStorage.php:116

TYPO3\CMS\Core\Resource\ResourceStorage\getEvaluatePermissions
getEvaluatePermissions()
Definition: ResourceStorage.php:529

TYPO3\CMS\Core\Resource\ResourceStorage\setEvaluatePermissions
setEvaluatePermissions($evaluatePermissions)
Definition: ResourceStorage.php:519

TYPO3\CMS\Core\Resource\ResourceStorage\emitPostFileSetContentsSignal
emitPostFileSetContentsSignal(FileInterface $file, $content)
Definition: ResourceStorage.php:2385

TYPO3\CMS\Core\Resource\ResourceStorage\emitPostFileCopySignal
emitPostFileCopySignal(FileInterface $file, Folder $targetFolder)
Definition: ResourceStorage.php:2277

TYPO3\CMS\Core\Resource\ResourceStorage\emitPreGeneratePublicUrlSignal
emitPreGeneratePublicUrlSignal(ResourceInterface $resourceObject, $relativeToCurrentScript, array $urlData)
Definition: ResourceStorage.php:2508

TYPO3\CMS\Core\Resource\FolderInterface
Definition: FolderInterface.php:21

TYPO3\CMS\Core\Resource\ResourceStorage\$fileAndFolderNameFilters
$fileAndFolderNameFilters
Definition: ResourceStorage.php:152

TYPO3\CMS\Core\Resource\ResourceStorage\getFileForLocalProcessing
getFileForLocalProcessing(FileInterface $fileObject, $writable=TRUE)
Definition: ResourceStorage.php:1246

TYPO3\CMS\Core\Resource\ResourceStorage\markAsTemporaryOffline
markAsTemporaryOffline()
Definition: ResourceStorage.php:409

TYPO3\CMS\Core\Resource\ResourceStorage\getConfiguration
getConfiguration()
Definition: ResourceStorage.php:190

TYPO3\CMS\Core\Resource\Folder\getIdentifier
getIdentifier()
Definition: Folder.php:158

TYPO3\CMS\Core\Resource\ResourceStorage\isPublic
isPublic()
Definition: ResourceStorage.php:318

TYPO3\CMS\Core\Resource\ResourceStorage\setConfiguration
setConfiguration(array $configuration)
Definition: ResourceStorage.php:199

TYPO3\CMS\Core\Resource\ResourceStorage\assureFileCopyPermissions
assureFileCopyPermissions(FileInterface $file, Folder $targetFolder, $targetFileName)
Definition: ResourceStorage.php:972

TYPO3\CMS\Core\Resource\ResourceStorage\checkFileExtensionPermission
checkFileExtensionPermission($fileName)
Definition: ResourceStorage.php:689

TYPO3\CMS\Core\Resource\ResourceStorage\moveFolderBetweenStorages
moveFolderBetweenStorages(Folder $folderToMove, Folder $targetParentFolder, $newFolderName)
Definition: ResourceStorage.php:1883

$result
if($list_of_literals) if(!empty($literals)) if(!empty($literals)) $result
Analyse literals to prepend the N char to them if their contents aren&#39;t numeric.
Definition: adodb-mssql_n.inc.php:148

TYPO3\CMS\Core\Resource\ResourceStorage\assureFolderDeletePermission
assureFolderDeletePermission(Folder $folder, $checkDeleteRecursively)
Definition: ResourceStorage.php:755

TYPO3\CMS\Core\Resource\ResourceStorage\$fileProcessingService
$fileProcessingService
Definition: ResourceStorage.php:83

TYPO3\CMS\Core\Resource\ResourceStorage\emitPostFileAddSignal
emitPostFileAddSignal(FileInterface $file, Folder $targetFolder)
Definition: ResourceStorage.php:2255

TYPO3\CMS\Core\Utility\PathUtility\dirname
static dirname($path)
Definition: PathUtility.php:182

TYPO3\CMS\Core\Resource\ResourceStorage\$signalSlotDispatcher
$signalSlotDispatcher
Definition: ResourceStorage.php:121

TYPO3\CMS\Core\Resource\ResourceStorage\checkUserActionPermission
checkUserActionPermission($action, $type)
Definition: ResourceStorage.php:551

TYPO3\CMS\Core\Resource\ResourceStorage\dumpFileContents
dumpFileContents(FileInterface $file, $asDownload=FALSE, $alternativeFilename=NULL)
Definition: ResourceStorage.php:1519

TYPO3\CMS\Core\Resource\ResourceStorage\createFolder
createFolder($folderName, Folder $parentFolder=NULL)
Definition: ResourceStorage.php:2120

TYPO3\CMS\Core\Resource\ResourceStorage\getFileByIdentifier
getFileByIdentifier($identifier)
Definition: ResourceStorage.php:253

TYPO3\CMS\Core\Resource\ResourceStorage\getProcessingFolder
getProcessingFolder()
Definition: ResourceStorage.php:2644

TYPO3\CMS\Core\Resource\ResourceStorage\emitPostFileDeleteSignal
emitPostFileDeleteSignal(FileInterface $file)
Definition: ResourceStorage.php:2374

TYPO3\CMS\Core\Resource\ResourceStorage\deleteFolder
deleteFolder($folderObject, $deleteRecursively=FALSE)
Definition: ResourceStorage.php:1994

TYPO3\CMS\Core\Resource\Index\FileIndexRepository\getInstance
static getInstance()
Definition: FileIndexRepository.php:72

TYPO3\CMS\Core\Resource\ResourceStorage\hasCapability
hasCapability($capability)
Definition: ResourceStorage.php:306

TYPO3\CMS\Core\Resource\ResourceStorage\moveFile
moveFile($file, $targetFolder, $targetFileName=NULL, $conflictMode='renameNewFile')
Definition: ResourceStorage.php:1669

TYPO3\CMS\Core\Resource\FileInterface\getExtension
getExtension()

TYPO3\CMS\Core\Resource\ResourceInterface
Definition: ResourceInterface.php:21

TYPO3\CMS\Core\Resource\ResourceStorage\$isDefault
$isDefault
Definition: ResourceStorage.php:145

TYPO3\CMS\Core\Resource\ResourceStorage\addUploadedFile
addUploadedFile(array $uploadedFileData, Folder $targetFolder=NULL, $targetFileName=NULL, $conflictMode='cancel')
Definition: ResourceStorage.php:1782

TYPO3\CMS\Core\Resource\ResourceStorage\fetchFolderListFromDriver
fetchFolderListFromDriver($path, $start=0, $numberOfItems=0, array $folderFilterCallbacks=array(), $recursive=FALSE)
Definition: ResourceStorage.php:2067

TYPO3\CMS\Core\Resource\ResourceStorage\assureFileDeletePermissions
assureFileDeletePermissions(FileInterface $file)
Definition: ResourceStorage.php:817

TYPO3\CMS\Core\Resource\ResourceStorage\getFile
getFile($identifier)
Definition: ResourceStorage.php:1257

TYPO3\CMS\Core\Resource\ResourceStorage\emitPreFolderDeleteSignal
emitPreFolderDeleteSignal(Folder $folder)
Definition: ResourceStorage.php:2487

TYPO3\CMS\Core\Resource\ResourceStorage\$evaluatePermissions
$evaluatePermissions
Definition: ResourceStorage.php:93

TYPO3\CMS\Core\Resource\ResourceStorage\setDriver
setDriver(Driver\DriverInterface $driver)
Definition: ResourceStorage.php:218

TYPO3\CMS\Core\Resource\ResourceStorage\emitPreFolderAddSignal
emitPreFolderAddSignal(Folder $targetFolder, $name)
Definition: ResourceStorage.php:2396

TYPO3\CMS\Core\Resource
Definition: AbstractFile.php:2

TYPO3\CMS\Core\Resource\ResourceStorage\createFile
createFile($fileName, Folder $targetFolderObject)
Definition: ResourceStorage.php:1575

TYPO3\CMS\Core\Resource\ResourceStorage\getCapabilities
getCapabilities()
Definition: ResourceStorage.php:296

TYPO3\CMS\Core\Resource\ResourceStorage\emitPostFolderMoveSignal
emitPostFolderMoveSignal(Folder $folder, Folder $targetFolder, $newName, Folder $originalFolder)
Definition: ResourceStorage.php:2455

TYPO3\CMS\Core\Resource\AbstractFile
Definition: AbstractFile.php:24

TYPO3\CMS\Core\Resource\ResourceInterface\getStorage
getStorage()

TYPO3\CMS\Core\Resource\ResourceStorage\assureFileUploadPermissions
assureFileUploadPermissions($localFilePath, $targetFolder, $targetFileName, $uploadedFileSize)
Definition: ResourceStorage.php:883

TYPO3\CMS\Core\Resource\ResourceStorage\getUniqueName
getUniqueName(Folder $folder, $theFile, $dontCheckForUnique=FALSE)
Definition: ResourceStorage.php:2525

TYPO3\CMS\Core\Resource\FileInterface\getMimeType
getMimeType()

TYPO3\CMS\Core\Resource\ResourceStorage\getDefaultFolder
getDefaultFolder()
Definition: ResourceStorage.php:2145

TYPO3\CMS\Core\Resource\ResourceStorage\getFoldersInFolder
getFoldersInFolder(Folder $folder, $start=0, $maxNumberOfItems=0, $useFilters=TRUE, $recursive=FALSE)
Definition: ResourceStorage.php:2040

TYPO3\CMS\Core\Resource\ResourceStorage\isProcessingFolder
isProcessingFolder(Folder $folder)
Definition: ResourceStorage.php:1474

TYPO3\CMS\Core\Resource\ResourceStorage\emitPreFileAddSignal
emitPreFileAddSignal($targetFileName, Folder $targetFolder, $sourceFilePath)
Definition: ResourceStorage.php:2243

TYPO3\CMS\Core\Resource\ResourceStorage\isDefault
isDefault()
Definition: ResourceStorage.php:2709

TYPO3\CMS\Core\Resource\ResourceStorage\$driver
$driver
Definition: ResourceStorage.php:64

TYPO3\CMS\Core\Resource\ResourceStorage\getRole
getRole(FolderInterface $folder)
Definition: ResourceStorage.php:2615

TYPO3\CMS\Core\Resource\ResourceStorage\emitPostFolderCopySignal
emitPostFolderCopySignal(Folder $folder, Folder $targetFolder, $newName)
Definition: ResourceStorage.php:2430

TYPO3\CMS\Core\Resource\ResourceStorage\isBrowsable
isBrowsable()
Definition: ResourceStorage.php:337

TYPO3\CMS\Core\Resource\ResourceInterface\getName
getName()

TYPO3\CMS\Core\Resource\ResourceStorage\emitPreFolderCopySignal
emitPreFolderCopySignal(Folder $folder, Folder $targetFolder, $newName)
Definition: ResourceStorage.php:2418

TYPO3\CMS\Core\Resource\ResourceStorage\setFileAndFolderNameFilters
setFileAndFolderNameFilters(array $filters)
Definition: ResourceStorage.php:1319

TYPO3\CMS\Core\Resource\ResourceStorage\hasFolderInFolder
hasFolderInFolder($folderName, Folder $folder)
Definition: ResourceStorage.php:2103

TYPO3\CMS\Core\Resource\File
Definition: File.php:23

TYPO3\CMS\Core\Resource\ResourceStorage\setDefault
setDefault($isDefault)
Definition: ResourceStorage.php:2702

$GLOBALS
if(!defined('TYPO3_MODE')) $GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['t3lib/class.t3lib_userauth.php']['logoff_pre_processing'][]
Definition: ext_localconf.php:5

TYPO3\CMS\Core\Resource\FolderInterface\ROLE_PROCESSING
const ROLE_PROCESSING
Definition: FolderInterface.php:28

TYPO3\CMS\Core\Resource\ResourceStorage\assureFileReadPermission
assureFileReadPermission(FileInterface $file)
Definition: ResourceStorage.php:780

TYPO3\CMS\Core\Resource\ResourceStorage\getFileProcessingService
getFileProcessingService()
Definition: ResourceStorage.php:2602

TYPO3\CMS\Core\Utility\GeneralUtility\inList
static inList($list, $item)
Definition: GeneralUtility.php:719

TYPO3\CMS\Core\Resource\ResourceStorage\assureFileRenamePermissions
assureFileRenamePermissions(FileInterface $file, $targetFileName)
Definition: ResourceStorage.php:939

TYPO3\CMS\Core\Resource\ResourceStorage\updateProcessedFile
updateProcessedFile($localFilePath, ProcessedFile $processedFile, Folder $processingFolder=NULL)
Definition: ResourceStorage.php:1118

TYPO3\CMS\Core\Resource\ResourceStorageInterface
Definition: ResourceStorageInterface.php:21

TYPO3\CMS\Core\Resource\ResourceStorage\getFileIdentifiersInFolder
getFileIdentifiersInFolder($folderIdentifier, $useFilters=TRUE, $recursive=FALSE)
Definition: ResourceStorage.php:1406

TYPO3\CMS\Core\Resource\ResourceStorage\renameFolder
renameFolder($folderObject, $newName)
Definition: ResourceStorage.php:1951

TYPO3\CMS\Core\Resource\ResourceStorage\isWritable
isWritable()
Definition: ResourceStorage.php:328

TYPO3\CMS\Core\Resource\Folder\getCombinedIdentifier
getCombinedIdentifier()
Definition: Folder.php:177

TYPO3\CMS\Core\Resource\ResourceStorage\assureFileMovePermissions
assureFileMovePermissions(FileInterface $file, Folder $targetFolder, $targetFileName)
Definition: ResourceStorage.php:909

TYPO3\CMS\Core\Resource\ResourceInterface\getIdentifier
getIdentifier()

TYPO3\CMS\Core\Resource\ResourceStorage\getFileIndexRepository
getFileIndexRepository()
Definition: ResourceStorage.php:2595

TYPO3\CMS\Core\Resource\FolderInterface\ROLE_USER_MOUNT
const ROLE_USER_MOUNT
Definition: FolderInterface.php:33

TYPO3\CMS\Core\Resource\Folder\getFiles
getFiles($start=0, $numberOfItems=0, $filterMode=self::FILTER_MODE_USE_OWN_AND_STORAGE_FILTERS, $recursive=FALSE)
Definition: Folder.php:206

TYPO3\CMS\Core\Resource\ResourceStorage\getObjectManager
getObjectManager()
Definition: ResourceStorage.php:2581

TYPO3\CMS\Core\Resource\ResourceStorage\getUid
getUid()
Definition: ResourceStorage.php:274

TYPO3\CMS\Core\Resource\ResourceStorage\emitPostFileMoveSignal
emitPostFileMoveSignal(FileInterface $file, Folder $targetFolder, Folder $originalFolder)
Definition: ResourceStorage.php:2300

TYPO3\CMS\Core\Resource\ResourceStorage\getFileInfo
getFileInfo(FileInterface $fileObject)
Definition: ResourceStorage.php:1272

TYPO3\CMS\Core\Utility\GeneralUtility\isValidUrl
static isValidUrl($url)
Definition: GeneralUtility.php:1401

TYPO3\CMS\Core\Resource\FolderInterface\getSubfolder
getSubfolder($name)

TYPO3\CMS\Core\Resource\ResourceFactory\getInstance
static getInstance()
Definition: ResourceFactory.php:35

TYPO3\CMS\Core\Resource\ResourceStorage\getFileInfoByIdentifier
getFileInfoByIdentifier($identifier, array $propertiesToExtract=array())
Definition: ResourceStorage.php:1284

TYPO3\CMS\Core\Resource\Folder\getParentFolder
getParentFolder()
Definition: Folder.php:491