/** * Render the URI to the resource. The filename is used from child content. * * @param string $path The location of the resource, can be either a path relative to the Public resource directory of the package or a resource://... URI * @param string $package Target package key. If not set, the current package key will be used * @param PersistentResource $resource If specified, this resource object is used instead of the path and package information * @param boolean $localize Whether resource localization should be attempted or not * @return string The absolute URI to the resource * @throws InvalidVariableException * @api */ public function render($path = null, $package = null, PersistentResource $resource = null, $localize = true) { if ($resource !== null) { $uri = $this->resourceManager->getPublicPersistentResourceUri($resource); if ($uri === false) { $uri = '404-Resource-Not-Found'; } } else { if ($path === null) { throw new InvalidVariableException('The ResourceViewHelper did neither contain a valuable "resource" nor "path" argument.', 1353512742); } if ($package === null) { $package = $this->controllerContext->getRequest()->getControllerPackageKey(); } if (strpos($path, 'resource://') === 0) { try { list($package, $path) = $this->resourceManager->getPackageAndPathByPublicPath($path); } catch (Exception $exception) { throw new InvalidVariableException(sprintf('The specified path "%s" does not point to a public resource.', $path), 1386458851); } } if ($localize === true) { $resourcePath = 'resource://' . $package . '/Public/' . $path; $localizedResourcePathData = $this->i18nService->getLocalizedFilename($resourcePath); $matches = array(); if (preg_match('#resource://([^/]+)/Public/(.*)#', current($localizedResourcePathData), $matches) === 1) { $package = $matches[1]; $path = $matches[2]; } } $uri = $this->resourceManager->getPublicPackageResourceUri($package, $path); } return $uri; }
/** * Upload a new image and return an image variant, a thumbnail and additional information like it would be * returned for the Neos backend. * * @param Image $image * @return string */ public function uploadAction(Image $image) { $this->assetRepository->add($image); $imageVariant = new ImageVariant($image); $this->assetRepository->add($imageVariant); $thumbnail = $image->getThumbnail(100, 100); $this->response->setHeader('Content-Type', 'application/json'); return json_encode(array('__identity' => $this->persistenceManager->getIdentifierByObject($image), '__resourceUri' => $this->resourceManager->getPublicPersistentResourceUri($image->getResource()), 'width' => $image->getWidth(), 'height' => $image->getHeight(), 'thumbnail' => array('__resourceUri' => $this->resourceManager->getPublicPersistentResourceUri($thumbnail->getResource()), 'width' => $thumbnail->getWidth(), 'height' => $thumbnail->getHeight()), 'variants' => array(array('__identity' => $this->persistenceManager->getIdentifierByObject($imageVariant), '__resourceUri' => $this->resourceManager->getPublicPersistentResourceUri($imageVariant->getResource()), 'width' => $imageVariant->getWidth(), 'height' => $imageVariant->getHeight())))); }
/** * Get the header include code for including Twitter Bootstrap on a page. If needed * the jQuery library can be included, too. * * Example usage: * {namespace bootstrap=Neos\Twitter\Bootstrap\ViewHelpers} * <bootstrap:include /> * * @param string $version The version to use, for example "2.2", "3.0" or also "2" or "3" meaning "2.x" and "3.x" respectively * @param boolean $minified If the minified version of Twitter Bootstrap should be used * @param boolean $includeJQuery If enabled, also includes jQuery * @param string $jQueryVersion The jQuery version to include * @return string */ public function render($version, $minified = TRUE, $includeJQuery = FALSE, $jQueryVersion = '1.10.1') { $content = sprintf('<link rel="stylesheet" href="%s" />' . PHP_EOL, $this->resourceManager->getPublicPackageResourceUri('Neos\\Twitter.Bootstrap', $version . '/css/bootstrap' . ($minified === TRUE ? '.min' : '') . '.css')); if ($includeJQuery === TRUE) { $content .= sprintf('<script src="%s"></script>' . PHP_EOL, $this->resourceManager->getPublicPackageResourceUri('Neos\\Twitter.Bootstrap', 'Libraries/jQuery/jquery-' . $jQueryVersion . ($minified === TRUE ? '.min' : '') . '.js')); } $content .= sprintf('<script src="%s"></script>' . PHP_EOL, $this->resourceManager->getPublicPackageResourceUri('Neos\\Twitter.Bootstrap', $version . '/js/bootstrap' . ($minified === TRUE ? '.min' : '') . '.js')); return $content; }
/** * @test */ public function openResolvesAnUpperCaseSha1HashUsingTheResourceManager() { $sha1Hash = '68AC906495480A3404BEEE4874ED853A037A7A8F'; $tempFile = tmpfile(); $mockResource = $this->getMockBuilder(PersistentResource::class)->disableOriginalConstructor()->getMock(); $this->mockResourceManager->expects($this->once())->method('getResourceBySha1')->with($sha1Hash)->will($this->returnValue($mockResource)); $this->mockResourceManager->expects($this->once())->method('getStreamByResource')->with($mockResource)->will($this->returnValue($tempFile)); $openedPathAndFilename = ''; $this->assertTrue($this->resourceStreamWrapper->open('resource://' . $sha1Hash, 'r', 0, $openedPathAndFilename)); $this->assertAttributeSame($tempFile, 'handle', $this->resourceStreamWrapper); }
/** * Renders an <img> HTML tag for a filetype icon for a given Neos.Media's asset instance * * @param AssetInterface $file * @param integer|null $width * @param integer|null $height * @return string */ public function render(AssetInterface $file, $width = null, $height = null) { $icon = FileTypeIconService::getIcon($file, $width, $height); $this->tag->addAttribute('src', $this->resourceManager->getPublicPackageResourceUriByPath($icon['src'])); $this->tag->addAttribute('alt', $icon['alt']); if ($width !== null) { $this->tag->addAttribute('width', $width); } if ($height !== null) { $this->tag->addAttribute('height', $height); } return $this->tag->render(); }
/** * @param string $presetName name of the preset to use * @return string the rendered form head */ public function render($presetName = 'default') { $content = ''; $presetConfiguration = $this->formBuilderFactory->getPresetConfiguration($presetName); $stylesheets = isset($presetConfiguration['stylesheets']) ? $presetConfiguration['stylesheets'] : []; foreach ($stylesheets as $stylesheet) { $content .= sprintf('<link href="%s" rel="stylesheet">', $this->resourceManager->getPublicPackageResourceUriByPath($stylesheet['source'])); } $javaScripts = isset($presetConfiguration['javaScripts']) ? $presetConfiguration['javaScripts'] : []; foreach ($javaScripts as $javaScript) { $content .= sprintf('<script src="%s"></script>', $this->resourceManager->getPublicPackageResourceUriByPath($javaScript['source'])); } return $content; }
/** * @return Asset * @throws \Neos\Flow\ResourceManagement\Exception */ protected function buildAssetObject() { $resource = $this->resourceManager->importResourceFromContent('Test', 'test.txt'); $asset = new Asset($resource); $this->assetRepository->add($asset); return $asset; }
/** * @test */ public function convertFromReturnsAnErrorIfTheUploadedFileCantBeImported() { $this->inject($this->resourceTypeConverter, 'systemLogger', $this->createMock(SystemLoggerInterface::class)); $source = ['tmp_name' => 'SomeFilename', 'error' => \UPLOAD_ERR_OK]; $this->mockResourceManager->expects($this->once())->method('importUploadedResource')->with($source)->will($this->throwException(new Exception())); $actualResult = $this->resourceTypeConverter->convertFrom($source, PersistentResource::class); $this->assertInstanceOf(FlowError\Error::class, $actualResult); }
/** * Resolves a given asset:// URI to a "normal" HTTP(S) URI for the addressed asset's resource. * * @param string|Uri $uri * @return string */ public function resolveAssetUri($uri) { $targetObject = $this->convertUriToObject($uri); if ($targetObject === null) { $this->systemLogger->log(sprintf('Could not resolve "%s" to an existing asset; The asset was probably deleted.', $uri)); return null; } return $this->resourceManager->getPublicPersistentResourceUri($targetObject->getResource()); }
/** * @param Image $image * @return array */ protected function getImagePreviewData(Image $image) { $imageProperties = ['originalImageResourceUri' => $this->resourceManager->getPublicPersistentResourceUri($image->getResource()), 'originalDimensions' => ['width' => $image->getWidth(), 'height' => $image->getHeight(), 'aspectRatio' => $image->getAspectRatio()], 'mediaType' => $image->getResource()->getMediaType()]; $thumbnail = $this->thumbnailService->getThumbnail($image, $this->thumbnailService->getThumbnailConfigurationForPreset('Neos.Media.Browser:Preview')); if ($thumbnail !== null) { $imageProperties['previewImageResourceUri'] = $this->thumbnailService->getUriForThumbnail($thumbnail); $imageProperties['previewDimensions'] = ['width' => $thumbnail->getWidth(), 'height' => $thumbnail->getHeight()]; } return $imageProperties; }
/** * @param ImageInterface $thumbnail * @return string * @throws ThumbnailServiceException */ public function getUriForThumbnail(ImageInterface $thumbnail) { $resource = $thumbnail->getResource(); if ($resource) { return $this->resourceManager->getPublicPersistentResourceUri($resource); } $staticResource = $thumbnail->getStaticResource(); if ($staticResource === null) { throw new ThumbnailServiceException(sprintf('Could not generate URI for static thumbnail "%s".', $this->persistenceManager->getIdentifierByObject($thumbnail)), 1450178437); } return $this->resourceManager->getPublicPackageResourceUriByPath($staticResource); }
/** * @param string $resourcePath * @return string */ protected function getStaticResourceWebBaseUri($resourcePath) { $localizedResourcePathData = $this->i18nService->getLocalizedFilename($resourcePath); $matches = array(); try { if (preg_match('#resource://([^/]+)/Public/(.*)#', current($localizedResourcePathData), $matches) === 1) { $packageKey = $matches[1]; $path = $matches[2]; return $this->resourceManager->getPublicPackageResourceUri($packageKey, $path); } } catch (\Exception $exception) { $this->systemLogger->logException($exception); } return ''; }
/** * Returns the absolute URL of a resource * * @return string * @throws TypoScriptException */ public function evaluate() { $resource = $this->getResource(); if ($resource !== null) { $uri = false; if ($resource instanceof PersistentResource) { $uri = $this->resourceManager->getPublicPersistentResourceUri($resource); } if ($uri === false) { throw new TypoScriptException('The specified resource is invalid', 1386458728); } return $uri; } $path = $this->getPath(); if ($path === null) { throw new TypoScriptException('Neither "resource" nor "path" were specified', 1386458763); } if (strpos($path, 'resource://') === 0) { $matches = array(); if (preg_match('#^resource://([^/]+)/Public/(.*)#', $path, $matches) !== 1) { throw new TypoScriptException(sprintf('The specified path "%s" does not point to a public resource.', $path), 1386458851); } $package = $matches[1]; $path = $matches[2]; } else { $package = $this->getPackage(); if ($package === null) { $controllerContext = $this->tsRuntime->getControllerContext(); /** @var $actionRequest ActionRequest */ $actionRequest = $controllerContext->getRequest(); $package = $actionRequest->getControllerPackageKey(); } } $localize = $this->isLocalize(); if ($localize === true) { $resourcePath = 'resource://' . $package . '/Public/' . $path; $localizedResourcePathData = $this->i18nService->getLocalizedFilename($resourcePath); $matches = array(); if (preg_match('#resource://([^/]+)/Public/(.*)#', current($localizedResourcePathData), $matches) === 1) { $package = $matches[1]; $path = $matches[2]; } } return $this->resourceManager->getPublicPackageResourceUri($package, $path); }
/** * Replace resource on an asset. Takes variants and redirect handling into account. * * @param AssetInterface $asset * @param PersistentResource $resource * @param array $options * @return void */ public function replaceAssetResource(AssetInterface $asset, PersistentResource $resource, array $options = []) { $originalAssetResource = $asset->getResource(); $asset->setResource($resource); if (isset($options['keepOriginalFilename']) && (bool) $options['keepOriginalFilename'] === true) { $asset->getResource()->setFilename($originalAssetResource->getFilename()); } $uriMapping = []; $redirectHandlerEnabled = isset($options['generateRedirects']) && (bool) $options['generateRedirects'] === true && $this->packageManager->isPackageAvailable('Neos.RedirectHandler'); if ($redirectHandlerEnabled) { $uriMapping[$this->resourceManager->getPublicPersistentResourceUri($originalAssetResource)] = $this->resourceManager->getPublicPersistentResourceUri($asset->getResource()); } if (method_exists($asset, 'getVariants')) { $variants = $asset->getVariants(); /** @var AssetVariantInterface $variant */ foreach ($variants as $variant) { $originalVariantResource = $variant->getResource(); $variant->refresh(); if (method_exists($variant, 'getAdjustments')) { foreach ($variant->getAdjustments() as $adjustment) { if (method_exists($adjustment, 'refit')) { $adjustment->refit($asset); } } } if ($redirectHandlerEnabled) { $uriMapping[$this->resourceManager->getPublicPersistentResourceUri($originalVariantResource)] = $this->resourceManager->getPublicPersistentResourceUri($variant->getResource()); } $this->getRepository($variant)->update($variant); } } if ($redirectHandlerEnabled) { /** @var \Neos\RedirectHandler\Storage\RedirectStorageInterface $redirectStorage */ $redirectStorage = $this->objectManager->get(\Neos\RedirectHandler\Storage\RedirectStorageInterface::class); foreach ($uriMapping as $originalUri => $newUri) { $existingRedirect = $redirectStorage->getOneBySourceUriPathAndHost($originalUri); if ($existingRedirect === null) { $redirectStorage->addRedirect($originalUri, $newUri, 301); } } } $this->getRepository($asset)->update($asset); $this->emitAssetResourceReplaced($asset); }
/** * Resolve help message thumbnail url * * @param string $nodeTypeName * @param string $configurationThumbnail * @return string $thumbnailUrl */ protected function resolveHelpMessageThumbnail($nodeTypeName, $configurationThumbnail) { if ($nodeTypeName !== null) { $thumbnailUrl = ''; if (isset($configurationThumbnail)) { $thumbnailUrl = $configurationThumbnail; if (strpos($thumbnailUrl, 'resource://') === 0) { $thumbnailUrl = $this->resourceManager->getPublicPackageResourceUriByPath($thumbnailUrl); } } else { # look in well know location $splitPrefix = $this->splitIdentifier($nodeTypeName); $relativePathAndFilename = 'NodeTypes/Thumbnails/' . $splitPrefix['id'] . '.png'; $resourcePath = 'resource://' . $splitPrefix['packageKey'] . '/Public/' . $relativePathAndFilename; if (file_exists($resourcePath)) { $thumbnailUrl = $this->resourceManager->getPublicPackageResourceUriByPath($resourcePath); } } return $thumbnailUrl; } }
/** * Evaluates the absolute path and filename of the resource file specified * by the given path. * * @param string $requestedPath * @param boolean $checkForExistence Whether a (non-hash) path should be checked for existence before being returned * @return mixed The full path and filename or FALSE if the file doesn't exist * @throws \InvalidArgumentException|ResourceException */ protected function evaluateResourcePath($requestedPath, $checkForExistence = true) { if (substr($requestedPath, 0, strlen(self::SCHEME)) !== self::SCHEME) { throw new \InvalidArgumentException('The ' . __CLASS__ . ' only supports the \'' . self::SCHEME . '\' scheme.', 1256052544); } $uriParts = Functions::parse_url($requestedPath); if (!is_array($uriParts) || !isset($uriParts['host'])) { return false; } if (preg_match('/^[0-9a-f]{40}$/i', $uriParts['host']) === 1) { $resource = $this->resourceManager->getResourceBySha1($uriParts['host']); return $this->resourceManager->getStreamByResource($resource); } if (!$this->packageManager->isPackageAvailable($uriParts['host'])) { throw new ResourceException(sprintf('Invalid resource URI "%s": Package "%s" is not available.', $requestedPath, $uriParts['host']), 1309269952); } $package = $this->packageManager->getPackage($uriParts['host']); $resourceUri = Files::concatenatePaths([$package->getResourcesPath(), $uriParts['path']]); if ($checkForExistence === false || file_exists($resourceUri)) { return $resourceUri; } return false; }
/** * Copy resources * * This command copies all resources from one collection to another storage identified by name. * The target storage must be empty and must not be identical to the current storage of the collection. * * This command merely copies the binary data from one storage to another, it does not change the related * PersistentResource objects in the database in any way. Since the PersistentResource objects in the database refer to a * collection name, you can use this command for migrating from one storage to another my configuring * the new storage with the name of the old storage collection after the resources have been copied. * * @param string $sourceCollection The name of the collection you want to copy the assets from * @param string $targetCollection The name of the collection you want to copy the assets to * @param boolean $publish If enabled, the target collection will be published after the resources have been copied * @return void */ public function copyCommand($sourceCollection, $targetCollection, $publish = false) { $sourceCollectionName = $sourceCollection; $sourceCollection = $this->resourceManager->getCollection($sourceCollectionName); if ($sourceCollection === null) { $this->outputLine('The source collection "%s" does not exist.', array($sourceCollectionName)); $this->quit(1); } $targetCollectionName = $targetCollection; $targetCollection = $this->resourceManager->getCollection($targetCollection); if ($targetCollection === null) { $this->outputLine('The target collection "%s" does not exist.', array($targetCollectionName)); $this->quit(1); } if (!empty($targetCollection->getObjects())) { $this->outputLine('The target collection "%s" is not empty.', array($targetCollectionName)); $this->quit(1); } $sourceObjects = $sourceCollection->getObjects(); $this->outputLine('Copying resource objects from collection "%s" to collection "%s" ...', [$sourceCollectionName, $targetCollectionName]); $this->outputLine(); $this->output->progressStart(count($sourceObjects)); foreach ($sourceCollection->getObjects() as $resource) { /** @var \Neos\Flow\ResourceManagement\Storage\StorageObject $resource */ $this->output->progressAdvance(); $targetCollection->importResource($resource->getStream()); } $this->output->progressFinish(); $this->outputLine(); if ($publish) { $this->outputLine('Publishing copied resources to the target "%s" ...', [$targetCollection->getTarget()->getName()]); $targetCollection->getTarget()->publishCollection($sourceCollection); } $this->outputLine('Done.'); $this->outputLine('Hint: If you want to use the target collection as a replacement for your current one, you can now modify your settings accordingly.'); }
/** * Convert an object from $source to an \Neos\Media\Domain\Model\AssetInterface implementation * * @param mixed $source * @param string $targetType must implement 'Neos\Media\Domain\Model\AssetInterface' * @param array $convertedChildProperties * @param PropertyMappingConfigurationInterface $configuration * @return Error|AssetInterface The converted Asset, a Validation Error or NULL * @throws InvalidTargetException */ public function convertFrom($source, $targetType, array $convertedChildProperties = array(), PropertyMappingConfigurationInterface $configuration = null) { $object = null; if (is_string($source) && $source !== '') { $source = array('__identity' => $source); } if (isset($convertedChildProperties['resource']) && $convertedChildProperties['resource'] instanceof PersistentResource) { $resource = $convertedChildProperties['resource']; if (isset($this->resourcesAlreadyConvertedToAssets[$resource->getSha1()])) { $object = $this->resourcesAlreadyConvertedToAssets[$resource->getSha1()]; } // This is pretty late to override the targetType, but usually you want to determine the model type from the resource when a new resource was uploaded... $targetType = $this->applyModelMappingStrategy($targetType, $resource, $source); } if ($object === null) { if ($configuration !== null && $configuration->getConfigurationValue(self::class, self::CONFIGURATION_ONE_PER_RESOURCE) === true && isset($convertedChildProperties['resource'])) { $resource = $convertedChildProperties['resource']; $possibleAsset = $this->assetRepository->findOneByResourceSha1($resource->getSha1()); if ($possibleAsset !== null) { $this->resourceManager->deleteResource($resource); return $possibleAsset; } } $object = parent::convertFrom($source, $targetType, $convertedChildProperties, $configuration); } if ($object instanceof AssetInterface) { $object = $this->applyTypeSpecificHandling($object, $source, $convertedChildProperties, $configuration); if ($object !== null) { $this->resourcesAlreadyConvertedToAssets[$object->getResource()->getSha1()] = $object; if (isset($resource) && $resource !== $object->getResource()) { $this->resourceManager->deleteResource($resource); } } } return $object; }
/** * @test */ public function fileGetContentsReturnFixtureContentForResourceUri() { $resource = $this->resourceManager->importResourceFromContent('fixture', 'fixture.txt'); $this->assertEquals('fixture', file_get_contents('resource://' . $resource->getSha1())); }
/** * @param PersistentResource $originalResource * @param array $adjustments * @return array resource, width, height as keys * @throws ImageFileException * @throws InvalidConfigurationException * @throws Exception */ public function processImage(PersistentResource $originalResource, array $adjustments) { $additionalOptions = array(); $adjustmentsApplied = false; // TODO: Special handling for SVG should be refactored at a later point. if ($originalResource->getMediaType() === 'image/svg+xml') { $originalResourceStream = $originalResource->getStream(); $resource = $this->resourceManager->importResource($originalResourceStream, $originalResource->getCollectionName()); fclose($originalResourceStream); $resource->setFilename($originalResource->getFilename()); return ['width' => null, 'height' => null, 'resource' => $resource]; } $resourceUri = $originalResource->createTemporaryLocalCopy(); $resultingFileExtension = $originalResource->getFileExtension(); $transformedImageTemporaryPathAndFilename = $this->environment->getPathToTemporaryDirectory() . uniqid('ProcessedImage-') . '.' . $resultingFileExtension; if (!file_exists($resourceUri)) { throw new ImageFileException(sprintf('An error occurred while transforming an image: the resource data of the original image does not exist (%s, %s).', $originalResource->getSha1(), $resourceUri), 1374848224); } $imagineImage = $this->imagineService->open($resourceUri); $convertCMYKToRGB = $this->getOptionsMergedWithDefaults()['convertCMYKToRGB']; if ($convertCMYKToRGB && $imagineImage->palette() instanceof CMYK) { $imagineImage->usePalette(new RGB()); } if ($this->imagineService instanceof Imagine && $originalResource->getFileExtension() === 'gif' && $this->isAnimatedGif(file_get_contents($resourceUri)) === true) { $imagineImage->layers()->coalesce(); $layers = $imagineImage->layers(); $newLayers = array(); foreach ($layers as $index => $imagineFrame) { $imagineFrame = $this->applyAdjustments($imagineFrame, $adjustments, $adjustmentsApplied); $newLayers[] = $imagineFrame; } $imagineImage = array_shift($newLayers); $layers = $imagineImage->layers(); foreach ($newLayers as $imagineFrame) { $layers->add($imagineFrame); } $additionalOptions['animated'] = true; } else { $imagineImage = $this->applyAdjustments($imagineImage, $adjustments, $adjustmentsApplied); } if ($adjustmentsApplied === true) { $imagineImage->save($transformedImageTemporaryPathAndFilename, $this->getOptionsMergedWithDefaults($additionalOptions)); $imageSize = $imagineImage->getSize(); // TODO: In the future the collectionName of the new resource should be configurable. $resource = $this->resourceManager->importResource($transformedImageTemporaryPathAndFilename, $originalResource->getCollectionName()); if ($resource === false) { throw new ImageFileException('An error occurred while importing a generated image file as a resource.', 1413562208); } unlink($transformedImageTemporaryPathAndFilename); $pathInfo = UnicodeFunctions::pathinfo($originalResource->getFilename()); $resource->setFilename(sprintf('%s-%ux%u.%s', $pathInfo['filename'], $imageSize->getWidth(), $imageSize->getHeight(), $pathInfo['extension'])); } else { $originalResourceStream = $originalResource->getStream(); $resource = $this->resourceManager->importResource($originalResourceStream, $originalResource->getCollectionName()); fclose($originalResourceStream); $resource->setFilename($originalResource->getFilename()); $imageSize = $this->getImageSize($originalResource); $imageSize = new Box($imageSize['width'], $imageSize['height']); } $this->imageSizeCache->set($resource->getCacheEntryIdentifier(), array('width' => $imageSize->getWidth(), 'height' => $imageSize->getHeight())); $result = array('width' => $imageSize->getWidth(), 'height' => $imageSize->getHeight(), 'resource' => $resource); return $result; }
/** * Doctrine lifecycle event callback which is triggered on "preRemove" events. * This method triggers the deletion of data related to this resource. * * @return void * @ORM\PreRemove */ public function preRemove() { if ($this->lifecycleEventsActive && $this->deleted === false) { $this->resourceManager->deleteResource($this); } }
/** * Get the collection name this resource will be stored in. Default will be ResourceManager::DEFAULT_PERSISTENT_COLLECTION_NAME * The propertyMappingConfiguration CONFIGURATION_COLLECTION_NAME will directly override the default. Then if CONFIGURATION_ALLOW_COLLECTION_OVERRIDE is TRUE * and __collectionName is in the $source this will finally be the value. * * @param array $source * @param PropertyMappingConfigurationInterface $configuration * @return string * @throws InvalidPropertyMappingConfigurationException */ protected function getCollectionName($source, PropertyMappingConfigurationInterface $configuration = null) { if ($configuration === null) { return ResourceManager::DEFAULT_PERSISTENT_COLLECTION_NAME; } $collectionName = $configuration->getConfigurationValue(ResourceTypeConverter::class, self::CONFIGURATION_COLLECTION_NAME) ?: ResourceManager::DEFAULT_PERSISTENT_COLLECTION_NAME; if (isset($source['__collectionName']) && $source['__collectionName'] !== '') { $collectionName = $source['__collectionName']; } if ($this->resourceManager->getCollection($collectionName) === null) { throw new InvalidPropertyMappingConfigurationException(sprintf('The selected resource collection named "%s" does not exist, a resource could not be imported.', $collectionName), 1416687475); } return $collectionName; }
/** * Retrieve all Objects stored in this storage. * * @param callable $callback Function called after each iteration * @return \Generator<Object> */ public function getObjects(callable $callback = null) { foreach ($this->resourceManager->getCollectionsByStorage($this) as $collection) { (yield $this->getObjectsByCollection($collection, $callback)); } }
/** * Returns the base URI for static resources * * IMPORTANT: This method merely exists in order to simplify migration from earlier versions of Flow which still * provided this method. This method has never been part of the public API and will be removed in the future. * * Note that, depending on your Resource Collection setup, this method will not always return the correct base URI, * because as of now there can be multiple publishing targets for static resources and URIs of the respective * target might not work by simply concatenating a base URI with the relative file name. * * This method will work for the default Flow setup using only the local file system. * * Make sure to refactor your client code to use the new resource management API instead. There is no direct * replacement for this method in the new API, but if you are dealing with static resources, use the resource stream * wrapper instead (through URLs like "resource://Neos.Flow/Public/Error/Debugger.css") or use * ResourceManager->getPublicPackageResourceUri() if you know the package key and relative path. * * Don't use this method. Ne pas utiliser cette méthode. No utilice este método. Finger weg! * U bent gewaarschuwd! You have been warned! Mēs jūs brīdinām! Mir hams euch fei gsagd! ;-) * * @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 * @deprecated since Flow 3.0. You cannot retrieve a base path for static resources anymore, please use resource://* instead or call ResourceManager->getPublicPackageResourceUri() */ public function getStaticResourcesWebBaseUri() { $this->systemLogger->log('The deprecated method ResourcePublisher->getStaticResourcesWebBaseUri() has been called' . $this->getCallee() . '. You cannot retrieve a base path for static resources anymore, please use resource://* instead or call ResourceManager->getPublicPackageResourceUri().', LOG_WARNING); return preg_replace('/\\/Packages\\/$/', '/', $this->resourceManager->getCollection(ResourceManager::DEFAULT_STATIC_COLLECTION_NAME)->getTarget()->getPublicStaticResourceUri('')); }