9.5/core_2_classes_2_resource_2_folder_8php_source.html

<?php

namespace ‪TYPO3\CMS\Core\Resource;


/*

 * This file is part of the TYPO3 CMS project.

 *

 * It is free software; you can redistribute it and/or modify it under

 * the terms of the GNU General Public License, either version 2

 * of the License, or any later version.

 *

 * For the full copyright and license information, please read the

 * LICENSE.txt file that was distributed with this source code.

 *

 * The TYPO3 project - inspiring people to share!

 */


use ‪TYPO3\CMS\Core\Resource\Search\FileSearchDemand;

use ‪TYPO3\CMS\Core\Resource\Search\Result\FileSearchResultInterface;

use ‪TYPO3\CMS\Core\Utility\PathUtility;


class ‪Folder implements ‪FolderInterface

{

    protected ‪$storage;


    protected ‪$identifier;


    protected ‪$name;


    protected ‪$fileAndFolderNameFilters = [];


    const ‪FILTER_MODE_NO_FILTERS = 0;

    // Merge local filters into storage's filters

    const ‪FILTER_MODE_USE_OWN_AND_STORAGE_FILTERS = 1;

    // Only use the filters provided by the storage

    const ‪FILTER_MODE_USE_STORAGE_FILTERS = 2;

    // Only use the filters provided by the current class

    const ‪FILTER_MODE_USE_OWN_FILTERS = 3;


    public function ‪__construct(‪ResourceStorage ‪$storage, ‪$identifier, ‪$name)

    {

        $this->storage = ‪$storage;

        $this->identifier = ‪$identifier;

        $this->name = ‪$name;

    }


    public function ‪getName()

    {

        return ‪$this->name;

    }


    public function ‪getReadablePath($rootId = null)

    {

        if ($rootId === null) {

            // Find first matching filemount and use that as root

            foreach ($this->storage->getFileMounts() as $fileMount) {

                if ($this->storage->isWithinFolder($fileMount['folder'], $this)) {

                    $rootId = $fileMount['folder']->getIdentifier();

                    break;

                }

            }

            if ($rootId === null) {

                $rootId = $this->storage->getRootLevelFolder()->getIdentifier();

            }

        }

        $readablePath = '/';

        if ($this->identifier !== $rootId) {

            try {

                $readablePath = $this->‪getParentFolder()->‪getReadablePath($rootId);

            } catch (Exception\InsufficientFolderAccessPermissionsException $e) {

                // May no access to parent folder (e.g. because of mount point)

                $readablePath = '/';

            }

        }

        return $readablePath . ($this->name ? $this->name . '/' : '');

    }


    public function ‪setName(‪$name)

    {

        $this->name = ‪$name;

    }


    public function ‪getStorage()

    {

        return ‪$this->storage;

    }


    public function ‪getIdentifier()

    {

        return ‪$this->identifier;

    }


    public function ‪getHashedIdentifier()

    {

        return $this->storage->hashFileIdentifier($this->identifier);

    }


    public function ‪getCombinedIdentifier()

    {

        return $this->‪getStorage()->‪getUid() . ':' . $this->‪getIdentifier();

    }


    public function ‪getPublicUrl($relativeToCurrentScript = false)

    {

        return $this->‪getStorage()->‪getPublicUrl($this, $relativeToCurrentScript);

    }


    public function ‪getFiles($start = 0, $numberOfItems = 0, $filterMode = self::FILTER_MODE_USE_OWN_AND_STORAGE_FILTERS, $recursive = false, $sort = '', $sortRev = false)

    {

        // Fallback for compatibility with the old method signature variable $useFilters that was used instead of $filterMode

        if ($filterMode === false) {

            $useFilters = false;

            $backedUpFilters = [];

        } else {

            list($backedUpFilters, $useFilters) = $this->‪prepareFiltersInStorage($filterMode);

        }


        $fileObjects = $this->storage->getFilesInFolder($this, $start, $numberOfItems, $useFilters, $recursive, $sort, $sortRev);


        $this->‪restoreBackedUpFiltersInStorage($backedUpFilters);


        return $fileObjects;

    }


    public function ‪searchFiles(FileSearchDemand $searchDemand, int $filterMode = self::FILTER_MODE_USE_OWN_AND_STORAGE_FILTERS): FileSearchResultInterface

    {

        list($backedUpFilters, $useFilters) = $this->‪prepareFiltersInStorage($filterMode);

        $searchResult = $this->storage->searchFiles($searchDemand, $this, $useFilters);

        $this->‪restoreBackedUpFiltersInStorage($backedUpFilters);


        return $searchResult;

    }


    public function ‪getFileCount(array $filterMethods = [], $recursive = false)

    {

        return $this->storage->countFilesInFolder($this, true, $recursive);

    }


    public function ‪getSubfolder(‪$name)

    {

        if (!$this->storage->hasFolderInFolder(‪$name, $this)) {

            throw new \InvalidArgumentException('Folder "' . ‪$name . '" does not exist in "' . $this->identifier . '"', 1329836110);

        }

        return $this->storage->getFolderInFolder(‪$name, $this);

    }


