/** * Perform custom security/access when accessing file * Method should issue 403 if access is rejected * or 401 if authentication is required * * @param \TYPO3\CMS\Core\Resource\ResourceInterface $file * @return void */ public function checkFileAccess(\TYPO3\CMS\Core\Resource\ResourceInterface $file) { if (!$file instanceof \TYPO3\CMS\Core\Resource\File) { $this->originalFile = $file->getOriginalFile(); } else { $this->originalFile = $file; } if (!$this->checkPermissions()) { if (!$this->isLoggedIn()) { if ($this->loginRedirectUrl !== null) { $this->redirectToUrl($this->loginRedirectUrl); } else { $this->exitScript('Authentication required!', 401); } } else { if ($this->noAccessRedirectUrl !== null) { $this->redirectToUrl($this->noAccessRedirectUrl); } else { $this->exitScript('No access!', 403); } } } /** @var \TYPO3\CMS\Extbase\SignalSlot\Dispatcher $signalSlotDispatcher */ $signalSlotDispatcher = GeneralUtility::makeInstance('TYPO3\\CMS\\Extbase\\SignalSlot\\Dispatcher'); $signalSlotDispatcher->dispatch(__CLASS__, 'BeforeFileDump', array($file, $this)); // todo: find a nicer way to force the download. Other hooks are blocked by this if (isset($_REQUEST['download'])) { $file->getStorage()->dumpFileContents($file, true); exit; } }
/** * This method will be called be the signal slot for retrieving the public URL * of a file. * * If the processed file was not modified (the original file is used) and if * that file comes from the storage using the Remote driver the public * URL will be modified to read the image from the remote server. * * @param \TYPO3\CMS\Core\Resource\ResourceStorage $resourceStorage * @param \TYPO3\CMS\Core\Resource\Driver\DriverInterface $driver * @param \TYPO3\CMS\Core\Resource\ResourceInterface $resourceObject * @param bool $relativeToCurrentScript * @param $urlData */ public function adjustPublicUrlForProcessedFiles($resourceStorage, $driver, $resourceObject, $relativeToCurrentScript, $urlData) { if (!$resourceObject instanceof ProcessedFile) { return; } if (!$resourceObject->usesOriginalFile()) { return; } $originalDriver = $this->getDriver($resourceObject->getOriginalFile()->getStorage()); if (!$originalDriver instanceof RemoteDriver) { return; } $urlData['publicUrl'] = $resourceObject->getOriginalFile()->getPublicUrl($relativeToCurrentScript); }
/** * Init * * @return void * @throws \RuntimeException * @throws InsufficientFileAccessPermissionsException */ protected function init() { // Initialize GPvars: $this->uid = (int) GeneralUtility::_GP('uid'); $lang = $this->getLanguageService(); $this->returnUrl = GeneralUtility::sanitizeLocalUrl(GeneralUtility::_GP('returnUrl')); // Cleaning and checking uid if ($this->uid > 0) { $this->fileOrFolderObject = ResourceFactory::getInstance()->retrieveFileOrFolderObject('file:' . $this->uid); } if (!$this->fileOrFolderObject) { $title = $lang->sL('LLL:EXT:lang/locallang_mod_file_list.xlf:paramError', true); $message = $lang->sL('LLL:EXT:lang/locallang_mod_file_list.xlf:targetNoDir', true); throw new \RuntimeException($title . ': ' . $message, 1436895930); } if ($this->fileOrFolderObject->getStorage()->getUid() === 0) { throw new InsufficientFileAccessPermissionsException('You are not allowed to access files outside your storages', 1436895931); } // If a folder should be renamed, AND the returnURL should go to the old directory name, the redirect is forced // so the redirect will NOT end in an error message // this case only happens if you select the folder itself in the foldertree and then use the clickmenu to // rename the folder if ($this->fileOrFolderObject instanceof Folder) { $parsedUrl = parse_url($this->returnUrl); $queryParts = GeneralUtility::explodeUrl2Array(urldecode($parsedUrl['query'])); if ($queryParts['id'] === $this->fileOrFolderObject->getCombinedIdentifier()) { $this->returnUrl = str_replace(urlencode($queryParts['id']), urlencode($this->fileOrFolderObject->getStorage()->getRootLevelFolder()->getCombinedIdentifier()), $this->returnUrl); } } $pathInfo = ['combined_identifier' => $this->fileOrFolderObject->getCombinedIdentifier()]; $this->moduleTemplate->getDocHeaderComponent()->setMetaInformation($pathInfo); $this->moduleTemplate->getPageRenderer()->loadRequireJsModule('TYPO3/CMS/Backend/ClickMenu'); $this->moduleTemplate->addJavaScriptCode('ReplaceFileOnlineJavaScript', 'function backToList() {top.goToModule("file_FilelistList");}'); }
/** * Publishes a persistent resource to the web accessible resources directory * * @param ResourceInterface $resource The resource to publish * @return mixed Either the web URI of the published resource or FALSE if the resource source file doesn't exist or the resource could not be published for other reasons */ public function publishResource(ResourceInterface $resource) { $publicUrl = FALSE; // We only manipulate the URL if we are in the backend or in FAL mode in FE (otherwise we parse the HTML) if (!$this->getRequestContext()->isFrontendRequest() || $this->configurationManager->getValue('enableFileAbstractionLayerHandling')) { $this->setResourcesSourcePath($this->getResourcesSourcePathByResourceStorage($resource->getStorage())); if ($this->isSourcePathInDocumentRoot()) { if (!$this->isPubliclyAvailable($resource)) { $publicUrl = $this->buildUri($this->getResourceUri($resource)); } } else { // TODO: Maybe implement this case? // We need to use absolute paths then or copy the files around, or... } } return $publicUrl; }
/** * @param \TYPO3\CMS\Core\Resource\ResourceStorage $resourceStorage * @param \TYPO3\CMS\Core\Resource\Driver\DriverInterface $driver * @param \TYPO3\CMS\Core\Resource\ResourceInterface $resourceObject * @param boolean $relativeToCurrentScript * @param string $urlData */ public function getCdnPublicUrl($resourceStorage, $driver, $resourceObject, $relativeToCurrentScript, $urlData) { if (!$driver instanceof LocalDriver || $this->environmentService->isEnvironmentInBackendMode()) { return; } if (($resourceObject instanceof File || $resourceObject instanceof ProcessedFile) && ($resourceStorage->getCapabilities() & ResourceStorageInterface::CAPABILITY_PUBLIC) == ResourceStorageInterface::CAPABILITY_PUBLIC) { $publicUrl = $driver->getPublicUrl($resourceObject->getIdentifier()); $urlData['publicUrl'] = $GLOBALS['TSFE']->config['config']['cdnBaseUrl'] . $publicUrl; if ($resourceObject instanceof File) { $urlData['publicUrl'] .= '?' . $resourceObject->getModificationTime(); } else { if ($resourceObject instanceof ProcessedFile) { $urlData['publicUrl'] .= '?' . $resourceObject->getProperty('tstamp'); } } } }
/** * Main function, rendering the content of the rename form * * @return void */ public function main() { // Make page header: $this->content = $this->doc->startPage($GLOBALS['LANG']->sL('LLL:EXT:lang/locallang_core.xlf:file_rename.php.pagetitle')); $pageContent = $this->doc->header($GLOBALS['LANG']->sL('LLL:EXT:lang/locallang_core.xlf:file_rename.php.pagetitle')); $pageContent .= $this->doc->spacer(5); $pageContent .= $this->doc->divider(5); if ($this->fileOrFolderObject instanceof \TYPO3\CMS\Core\Resource\Folder) { $fileIdentifier = $this->fileOrFolderObject->getCombinedIdentifier(); } else { $fileIdentifier = $this->fileOrFolderObject->getUid(); } $code = '<form action="tce_file.php" method="post" name="editform">'; // Making the formfields for renaming: $code .= ' <div id="c-rename"> <input type="text" name="file[rename][0][target]" value="' . htmlspecialchars($this->fileOrFolderObject->getName()) . '"' . $GLOBALS['TBE_TEMPLATE']->formWidth(40) . ' /> <input type="hidden" name="file[rename][0][data]" value="' . htmlspecialchars($fileIdentifier) . '" /> </div> '; // Making submit button: $code .= ' <div id="c-submit"> <input type="submit" value="' . $GLOBALS['LANG']->sL('LLL:EXT:lang/locallang_core.xlf:file_rename.php.submit', TRUE) . '" /> <input type="submit" value="' . $GLOBALS['LANG']->sL('LLL:EXT:lang/locallang_core.xlf:labels.cancel', TRUE) . '" onclick="backToList(); return false;" /> <input type="hidden" name="redirect" value="' . htmlspecialchars($this->returnUrl) . '" /> ' . \TYPO3\CMS\Backend\Form\FormEngine::getHiddenTokenField('tceAction') . ' </div> '; $code .= '</form>'; // Add the HTML as a section: $pageContent .= $code; $docHeaderButtons = array('back' => ''); $docHeaderButtons['csh'] = BackendUtility::cshItem('xMOD_csh_corebe', 'file_rename', $GLOBALS['BACK_PATH']); // Back if ($this->returnUrl) { $docHeaderButtons['back'] = '<a href="' . htmlspecialchars(\TYPO3\CMS\Core\Utility\GeneralUtility::linkThisUrl($this->returnUrl)) . '" class="typo3-goBack" title="' . $GLOBALS['LANG']->sL('LLL:EXT:lang/locallang_core.xlf:labels.goBack', TRUE) . '">' . \TYPO3\CMS\Backend\Utility\IconUtility::getSpriteIcon('actions-view-go-back') . '</a>'; } // Add the HTML as a section: $markerArray = array('CSH' => $docHeaderButtons['csh'], 'FUNC_MENU' => BackendUtility::getFuncMenu($this->id, 'SET[function]', $this->MOD_SETTINGS['function'], $this->MOD_MENU['function']), 'CONTENT' => $pageContent, 'PATH' => $this->title); $this->content .= $this->doc->moduleBody(array(), $docHeaderButtons, $markerArray); $this->content .= $this->doc->endPage(); $this->content = $this->doc->insertStylesAndJS($this->content); }
/** * @param \TYPO3\CMS\Core\Resource\ResourceInterface $resource * @param $iconName * @param array $options * @param array $overlays */ public function overrideResourceIcon(\TYPO3\CMS\Core\Resource\ResourceInterface $resource, &$iconName, array &$options, array &$overlays) { if (!$resource->getStorage()->isPublic()) { /** @var $checkPermissionsService \BeechIt\FalSecuredownload\Security\CheckPermissions */ $checkPermissionsService = \TYPO3\CMS\Core\Utility\GeneralUtility::makeInstance('BeechIt\\FalSecuredownload\\Security\\CheckPermissions'); $currentPermissionsCheck = $resource->getStorage()->getEvaluatePermissions(); $resource->getStorage()->setEvaluatePermissions(false); if ($resource instanceof \TYPO3\CMS\Core\Resource\Folder) { $folder = $resource; } else { $folder = $resource->getParentFolder(); } if ($resource instanceof \TYPO3\CMS\Core\Resource\File && $resource->getProperty('fe_groups')) { $overlays['status-overlay-access-restricted'] = array(); // check if there are permissions set on this specific folder } elseif ($folder === $resource && $checkPermissionsService->getFolderPermissions($folder) !== false) { $overlays['status-overlay-access-restricted'] = array(); // check if there are access restrictions in the root line of this folder } elseif (!$checkPermissionsService->checkFolderRootLineAccess($folder, false)) { $overlays['extensions-fal_securedownload-overlay-permissions'] = array(); } $resource->getStorage()->setEvaluatePermissions($currentPermissionsCheck); } }
/** * Checks if a resource (file or folder) is within the given folder * * @param Folder $folder * @param ResourceInterface $resource * @return bool * @throws \InvalidArgumentException */ 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()); }
/** * This method is used throughout the TYPO3 Backend to show icons for files and folders * * The method takes care of the translation of file extension to proper icon and for folders * it will return the icon depending on the role of the folder. * * If the given resource is a folder there are some additional options that can be used: * - mount-root => TRUE (to indicate this is the root of a mount) * - folder-open => TRUE (to indicate that the folder is opened in the file tree) * * There is a hook in place to manipulate the icon name and overlays. * * @param \TYPO3\CMS\Core\Resource\ResourceInterface $resource * @param array $options An associative array with additional options and attributes for the tag. See self::getSpriteIcon() * @param array $overlays An associative array with the icon-name as key, and the options for this overlay as an array again (see the parameter $options again) * @return string * @throws \UnexpectedValueException */ public static function getSpriteIconForResource(\TYPO3\CMS\Core\Resource\ResourceInterface $resource, array $options = array(), array $overlays = array()) { // Folder if ($resource instanceof \TYPO3\CMS\Core\Resource\FolderInterface) { $iconName = NULL; $role = $resource->getRole(); // non browsable storage if ($resource->getStorage()->isBrowsable() === FALSE && !empty($options['mount-root'])) { $iconName = 'apps-filetree-folder-locked'; } else { // storage root if ($resource->getStorage()->getRootLevelFolder()->getIdentifier() === $resource->getIdentifier()) { $iconName = 'apps-filetree-root'; } // user/group mount root if (!empty($options['mount-root'])) { $iconName = 'apps-filetree-mount'; if ($role === \TYPO3\CMS\Core\Resource\FolderInterface::ROLE_READONLY_MOUNT) { $overlays['status-overlay-locked'] = array(); } elseif ($role === \TYPO3\CMS\Core\Resource\FolderInterface::ROLE_USER_MOUNT) { $overlays['status-overlay-access-restricted'] = array(); } } if ($iconName === NULL) { // in folder tree view $options['folder-open'] can define a open folder icon if (!empty($options['folder-open'])) { $iconName = 'apps-filetree-folder-opened'; } else { $iconName = 'apps-filetree-folder-default'; } if ($role === \TYPO3\CMS\Core\Resource\FolderInterface::ROLE_TEMPORARY) { $iconName = 'apps-filetree-folder-temp'; } elseif ($role === \TYPO3\CMS\Core\Resource\FolderInterface::ROLE_RECYCLER) { $iconName = 'apps-filetree-folder-recycler'; } } // if locked add overlay if ($resource instanceof \TYPO3\CMS\Core\Resource\InaccessibleFolder || !$resource->getStorage()->isBrowsable() || !$resource->getStorage()->checkFolderActionPermission('add', $resource)) { $overlays['status-overlay-locked'] = array(); } } // File } else { $iconName = self::mapFileExtensionToSpriteIconName($resource->getExtension()); if ($resource instanceof \TYPO3\CMS\Core\Resource\File && $resource->isMissing()) { $overlays['status-overlay-missing'] = array(); } } // Hook: allow some other process to influence the choice of icon and overlays if (is_array($GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['t3lib/class.t3lib_iconworks.php']['overrideResourceIcon'])) { foreach ($GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['t3lib/class.t3lib_iconworks.php']['overrideResourceIcon'] as $classRef) { $hookObject = GeneralUtility::getUserObj($classRef); if (!$hookObject instanceof IconUtilityOverrideResourceIconHookInterface) { throw new \UnexpectedValueException('$hookObject must implement interface TYPO3\\CMS\\Backend\\Utility\\IconUtilityOverrideResourceIconHookInterface', 1393574895); } $hookObject->overrideResourceIcon($resource, $iconName, $options, $overlays); } } unset($options['mount-root']); unset($options['folder-open']); return self::getSpriteIcon($iconName, $options, $overlays); }
/** * This method is used throughout the TYPO3 Backend to show icons for files and folders * * The method takes care of the translation of file extension to proper icon and for folders * it will return the icon depending on the role of the folder. * * If the given resource is a folder there are some additional options that can be used: * - mount-root => TRUE (to indicate this is the root of a mount) * - folder-open => TRUE (to indicate that the folder is opened in the file tree) * * There is a hook in place to manipulate the icon name and overlays. * * @param ResourceInterface $resource * @param string $size "large" "small" or "default", see the constants of the Icon class * @param string $overlayIdentifier * @param array $options An associative array with additional options. * @return Icon */ public function getIconForResource(ResourceInterface $resource, $size = Icon::SIZE_DEFAULT, $overlayIdentifier = null, array $options = array()) { $iconIdentifier = null; // Folder if ($resource instanceof FolderInterface) { // non browsable storage if ($resource->getStorage()->isBrowsable() === false && !empty($options['mount-root'])) { $iconIdentifier = 'apps-filetree-folder-locked'; } else { // storage root if ($resource->getStorage()->getRootLevelFolder()->getIdentifier() === $resource->getIdentifier()) { $iconIdentifier = 'apps-filetree-root'; } $role = is_callable([$resource, 'getRole']) ? $resource->getRole() : ''; // user/group mount root if (!empty($options['mount-root'])) { $iconIdentifier = 'apps-filetree-mount'; if ($role === FolderInterface::ROLE_READONLY_MOUNT) { $overlayIdentifier = 'overlay-locked'; } elseif ($role === FolderInterface::ROLE_USER_MOUNT) { $overlayIdentifier = 'overlay-restricted'; } } if ($iconIdentifier === null) { // in folder tree view $options['folder-open'] can define an open folder icon if (!empty($options['folder-open'])) { $iconIdentifier = 'apps-filetree-folder-opened'; } else { $iconIdentifier = 'apps-filetree-folder-default'; } if ($role === FolderInterface::ROLE_TEMPORARY) { $iconIdentifier = 'apps-filetree-folder-temp'; } elseif ($role === FolderInterface::ROLE_RECYCLER) { $iconIdentifier = 'apps-filetree-folder-recycler'; } } // if locked add overlay if ($resource instanceof InaccessibleFolder || !$resource->getStorage()->isBrowsable() || !$resource->getStorage()->checkFolderActionPermission('add', $resource)) { $overlayIdentifier = 'overlay-locked'; } } // File } else { if ($resource instanceof File && $resource->isMissing()) { $overlayIdentifier = 'overlay-missing'; } $iconRegistry = GeneralUtility::makeInstance(IconRegistry::class); $iconIdentifier = $iconRegistry->getIconIdentifierForFileExtension($resource->getExtension()); } unset($options['mount-root']); unset($options['folder-open']); list($iconIdentifier, $overlayIdentifier) = $this->emitBuildIconForResourceSignal($resource, $size, $options, $iconIdentifier, $overlayIdentifier); return $this->getIcon($iconIdentifier, $size, $overlayIdentifier); }
/** * Returns the public URL to a file. For the local driver, this will always * return a path relative to PATH_site. * * @param \TYPO3\CMS\Core\Resource\ResourceInterface $fileOrFolder * @param bool $relativeToCurrentScript Determines whether the URL returned should be relative to the current script, in case it is relative at all (only for the LocalDriver) * @return string */ public function getPublicUrl(\TYPO3\CMS\Core\Resource\ResourceInterface $fileOrFolder, $relativeToCurrentScript = FALSE) { if ($this->configuration['pathType'] === 'relative' && rtrim($this->configuration['basePath'], '/') !== '') { $publicUrl = rtrim($this->configuration['basePath'], '/') . '/' . ltrim($fileOrFolder->getIdentifier(), '/'); } elseif (isset($this->baseUri)) { $publicUrl = $this->baseUri . ltrim($fileOrFolder->getIdentifier(), '/'); } else { throw new \TYPO3\CMS\Core\Resource\Exception('Public URL of file cannot be determined', 1329765518); } // If requested, make the path relative to the current script in order to make it possible // to use the relative file if ($relativeToCurrentScript) { $publicUrl = \TYPO3\CMS\Core\Utility\PathUtility::getRelativePathTo(dirname(PATH_site . $publicUrl)) . basename($publicUrl); } return $publicUrl; }
/** * Like ->getHeader() but for files and folders * Returns the icon with the path of the file/folder set in the alt/title attribute. Shows the name after the icon. * * @param \TYPO3\CMS\Core\Resource\ResourceInterface $resource * @param array $tWrap is an array with indexes 0 and 1 each representing HTML-tags (start/end) which will wrap the title * @param bool $enableClickMenu If TRUE, render click menu code around icon image * @return string */ public function getResourceHeader(\TYPO3\CMS\Core\Resource\ResourceInterface $resource, $tWrap = array('', ''), $enableClickMenu = true) { try { $path = $resource->getStorage()->getName() . $resource->getParentFolder()->getIdentifier(); $iconImgTag = '<span title="' . htmlspecialchars($path) . '">' . $this->iconFactory->getIconForResource($resource, Icon::SIZE_SMALL)->render() . '</span>'; } catch (\TYPO3\CMS\Core\Resource\Exception\ResourceDoesNotExistException $e) { $iconImgTag = ''; } if ($enableClickMenu && $resource instanceof \TYPO3\CMS\Core\Resource\File) { $metaData = $resource->_getMetaData(); $iconImgTag = BackendUtility::wrapClickMenuOnIcon($iconImgTag, 'sys_file_metadata', $metaData['uid']); } return '<span class="typo3-moduleHeader">' . $iconImgTag . $tWrap[0] . htmlspecialchars(GeneralUtility::fixed_lgd_cs($resource->getName(), 45)) . $tWrap[1] . '</span>'; }
/** * Get FeGroups that are allowed to view a file/folder (checks full rootline) * * @param ResourceInterface $resource * @return string */ public function getPermissions(ResourceInterface $resource) { $currentPermissionsCheck = $resource->getStorage()->getEvaluatePermissions(); $resource->getStorage()->setEvaluatePermissions(false); $feGroups = array(); // loop trough the root line of an folder and check the permissions of every folder foreach ($this->getFolderRootLine($resource->getParentFolder()) as $folder) { // fetch folder permissions record $folderRecord = $this->utilityService->getFolderRecord($folder); // if record found check permissions if ($folderRecord) { if ($feGroups === array()) { $feGroups = GeneralUtility::trimExplode(',', $folderRecord['fe_groups'], true); } if ($folderRecord['fe_groups']) { $feGroups = GeneralUtility::keepItemsInArray($feGroups, $folderRecord['fe_groups']); } break; } } if ($resource instanceof File && $resource->getProperty('fe_groups')) { $feGroups = GeneralUtility::keepItemsInArray($feGroups, $resource->getProperty('fe_groups')); } $resource->getStorage()->setEvaluatePermissions($currentPermissionsCheck); return implode(',', $feGroups); }
/** * @param ResourceInterface $resource * @return string */ protected function getResourceSourcePathAndFileName(ResourceInterface $resource) { $pathAndFilename = $this->resourcesSourcePath . ltrim($resource->getIdentifier(), '/'); return file_exists($pathAndFilename) ? $pathAndFilename : FALSE; }
/** * Retrieve data from a file reference * * @param \TYPO3\CMS\Core\Resource\ResourceInterface|Folder|\TYPO3\CMS\Core\Resource\AbstractFile $originalResource * @return array */ protected function transformFileReference($originalResource) { static $depth = 0; if ($originalResource instanceof AbstractFileFolder) { if (++$depth > 10) { throw new \RuntimeException('Max nesting level'); } $result = $this->transformFileReference($originalResource->getOriginalResource()); $depth--; return $result; } try { if ($originalResource instanceof Folder) { $filesInFolder = array(); foreach ($originalResource->getFiles() as $currentFile) { $filesInFolder[] = $this->transformFileReference($currentFile); } return $filesInFolder; } if ($originalResource instanceof FileReference) { // This would expose all data // return $originalResource->getProperties(); list($title, $description) = $this->getTitleAndDescription($originalResource); return array('name' => $originalResource->getName(), 'mimeType' => $originalResource->getMimeType(), 'url' => $originalResource->getPublicUrl(), 'size' => $originalResource->getSize(), 'title' => $title, 'description' => $description); } if ($originalResource instanceof FileInterface) { return array('name' => $originalResource->getName(), 'mimeType' => $originalResource->getMimeType(), 'url' => $originalResource->getPublicUrl(), 'size' => $originalResource->getSize()); } return array('name' => $originalResource->getName()); } catch (\RuntimeException $exception) { return array(); } }
/** * Like ->getHeader() but for files and folders * Returns the icon with the path of the file/folder set in the alt/title attribute. Shows the name after the icon. * * @param \TYPO3\CMS\Core\Resource\ResourceInterface $resource * @param array $tWrap is an array with indexes 0 and 1 each representing HTML-tags (start/end) which will wrap the title * @param bool $enableClickMenu If TRUE, render click menu code around icon image * @return string */ public function getResourceHeader(\TYPO3\CMS\Core\Resource\ResourceInterface $resource, $tWrap = array('', ''), $enableClickMenu = TRUE) { $path = $resource->getStorage()->getName() . $resource->getParentFolder()->getIdentifier(); $iconImgTag = IconUtility::getSpriteIconForResource($resource, array('title' => htmlspecialchars($path))); if ($enableClickMenu && $resource instanceof \TYPO3\CMS\Core\Resource\File) { $metaData = $resource->_getMetaData(); $iconImgTag = $this->wrapClickMenuOnIcon($iconImgTag, 'sys_file_metadata', $metaData['uid']); } return '<span class="typo3-moduleHeader">' . $iconImgTag . $tWrap[0] . htmlspecialchars(GeneralUtility::fixed_lgd_cs($resource->getName(), 45)) . $tWrap[1] . '</span>'; }
/** * @param \TYPO3\CMS\Core\Resource\ResourceInterface $originalResource */ public function setOriginalResource(\TYPO3\CMS\Core\Resource\ResourceInterface $originalResource) { $this->originalResource = $originalResource; $this->uidLocal = (int) $originalResource->getOriginalFile()->getUid(); }
/** * Returns the public URL to a file. * * @param \TYPO3\CMS\Core\Resource\ResourceInterface $resource * @param bool $relativeToCurrentScript Determines whether the URL returned should be relative to the current script, in case it is relative at all (only for the LocalDriver) * @return string */ public function getPublicUrl(\TYPO3\CMS\Core\Resource\ResourceInterface $resource, $relativeToCurrentScript = false) { if (\TYPO3\CMS\Core\Utility\GeneralUtility::isFirstPartOfStr($resource->getIdentifier(), '/_processed_/')) { $publicUrl = '../typo3temp/yag' . $resource->getIdentifier(); // TODO: ....!!!! } else { $item = $resource->getProperty('yagItem'); if (!$item instanceof \Tx_Yag_Domain_Model_Item) { $pathInfo = new PathInfo($resource->getIdentifier()); $item = $this->getItem($pathInfo); } $publicUrl = $this->yagFileSystemDiv->getFileRelFileName($item->getSourceuri()); } if ($relativeToCurrentScript) { $publicUrl = PathUtility::getRelativePathTo(PathUtility::dirname(PATH_site . $publicUrl)) . PathUtility::basename($publicUrl); } return $publicUrl; }
/** * This method is used throughout the TYPO3 Backend to show icons for files and folders * * The method takes care of the translation of file extension to proper icon and for folders * it will return the icon depending on the role of the folder. * * If the given resource is a folder there are some additional options that can be used: * - mount-root => TRUE (to indicate this is the root of a mount) * - folder-open => TRUE (to indicate that the folder is opened in the file tree) * * There is a hook in place to manipulate the icon name and overlays. * * @param ResourceInterface $resource * @param string $size "large" "small" or "default", see the constants of the Icon class * @param string $overlayIdentifier * @param array $options An associative array with additional options. * @return Icon */ public function getIconForResource(ResourceInterface $resource, $size = Icon::SIZE_DEFAULT, $overlayIdentifier = null, array $options = array()) { $iconIdentifier = null; // Folder if ($resource instanceof FolderInterface) { // non browsable storage if ($resource->getStorage()->isBrowsable() === false && !empty($options['mount-root'])) { $iconIdentifier = 'apps-filetree-folder-locked'; } else { // storage root if ($resource->getStorage()->getRootLevelFolder()->getIdentifier() === $resource->getIdentifier()) { $iconIdentifier = 'apps-filetree-root'; } $role = is_callable([$resource, 'getRole']) ? $resource->getRole() : ''; // user/group mount root if (!empty($options['mount-root'])) { $iconIdentifier = 'apps-filetree-mount'; if ($role === FolderInterface::ROLE_READONLY_MOUNT) { $overlayIdentifier = 'overlay-locked'; } elseif ($role === FolderInterface::ROLE_USER_MOUNT) { $overlayIdentifier = 'overlay-restricted'; } } if ($iconIdentifier === null) { // in folder tree view $options['folder-open'] can define an open folder icon if (!empty($options['folder-open'])) { $iconIdentifier = 'apps-filetree-folder-opened'; } else { $iconIdentifier = 'apps-filetree-folder-default'; } if ($role === FolderInterface::ROLE_TEMPORARY) { $iconIdentifier = 'apps-filetree-folder-temp'; } elseif ($role === FolderInterface::ROLE_RECYCLER) { $iconIdentifier = 'apps-filetree-folder-recycler'; } } // if locked add overlay if ($resource instanceof InaccessibleFolder || !$resource->getStorage()->isBrowsable() || !$resource->getStorage()->checkFolderActionPermission('add', $resource)) { $overlayIdentifier = 'overlay-locked'; } } // File } elseif ($resource instanceof File) { $mimeTypeIcon = $this->iconRegistry->getIconIdentifierForMimeType($resource->getMimeType()); // Check if we find a exact matching mime type if ($mimeTypeIcon !== null) { $iconIdentifier = $mimeTypeIcon; } else { $fileExtensionIcon = $this->iconRegistry->getIconIdentifierForFileExtension($resource->getExtension()); if ($fileExtensionIcon !== 'mimetypes-other-other') { // Fallback 1: icon by file extension $iconIdentifier = $fileExtensionIcon; } else { // Fallback 2: icon by mime type with subtype replaced by * $mimeTypeParts = explode('/', $resource->getMimeType()); $mimeTypeIcon = $this->iconRegistry->getIconIdentifierForMimeType($mimeTypeParts[0] . '/*'); if ($mimeTypeIcon !== null) { $iconIdentifier = $mimeTypeIcon; } else { // Fallback 3: use 'mimetypes-other-other' $iconIdentifier = $fileExtensionIcon; } } } if ($resource->isMissing()) { $overlayIdentifier = 'overlay-missing'; } } unset($options['mount-root']); unset($options['folder-open']); list($iconIdentifier, $overlayIdentifier) = $this->emitBuildIconForResourceSignal($resource, $size, $options, $iconIdentifier, $overlayIdentifier); return $this->getIcon($iconIdentifier, $size, $overlayIdentifier); }
/** * @param ResourceInterface $resource * @return string */ protected function getResourceUri(ResourceInterface $resource) { return PathUtility::getCanonicalPath($this->getResourcesBaseUri() . '/' . $resource->getIdentifier()); }