/** * Shows a specific asset * * @param string $identifier Specifies the asset to look up * @return string */ public function showAction($identifier) { $asset = $this->assetRepository->findByIdentifier($identifier); if ($asset === null) { $this->throwStatus(404); } $this->view->assign('asset', $asset); }
/** * 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())))); }
/** * @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; }
/** * Removes unused ImageVariants after a Node property changes to a different ImageVariant. * This is triggered via the nodePropertyChanged event. * * Note: This method it triggered by the "nodePropertyChanged" signal, @see \Neos\ContentRepository\Domain\Model\Node::emitNodePropertyChanged() * * @param NodeInterface $node the affected node * @param string $propertyName name of the property that has been changed/added * @param mixed $oldValue the property value before it was changed or NULL if the property is new * @param mixed $value the new property value * @return void */ public function removeUnusedImageVariant(NodeInterface $node, $propertyName, $oldValue, $value) { if ($oldValue === $value || !$oldValue instanceof ImageVariant) { return; } $identifier = $this->persistenceManager->getIdentifierByObject($oldValue); $results = $this->nodeDataRepository->findNodesByRelatedEntities(array(ImageVariant::class => [$identifier])); // This case shouldn't happen as the query will usually find at least the node that triggered this call, still if there is no relation we can remove the ImageVariant. if ($results === []) { $this->assetRepository->remove($oldValue); return; } // If the result contains exactly the node that got a new ImageVariant assigned then we are safe to remove the asset here. if ($results === [$node->getNodeData()]) { $this->assetRepository->remove($oldValue); } }
/** * Generate a new image variant from given data. * * @param ImageVariant $asset * @return string */ public function createImageVariantAction(ImageVariant $asset) { if ($this->persistenceManager->isNewObject($asset)) { $this->assetRepository->add($asset); } $propertyMappingConfiguration = new PropertyMappingConfiguration(); // This will not be sent as "application/json" as we need the JSON string and not the single variables. return json_encode($this->entityToIdentityConverter->convertFrom($asset, 'array', [], $propertyMappingConfiguration)); }
/** * Fetch an object from persistence layer. * * @param mixed $identity * @param string $targetType * @return object * @throws TargetNotFoundException * @throws InvalidSourceException */ protected function fetchObjectFromPersistence($identity, $targetType) { if ($targetType === Thumbnail::class) { $object = $this->persistenceManager->getObjectByIdentifier($identity, $targetType); } elseif (is_string($identity)) { $object = $this->assetRepository->findByIdentifier($identity); } else { throw new InvalidSourceException('The identity property "' . $identity . '" is not a string.', 1415817618); } return $object; }
/** * @param Tag $tag * @return void */ public function deleteTagAction(Tag $tag) { $taggedAssets = $this->assetRepository->findByTag($tag); foreach ($taggedAssets as $asset) { $asset->removeTag($tag); $this->assetRepository->update($asset); } $this->tagRepository->remove($tag); $this->addFlashMessage('tagHasBeenDeleted', '', Message::SEVERITY_OK, [htmlspecialchars($tag->getLabel())]); $this->redirect('index'); }
/** * Return the object the URI addresses or NULL. * * @param string|Uri $uri * @param NodeInterface $contextNode * @return NodeInterface|AssetInterface|NULL */ public function convertUriToObject($uri, NodeInterface $contextNode = null) { if ($uri instanceof Uri) { $uri = (string) $uri; } if (preg_match(self::PATTERN_SUPPORTED_URIS, $uri, $matches) === 1) { switch ($matches[1]) { case 'node': if ($contextNode === null) { throw new \RuntimeException('node:// URI conversion requires a context node to be passed', 1409734235); } return $contextNode->getContext()->getNodeByIdentifier($matches[2]); case 'asset': return $this->assetRepository->findByIdentifier($matches[2]); } } return null; }
/** * Create thumbnails * * Creates thumbnail images based on the configured thumbnail presets. Optional ``preset`` parameter to only create * thumbnails for a specific thumbnail preset configuration. * * Additionally accepts a ``async`` parameter determining if the created thumbnails are generated when created. * * @param string $preset Preset name, if not provided thumbnails are created for all presets * @param boolean $async Asynchronous generation, if not provided the setting ``Neos.Media.asyncThumbnails`` is used * @return void */ public function createThumbnailsCommand($preset = null, $async = null) { $async = $async !== null ? $async : $this->asyncThumbnails; $presets = $preset !== null ? [$preset] : array_keys($this->thumbnailService->getPresets()); $presetThumbnailConfigurations = []; foreach ($presets as $preset) { $presetThumbnailConfigurations[] = $this->thumbnailService->getThumbnailConfigurationForPreset($preset, $async); } $iterator = $this->assetRepository->findAllIterator(); $imageCount = $this->assetRepository->countAll(); $this->output->progressStart($imageCount * count($presetThumbnailConfigurations)); foreach ($this->assetRepository->iterate($iterator) as $image) { foreach ($presetThumbnailConfigurations as $presetThumbnailConfiguration) { $this->thumbnailService->getThumbnail($image, $presetThumbnailConfiguration); $this->persistenceManager->persistAll(); $this->output->progressAdvance(1); } } }
/** * @test */ public function findBySearchTermAndTagsReturnsFilteredResult() { $tag = new Tag('home'); $this->tagRepository->add($tag); $resource1 = $this->resourceManager->importResource(__DIR__ . '/../../Fixtures/Resources/license.txt'); $resource2 = $this->resourceManager->importResource(__DIR__ . '/../../Fixtures/Resources/417px-Mihaly_Csikszentmihalyi.jpg'); $asset1 = new Asset($resource1); $asset1->setTitle('asset for homepage'); $asset2 = new Asset($resource2); $asset2->setTitle('just another asset'); $asset2->addTag($tag); $this->assetRepository->add($asset1); $this->assetRepository->add($asset2); $this->persistenceManager->persistAll(); $this->persistenceManager->clearState(); $this->assertCount(2, $this->assetRepository->findBySearchTermOrTags('home', array($tag))); $this->assertCount(2, $this->assetRepository->findBySearchTermOrTags('homepage', array($tag))); $this->assertCount(1, $this->assetRepository->findBySearchTermOrTags('baz', array($tag))); // This is necessary to initialize all resource instances before the tables are deleted foreach ($this->assetRepository->findAll() as $asset) { $asset->getResource()->getSha1(); } }
/** * Change the property on the given node. * * @param NodeData $node * @return void */ public function execute(NodeData $node) { foreach ($node->getNodeType()->getProperties() as $propertyName => $propertyConfiguration) { if (isset($propertyConfiguration['type']) && ($propertyConfiguration['type'] === ImageInterface::class || preg_match('/array\\<.*\\>/', $propertyConfiguration['type']))) { if (!isset($nodeProperties)) { $nodeRecordQuery = $this->entityManager->getConnection()->prepare('SELECT properties FROM typo3_typo3cr_domain_model_nodedata WHERE persistence_object_identifier=?'); $nodeRecordQuery->execute([$this->persistenceManager->getIdentifierByObject($node)]); $nodeRecord = $nodeRecordQuery->fetch(\PDO::FETCH_ASSOC); $nodeProperties = unserialize($nodeRecord['properties']); } if (!isset($nodeProperties[$propertyName]) || empty($nodeProperties[$propertyName])) { continue; } if ($propertyConfiguration['type'] === ImageInterface::class) { $adjustments = array(); $oldVariantConfiguration = $nodeProperties[$propertyName]; if (is_array($oldVariantConfiguration)) { foreach ($oldVariantConfiguration as $variantPropertyName => $property) { switch (substr($variantPropertyName, 3)) { case 'originalImage': /** * @var $originalAsset Image */ $originalAsset = $this->assetRepository->findByIdentifier($this->persistenceManager->getIdentifierByObject($property)); break; case 'processingInstructions': $adjustments = $this->processingInstructionsConverter->convertFrom($property, 'array'); break; } } $nodeProperties[$propertyName] = null; if (isset($originalAsset)) { $stream = $originalAsset->getResource()->getStream(); if ($stream === false) { continue; } fclose($stream); $newImageVariant = new ImageVariant($originalAsset); foreach ($adjustments as $adjustment) { $newImageVariant->addAdjustment($adjustment); } $originalAsset->addVariant($newImageVariant); $this->assetRepository->update($originalAsset); $nodeProperties[$propertyName] = $this->persistenceManager->getIdentifierByObject($newImageVariant); } } } elseif (preg_match('/array\\<.*\\>/', $propertyConfiguration['type'])) { if (is_array($nodeProperties[$propertyName])) { $convertedValue = []; foreach ($nodeProperties[$propertyName] as $entryValue) { if (!is_object($entryValue)) { continue; } $stream = $entryValue->getResource()->getStream(); if ($stream === false) { continue; } fclose($stream); $existingObjectIdentifier = null; try { $existingObjectIdentifier = $this->persistenceManager->getIdentifierByObject($entryValue); if ($existingObjectIdentifier !== null) { $convertedValue[] = $existingObjectIdentifier; } } catch (\Exception $exception) { } } $nodeProperties[$propertyName] = $convertedValue; } } } } if (isset($nodeProperties)) { $nodeUpdateQuery = $this->entityManager->getConnection()->prepare('UPDATE typo3_typo3cr_domain_model_nodedata SET properties=? WHERE persistence_object_identifier=?'); $nodeUpdateQuery->execute([serialize($nodeProperties), $this->persistenceManager->getIdentifierByObject($node)]); } }