    public function ‪getSubfolders($start = 0, $numberOfItems = 0, $filterMode = self::FILTER_MODE_USE_OWN_AND_STORAGE_FILTERS, $recursive = false)

    {

        list($backedUpFilters, $useFilters) = $this->‪prepareFiltersInStorage($filterMode);

        $folderObjects = $this->storage->getFoldersInFolder($this, $start, $numberOfItems, $useFilters, $recursive);

        $this->‪restoreBackedUpFiltersInStorage($backedUpFilters);

        return $folderObjects;

    }


    public function ‪addFile($localFilePath, $fileName = null, $conflictMode = ‪DuplicationBehavior::CANCEL)

    {

        $fileName = $fileName ? $fileName : ‪PathUtility::basename($localFilePath);

        return $this->storage->addFile($localFilePath, $this, $fileName, $conflictMode);

    }


    public function ‪addUploadedFile(array $uploadedFileData, $conflictMode = ‪DuplicationBehavior::CANCEL)

    {

        return $this->storage->addUploadedFile($uploadedFileData, $this, $uploadedFileData['name'], $conflictMode);

    }


    public function ‪rename($newName)

    {

        return $this->storage->renameFolder($this, $newName);

    }


    public function delete($deleteRecursively = true)

    {

        return $this->storage->deleteFolder($this, $deleteRecursively);

    }


    public function ‪createFile($fileName)

    {

        return $this->storage->createFile($fileName, $this);

    }


    public function ‪createFolder($folderName)

    {

        return $this->storage->‪createFolder($folderName, $this);

    }


    public function ‪copyTo(Folder $targetFolder, $targetFolderName = null, $conflictMode = ‪DuplicationBehavior::RENAME)

    {

        return $targetFolder->‪getStorage()->‪copyFolder($this, $targetFolder, $targetFolderName, $conflictMode);

    }


    public function ‪moveTo(Folder $targetFolder, $targetFolderName = null, $conflictMode = ‪DuplicationBehavior::RENAME)

    {

        return $targetFolder->‪getStorage()->‪moveFolder($this, $targetFolder, $targetFolderName, $conflictMode);

    }


    public function ‪hasFile(‪$name)

    {

        return $this->storage->hasFileInFolder(‪$name, $this);

    }


    public function ‪hasFolder(‪$name)

    {

        return $this->storage->hasFolderInFolder(‪$name, $this);

    }


    public function ‪checkActionPermission($action)

    {

        try {

            return $this->‪getStorage()->‪checkFolderActionPermission($action, $this);

        } catch (Exception\ResourcePermissionsUnavailableException $e) {

            return false;

        }

    }


    public function ‪updateProperties(array $properties)

    {

        // Setting identifier and name to update values

        if (isset($properties['identifier'])) {

            $this->identifier = $properties['identifier'];

        }

        if (isset($properties['name'])) {

            $this->name = $properties['name'];

        }

    }


    protected function ‪prepareFiltersInStorage($filterMode)

    {

        $backedUpFilters = null;

        $useFilters = true;


        switch ($filterMode) {

            case ‪self::FILTER_MODE_USE_OWN_FILTERS:

                $backedUpFilters = $this->storage->getFileAndFolderNameFilters();

                $this->storage->setFileAndFolderNameFilters($this->fileAndFolderNameFilters);


                break;


            case ‪self::FILTER_MODE_USE_OWN_AND_STORAGE_FILTERS:

                if (!empty($this->fileAndFolderNameFilters)) {

                    $backedUpFilters = $this->storage->getFileAndFolderNameFilters();

                    foreach ($this->fileAndFolderNameFilters as $filter) {

                        $this->storage->addFileAndFolderNameFilter($filter);

                    }

                }


                break;


            case ‪self::FILTER_MODE_USE_STORAGE_FILTERS:

                // nothing to do here


                break;


            case ‪self::FILTER_MODE_NO_FILTERS:

                $useFilters = false;


                break;

        }

        return [$backedUpFilters, $useFilters];

    }


    protected function ‪restoreBackedUpFiltersInStorage($backedUpFilters)

    {

        if ($backedUpFilters !== null) {

            $this->storage->setFileAndFolderNameFilters($backedUpFilters);

        }

    }


    public function ‪setFileAndFolderNameFilters(array $filters)

    {

        $this->fileAndFolderNameFilters = $filters;

    }


    public function ‪getRole()

    {

        return $this->storage->getRole($this);

    }


    public function ‪getParentFolder()

    {

        return $this->‪getStorage()->‪getFolder($this->‪getStorage()->getFolderIdentifierFromFileIdentifier($this->‪getIdentifier()));

    }


    public function ‪getModificationTime()

    {

        return $this->storage->getFolderInfo($this)['mtime'];

    }


    public function ‪getCreationTime()

    {

        return $this->storage->getFolderInfo($this)['ctime'];

    }

}