/**
* Provides an XML comment containing the exception
*
* @param string $typoScriptPath path causing the exception
* @param \Exception $exception exception to handle
* @param integer $referenceCode
* @return string
*/
protected function handle($typoScriptPath, \Exception $exception, $referenceCode)
{
$this->systemLogger->logException($exception);
if (isset($referenceCode)) {
return sprintf('<!-- Exception while rendering %s: %s (%s) -->', $this->formatScriptPath($typoScriptPath, ''), htmlspecialchars($exception->getMessage()), $referenceCode);
} else {
return sprintf('<!-- Exception while rendering %s: %s -->', $this->formatScriptPath($typoScriptPath, ''), htmlspecialchars($exception->getMessage()));
}
}
/**
* Create a new site from a site template
*
* This command uses a site template located in a sitePackage to create a new site with a new subdomain.
*
* @param string $sitePackage Package key of the Site containing the template under Templates/Content/Sites.xml
* @param string $siteName The sitename
* @param string $baseDomain The base domain name e.g. site.com => will be used like $siteName.site.com
* @return void
*/
public function newSiteCommand($sitePackage, $siteName, $baseDomain)
{
try {
$site = $this->siteService->importSiteFromTemplate($sitePackage, $siteName, $baseDomain);
$this->outputLine('Created a new site "%s"', array($site->getName()));
} catch (\Exception $e) {
$this->systemLogger->logException($e);
$this->outputLine('An error occured during site creation, check error log for details');
}
}
/**
* Renders the exception in HTML for display
*
* @param string $typoScriptPath path causing the exception
* @param \Exception $exception exception to handle
* @param integer $referenceCode
* @return string
*/
protected function handle($typoScriptPath, \Exception $exception, $referenceCode)
{
$messageArray = array('header' => 'An exception was thrown while Neos tried to render your page', 'content' => $exception->getMessage(), 'stacktrace' => $this->formatTypoScriptPath($typoScriptPath), 'referenceCode' => $this->formatErrorCodeMessage($referenceCode));
$messageBody = sprintf('<p class="neos-message-content">%s</p>' . '<p class="neos-message-stacktrace"><code>%s</code></p>', $messageArray['content'], $messageArray['stacktrace']);
if ($referenceCode) {
$messageBody = sprintf('%s<p class="neos-reference-code">%s</p>', $messageBody, $messageArray['referenceCode']);
}
$message = sprintf('<div class="neos-message-header"><div class="neos-message-icon"><i class="icon-warning-sign"></i></div><h1>%s</h1></div>' . '<div class="neos-message-wrapper">%s</div>', $messageArray['header'], $messageBody);
$this->systemLogger->logException($exception);
return $message;
}
/**
* Handles the given exception
*
* @param object $exception The exception object - can be \Exception, or some type of \Throwable in PHP 7
* @return void
*/
public function handleException($exception)
{
// Ignore if the error is suppressed by using the shut-up operator @
if (error_reporting() === 0) {
return;
}
$this->renderingOptions = $this->resolveCustomRenderingOptions($exception);
if (is_object($this->systemLogger) && isset($this->renderingOptions['logException']) && $this->renderingOptions['logException']) {
if ($exception instanceof \Throwable) {
if ($this->systemLogger instanceof ThrowableLoggerInterface) {
$this->systemLogger->logThrowable($exception);
} else {
// Convert \Throwable to \Exception for non-supporting logger implementations
$this->systemLogger->logException(new \Exception($exception->getMessage(), $exception->getCode()));
}
} elseif ($exception instanceof \Exception) {
$this->systemLogger->logException($exception);
}
}
switch (PHP_SAPI) {
case 'cli':
$this->echoExceptionCli($exception);
break;
default:
$this->echoExceptionWeb($exception);
}
}
/**
* Commits new objects and changes to objects in the current persistence
* session into the backend
*
* @param boolean $onlyWhitelistedObjects If TRUE an exception will be thrown if there are scheduled updates/deletes or insertions for objects that are not "whitelisted" (see AbstractPersistenceManager::whitelistObject())
* @return void
* @api
*/
public function persistAll($onlyWhitelistedObjects = false)
{
if ($onlyWhitelistedObjects) {
$unitOfWork = $this->entityManager->getUnitOfWork();
/** @var \Doctrine\ORM\UnitOfWork $unitOfWork */
$unitOfWork->computeChangeSets();
$objectsToBePersisted = $unitOfWork->getScheduledEntityUpdates() + $unitOfWork->getScheduledEntityDeletions() + $unitOfWork->getScheduledEntityInsertions();
foreach ($objectsToBePersisted as $object) {
$this->throwExceptionIfObjectIsNotWhitelisted($object);
}
}
if (!$this->entityManager->isOpen()) {
$this->systemLogger->log('persistAll() skipped flushing data, the Doctrine EntityManager is closed. Check the logs for error message.', LOG_ERR);
return;
}
try {
$this->entityManager->flush();
} catch (Exception $exception) {
$this->systemLogger->logException($exception);
/** @var Connection $connection */
$connection = $this->entityManager->getConnection();
$connection->close();
$connection->connect();
$this->systemLogger->log('Reconnected the Doctrine EntityManager to the persistence backend.', LOG_INFO);
$this->entityManager->flush();
} finally {
$this->emitAllObjectsPersisted();
}
}
/**
* Send a new notification that a comment has been created
*
* @param \TYPO3\TYPO3CR\Domain\Model\NodeInterface $commentNode The comment node
* @param \TYPO3\TYPO3CR\Domain\Model\NodeInterface $postNode The post node
* @return void
*/
public function sendNewCommentNotification(NodeInterface $commentNode, NodeInterface $postNode)
{
if ($this->settings['notifications']['to']['email'] === '') {
return;
}
if (!class_exists('TYPO3\\SwiftMailer\\Message')) {
$this->systemLogger->logException(new \TYPO3\Flow\Exception('The package "TYPO3.SwiftMailer" is required to send notifications!', 1359473932));
return;
}
try {
$mail = new Message();
$mail->setFrom(array($commentNode->getProperty('emailAddress') => $commentNode->getProperty('author')))->setTo(array($this->settings['notifications']['to']['email'] => $this->settings['notifications']['to']['name']))->setSubject('New comment on blog post "' . $postNode->getProperty('title') . '"' . ($commentNode->getProperty('spam') ? ' (SPAM)' : ''))->setBody($commentNode->getProperty('text'))->send();
} catch (\Exception $e) {
$this->systemLogger->logException($e);
}
}
/**
* @param \TYPO3\Form\Core\Model\FinisherContext $finisherContext
* @return void
* @throws \TYPO3\Setup\Exception
*/
public function importSite(\TYPO3\Form\Core\Model\FinisherContext $finisherContext)
{
$formValues = $finisherContext->getFormRuntime()->getFormState()->getFormValues();
if (isset($formValues['prune']) && intval($formValues['prune']) === 1) {
$this->nodeDataRepository->removeAll();
$this->workspaceRepository->removeAll();
$this->domainRepository->removeAll();
$this->siteRepository->removeAll();
$this->persistenceManager->persistAll();
}
if (!empty($formValues['packageKey'])) {
if ($this->packageManager->isPackageAvailable($formValues['packageKey'])) {
throw new \TYPO3\Setup\Exception(sprintf('The package key "%s" already exists.', $formValues['packageKey']), 1346759486);
}
$packageKey = $formValues['packageKey'];
$siteName = $formValues['siteName'];
$generatorService = $this->objectManager->get('TYPO3\\Neos\\Kickstarter\\Service\\GeneratorService');
$generatorService->generateSitePackage($packageKey, $siteName);
} elseif (!empty($formValues['site'])) {
$packageKey = $formValues['site'];
}
$this->deactivateOtherSitePackages($packageKey);
$this->packageManager->activatePackage($packageKey);
if (!empty($packageKey)) {
try {
$contentContext = $this->contextFactory->create(array('workspaceName' => 'live'));
$this->siteImportService->importFromPackage($packageKey, $contentContext);
} catch (\Exception $exception) {
$finisherContext->cancel();
$this->systemLogger->logException($exception);
throw new SetupException(sprintf('Error: During the import of the "Sites.xml" from the package "%s" an exception occurred: %s', $packageKey, $exception->getMessage()), 1351000864);
}
}
}
/**
* Import sites content
*
* This command allows for importing one or more sites or partial content from an XML source. The format must
* be identical to that produced by the export command.
*
* If a filename is specified, this command expects the corresponding file to contain the XML structure. The
* filename php://stdin can be used to read from standard input.
*
* If a package key is specified, this command expects a Sites.xml file to be located in the private resources
* directory of the given package (Resources/Private/Content/Sites.xml).
*
* @param string $packageKey Package key specifying the package containing the sites content
* @param string $filename relative path and filename to the XML file containing the sites content
* @return void
*/
public function importCommand($packageKey = null, $filename = null)
{
$exceedingArguments = $this->request->getExceedingArguments();
if (isset($exceedingArguments[0]) && $packageKey === null && $filename === null) {
if (file_exists($exceedingArguments[0])) {
$filename = $exceedingArguments[0];
} elseif ($this->packageManager->isPackageAvailable($exceedingArguments[0])) {
$packageKey = $exceedingArguments[0];
}
}
if ($packageKey === null && $filename === null) {
$this->outputLine('You have to specify either "--package-key" or "--filename"');
$this->quit(1);
}
$site = null;
if ($filename !== null) {
try {
$site = $this->siteImportService->importFromFile($filename);
} catch (\Exception $exception) {
$this->systemLogger->logException($exception);
$this->outputLine('Error: During the import of the file "%s" an exception occurred: %s, see log for further information.', array($filename, $exception->getMessage()));
$this->quit(1);
}
} else {
try {
$site = $this->siteImportService->importFromPackage($packageKey);
} catch (\Exception $exception) {
$this->systemLogger->logException($exception);
$this->outputLine('Error: During the import of the "Sites.xml" from the package "%s" an exception occurred: %s, see log for further information.', array($packageKey, $exception->getMessage()));
$this->quit(1);
}
}
$this->outputLine('Import of site "%s" finished.', array($site->getName()));
}
/**
* Create a new site.
*
* @param string $site Site to import
* @param string $packageKey Package Name to create
* @param string $siteName Site Name to create
* @Flow\Validate(argumentName="$packageKey", type="\TYPO3\Neos\Validation\Validator\PackageKeyValidator")
* @return void
*/
public function createSiteAction($site, $packageKey = '', $siteName = '')
{
if ($packageKey !== '' && $this->packageManager->isPackageActive('TYPO3.Neos.Kickstarter')) {
if ($this->packageManager->isPackageAvailable($packageKey)) {
$this->addFlashMessage('The package key "%s" already exists.', 'Invalid package key', Message::SEVERITY_ERROR, array(htmlspecialchars($packageKey)), 1412372021);
$this->redirect('index');
}
$generatorService = $this->objectManager->get('TYPO3\\Neos\\Kickstarter\\Service\\GeneratorService');
$generatorService->generateSitePackage($packageKey, $siteName);
} else {
$packageKey = $site;
}
$deactivatedSitePackages = $this->deactivateAllOtherSitePackages($packageKey);
if (count($deactivatedSitePackages) > 0) {
$this->flashMessageContainer->addMessage(new Message(sprintf('The existing Site Packages "%s" were deactivated, in order to prevent interactions with the newly created package "%s".', htmlspecialchars(implode(', ', $deactivatedSitePackages)), htmlspecialchars($packageKey))));
}
$this->packageManager->activatePackage($packageKey);
if ($packageKey !== '') {
try {
$this->siteImportService->importFromPackage($packageKey);
$this->addFlashMessage('The site has been created.', '', null, array(), 1412372266);
} catch (\Exception $exception) {
$this->systemLogger->logException($exception);
$this->addFlashMessage('Error: During the import of the "Sites.xml" from the package "%s" an exception occurred: %s', 'Import error', Message::SEVERITY_ERROR, array(htmlspecialchars($packageKey), htmlspecialchars($exception->getMessage())), 1412372375);
}
} else {
$this->addFlashMessage('No site selected for import and no package name provided.', 'No site selected', Message::SEVERITY_ERROR, array(), 1412372554);
$this->redirect('newSite');
}
$this->unsetLastVisitedNodeAndRedirect('index');
}
/**
* Returns the query result count
*
* @return integer The query result count
* @throws Exception\DatabaseConnectionException
* @api
*/
public function count()
{
try {
$originalQuery = $this->queryBuilder->getQuery();
$dqlQuery = clone $originalQuery;
$dqlQuery->setParameters($originalQuery->getParameters());
$dqlQuery->setHint(\Doctrine\ORM\Query::HINT_CUSTOM_TREE_WALKERS, array('TYPO3\\Flow\\Persistence\\Doctrine\\CountWalker'));
$offset = $dqlQuery->getFirstResult();
$limit = $dqlQuery->getMaxResults();
if ($offset !== NULL) {
$dqlQuery->setFirstResult(NULL);
}
$numberOfResults = (int) $dqlQuery->getSingleScalarResult();
if ($offset !== NULL) {
$numberOfResults = max(0, $numberOfResults - $offset);
}
if ($limit !== NULL) {
$numberOfResults = min($numberOfResults, $limit);
}
return $numberOfResults;
} catch (\Doctrine\ORM\ORMException $ormException) {
$this->systemLogger->logException($ormException);
return 0;
} catch (\PDOException $pdoException) {
throw new Exception\DatabaseConnectionException($pdoException->getMessage(), $pdoException->getCode());
}
}
/**
* Handles the given exception
*
* @param \Exception $exception The exception object
* @return void
*/
public function handleException(\Exception $exception)
{
// Ignore if the error is suppressed by using the shut-up operator @
if (error_reporting() === 0) {
return;
}
if (is_object($this->systemLogger)) {
$this->systemLogger->logException($exception);
}
switch (PHP_SAPI) {
case 'cli':
$this->echoExceptionCli($exception);
break;
default:
$this->echoExceptionWeb($exception);
}
}
/**
* Output an error message and log the exception.
*
* @param \Exception $exception
* @return void
*/
protected function handleException(\Exception $exception)
{
$this->outputLine('<error>%s</error>', [$exception->getMessage()]);
$this->outputLine();
$this->outputLine('The exception details have been logged to the Flow system log.');
$this->systemLogger->logException($exception);
$this->quit(1);
}
/**
* Sends a mail and creates a system logger entry if sending failed
*
* @param Message $mail
* @return boolean TRUE on success, otherwise FALSE
*/
protected function sendMail(Message $mail)
{
$numberOfRecipients = 0;
// ignore exceptions but log them
$exceptionMessage = '';
try {
$numberOfRecipients = $mail->send();
} catch (\Exception $e) {
$this->systemLogger->logException($e);
$exceptionMessage = $e->getMessage();
}
if ($numberOfRecipients < 1) {
$this->systemLogger->log('Could not send notification email "' . $mail->getSubject() . '"', LOG_ERR, ['exception' => $exceptionMessage, 'message' => $mail->getSubject(), 'id' => (string) $mail->getHeaders()->get('Message-ID')]);
return false;
}
return true;
}
/**
* Return an array with data from the given exception, suitable for being returned
* in an ExtDirect response.
*
* The excpetion is logged to the system logger as well.
*
* @param \Exception $exception
* @return array
*/
protected function handleException(\Exception $exception, $transactionId = NULL)
{
$this->systemLogger->logException($exception);
// As an exception happened, we now need to check whether detailed exception reporting was enabled.
$exposeExceptionInformation = $this->settings['ExtDirect']['exposeExceptionInformation'] === TRUE;
$exceptionWhere = $exception instanceof \TYPO3\Flow\Exception ? ' (ref ' . $exception->getReferenceCode() . ')' : '';
$exceptionMessage = $exposeExceptionInformation ? 'Uncaught exception #' . $exception->getCode() . $exceptionWhere . ' - ' . $exception->getMessage() : 'An internal error occured';
return array('type' => 'exception', 'tid' => $transactionId, 'message' => $exceptionMessage, 'where' => $exceptionWhere);
}
/**
* Get a single property reduced to a simple type (no objects) representation
*
* @param NodeInterface $node
* @param string $propertyName
* @return mixed
*/
public function getProperty(NodeInterface $node, $propertyName)
{
if ($propertyName[0] === '_') {
$propertyValue = ObjectAccess::getProperty($node, ltrim($propertyName, '_'));
} else {
$propertyValue = $node->getProperty($propertyName);
}
$dataType = $node->getNodeType()->getPropertyType($propertyName);
try {
$convertedValue = $this->convertValue($propertyValue, $dataType);
} catch (PropertyException $exception) {
$this->systemLogger->logException($exception);
$convertedValue = null;
}
if ($convertedValue === null) {
$convertedValue = $this->getDefaultValueForProperty($node->getNodeType(), $propertyName);
}
return $convertedValue;
}
/**
* Handles the given exception
*
* @param object $exception The exception object - can be \Exception, or some type of \Throwable in PHP 7
* @return void
*/
public function handleException($exception)
{
// Ignore if the error is suppressed by using the shut-up operator @
if (error_reporting() === 0) {
return;
}
$this->renderingOptions = $this->resolveCustomRenderingOptions($exception);
if (is_object($this->systemLogger) && isset($this->renderingOptions['logException']) && $this->renderingOptions['logException']) {
if ($exception instanceof \Exception) {
$this->systemLogger->logException($exception);
}
}
switch (PHP_SAPI) {
case 'cli':
$this->echoExceptionCli($exception);
break;
default:
$this->echoExceptionWeb($exception);
}
}
/**
* Returns a thumbnail of the given asset
*
* If the maximum width / height is not specified or exceeds the original asset's dimensions, the width / height of
* the original asset is used.
*
* @param AssetInterface $asset The asset to render a thumbnail for
* @param ThumbnailConfiguration $configuration
* @return ImageInterface
* @throws \Exception
*/
public function getThumbnail(AssetInterface $asset, ThumbnailConfiguration $configuration)
{
// Calculates the dimensions of the thumbnail to be generated and returns the thumbnail image if the new
// dimensions differ from the specified image dimensions, otherwise the original image is returned.
if ($asset instanceof ImageInterface) {
if ($asset->getWidth() === null && $asset->getHeight() === null) {
return $asset;
}
$maximumWidth = $configuration->getMaximumWidth() > $asset->getWidth() ? $asset->getWidth() : $configuration->getMaximumWidth();
$maximumHeight = $configuration->getMaximumHeight() > $asset->getHeight() ? $asset->getHeight() : $configuration->getMaximumHeight();
if ($configuration->isUpScalingAllowed() === false && $maximumWidth === $asset->getWidth() && $maximumHeight === $asset->getHeight()) {
return $asset;
}
}
$assetIdentifier = $this->persistenceManager->getIdentifierByObject($asset);
$configurationHash = $configuration->getHash();
if (!isset($this->thumbnailCache[$assetIdentifier])) {
$this->thumbnailCache[$assetIdentifier] = [];
}
if (isset($this->thumbnailCache[$assetIdentifier][$configurationHash])) {
$thumbnail = $this->thumbnailCache[$assetIdentifier][$configurationHash];
} else {
$thumbnail = $this->thumbnailRepository->findOneByAssetAndThumbnailConfiguration($asset, $configuration);
$this->thumbnailCache[$assetIdentifier][$configurationHash] = $thumbnail;
}
$async = $configuration->isAsync();
if ($thumbnail === null) {
try {
$thumbnail = new Thumbnail($asset, $configuration, $async);
$this->emitThumbnailCreated($thumbnail);
// If the thumbnail strategy failed to generate a valid thumbnail
if ($async === false && $thumbnail->getResource() === null && $thumbnail->getStaticResource() === null) {
$this->thumbnailRepository->remove($thumbnail);
return null;
}
if (!$this->persistenceManager->isNewObject($asset)) {
$this->thumbnailRepository->add($thumbnail);
}
$asset->addThumbnail($thumbnail);
// Allow thumbnails to be persisted even if this is a "safe" HTTP request:
$this->persistenceManager->whiteListObject($thumbnail);
$this->thumbnailCache[$assetIdentifier][$configurationHash] = $thumbnail;
} catch (NoThumbnailAvailableException $exception) {
$this->systemLogger->logException($exception);
return null;
}
$this->persistenceManager->whiteListObject($thumbnail);
$this->thumbnailCache[$assetIdentifier][$configurationHash] = $thumbnail;
} elseif ($thumbnail->getResource() === null && $async === false) {
$this->refreshThumbnail($thumbnail);
}
return $thumbnail;
}
/**
* Writes out a single property into the XML structure.
*
* @param array $data The data as an array, the given property name is looked up there
* @param string $propertyName The name of the property
* @param string $elementName an optional name to use, defaults to $propertyName
* @return void
*/
protected function writeConvertedElement(array &$data, $propertyName, $elementName = null, $declaredPropertyType = null)
{
if (array_key_exists($propertyName, $data) && $data[$propertyName] !== null) {
$propertyValue = $data[$propertyName];
$this->xmlWriter->startElement($elementName ?: $propertyName);
if (!empty($propertyValue)) {
switch ($declaredPropertyType) {
case null:
case 'reference':
case 'references':
break;
default:
$propertyValue = $this->propertyMapper->convert($propertyValue, $declaredPropertyType);
break;
}
}
$this->xmlWriter->writeAttribute('__type', gettype($propertyValue));
try {
if (is_object($propertyValue) && !$propertyValue instanceof \DateTime) {
$objectIdentifier = $this->persistenceManager->getIdentifierByObject($propertyValue);
if ($objectIdentifier !== null) {
$this->xmlWriter->writeAttribute('__identifier', $objectIdentifier);
}
if ($propertyValue instanceof \Doctrine\ORM\Proxy\Proxy) {
$className = get_parent_class($propertyValue);
} else {
$className = get_class($propertyValue);
}
$this->xmlWriter->writeAttribute('__classname', $className);
$this->xmlWriter->writeAttribute('__encoding', 'json');
$converted = json_encode($this->propertyMapper->convert($propertyValue, 'array', $this->propertyMappingConfiguration));
$this->xmlWriter->text($converted);
} elseif (is_array($propertyValue)) {
foreach ($propertyValue as $key => $element) {
$this->writeConvertedElement($propertyValue, $key, 'entry' . $key);
}
} else {
if ($propertyValue instanceof \DateTime) {
$this->xmlWriter->writeAttribute('__classname', 'DateTime');
}
$this->xmlWriter->text($this->propertyMapper->convert($propertyValue, 'string', $this->propertyMappingConfiguration));
}
} catch (\Exception $exception) {
$this->xmlWriter->writeComment(sprintf('Could not convert property "%s" to string.', $propertyName));
$this->xmlWriter->writeComment($exception->getMessage());
$this->systemLogger->logException($exception);
$this->exceptionsDuringExport[] = $exception;
}
$this->xmlWriter->endElement();
}
}
/**
* @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 '';
}
/**
* Finally evaluate the TypoScript path
*
* As PHP does not like throwing an exception here, we render any exception using the configured TypoScript exception
* handler and will also catch and log any exceptions resulting from that as a last resort.
*
* @return string
*/
public function __toString()
{
try {
return (string) $this->objectAccess();
} catch (\Exception $exceptionHandlerException) {
try {
// Throwing an exception in __toString causes a fatal error, so if that happens we catch them and use the context dependent exception handler instead.
$contextDependentExceptionHandler = new ContextDependentHandler();
$contextDependentExceptionHandler->setRuntime($this->tsRuntime);
return $contextDependentExceptionHandler->handleRenderingException($this->path, $exception);
} catch (\Exception $contextDepndentExceptionHandlerException) {
$this->systemLogger->logException($contextDepndentExceptionHandlerException, array('path' => $this->path));
return sprintf('<!-- Exception while rendering exception in %s: %s (%s) -->', $this->path, $contextDepndentExceptionHandlerException->getMessage(), $contextDepndentExceptionHandlerException instanceof Exception ? 'see reference code ' . $contextDepndentExceptionHandlerException->getReferenceCode() . ' in log' : $contextDepndentExceptionHandlerException->getCode());
}
}
}
/**
* @param string $presetName
* @param string $partName
* @param string $dataProviderClassName
* @param string $importerClassName
* @param string $logPrefix
* @param integer $offset
* @param integer $batchSize
* @return integer
* @Flow\Internal
*/
public function executeBatchCommand($presetName, $partName, $dataProviderClassName, $importerClassName, $logPrefix, $offset = NULL, $batchSize = NULL)
{
try {
$dataProviderOptions = Arrays::getValueByPath($this->settings, implode('.', ['presets', $presetName, $partName, 'dataProviderOptions']));
/** @var DataProvider $dataProvider */
$dataProvider = $dataProviderClassName::create(is_array($dataProviderOptions) ? $dataProviderOptions : [], $offset, $batchSize);
$importerOptions = Arrays::getValueByPath($this->settings, ['presets', $presetName, $partName, 'importerOptions']);
/** @var Importer $importer */
$importer = $this->objectManager->get($importerClassName, is_array($importerOptions) ? $importerOptions : []);
$importer->setLogPrefix($logPrefix);
$importer->import($dataProvider);
$this->output($dataProvider->getCount());
} catch (\Exception $exception) {
$this->logger->logException($exception);
$this->quit(1);
}
}
/**
* Render the Uri.
*
* @return string The rendered URI or NULL if no URI could be resolved for the given node
* @throws NeosException
*/
public function evaluate()
{
$baseNode = null;
$baseNodeName = $this->getBaseNodeName() ?: 'documentNode';
$currentContext = $this->tsRuntime->getCurrentContext();
if (isset($currentContext[$baseNodeName])) {
$baseNode = $currentContext[$baseNodeName];
} else {
throw new NeosException(sprintf('Could not find a node instance in TypoScript context with name "%s" and no node instance was given to the node argument. Set a node instance in the TypoScript context or pass a node object to resolve the URI.', $baseNodeName), 1373100400);
}
try {
return $this->linkingService->createNodeUri($this->tsRuntime->getControllerContext(), $this->getNode(), $baseNode, $this->getFormat(), $this->isAbsolute(), $this->getAdditionalParams(), $this->getSection(), $this->getAddQueryString(), $this->getArgumentsToBeExcludedFromQueryString());
} catch (NeosException $exception) {
$this->systemLogger->logException($exception);
return '';
}
}
/**
* @param string $jobIdentifier
* @param array $options
*/
protected function executeJob($jobIdentifier, array $options = [])
{
$jobConfiguration = $this->jobConfigurationRepository->findOneByIdentifier($jobIdentifier);
try {
$startTime = microtime(true);
$options = new JobConfigurationOptions($options);
if ($this->jobRunnerService->execute($jobConfiguration, $options)) {
if ($jobConfiguration->isAsynchronous()) {
$this->flashMessageContainer->addMessage(new Message(sprintf('Job "%s" queued with success', $jobConfiguration->getName())));
} else {
$duration = round(microtime(true) - $startTime, 2);
$this->flashMessageContainer->addMessage(new Message(sprintf('Job "%s" exectued with success in %s sec.', $jobConfiguration->getName(), $duration)));
}
}
} catch (\Exception $exception) {
$this->systemLogger->logException($exception);
$this->flashMessageContainer->addMessage(new Error(sprintf('Failed to execute job "%s" with message: %s', $jobConfiguration->getName(), $exception->getMessage())));
}
}
/**
* Returns a thumbnail of the given asset
*
* If the maximum width / height is not specified or exceeds the original asset's dimensions, the width / height of
* the original asset is used.
*
* @param AssetInterface $asset The asset to render a thumbnail for
* @param ThumbnailConfiguration $configuration
* @return Thumbnail
* @throws \Exception
*/
public function getThumbnail(AssetInterface $asset, ThumbnailConfiguration $configuration)
{
$assetIdentifier = $this->persistenceManager->getIdentifierByObject($asset);
$configurationHash = $configuration->getHash();
if (!isset($this->thumbnailCache[$assetIdentifier])) {
$this->thumbnailCache[$assetIdentifier] = [];
}
if (isset($this->thumbnailCache[$assetIdentifier][$configurationHash])) {
$thumbnail = $this->thumbnailCache[$assetIdentifier][$configurationHash];
} else {
$thumbnail = $this->thumbnailRepository->findOneByAssetAndThumbnailConfiguration($asset, $configuration);
$this->thumbnailCache[$assetIdentifier][$configurationHash] = $thumbnail;
}
$async = $configuration->isAsync();
if ($thumbnail === null) {
try {
$thumbnail = new Thumbnail($asset, $configuration, $async);
// If the thumbnail strategy failed to generate a valid thumbnail
if ($async === false && $thumbnail->getResource() === null && $thumbnail->getStaticResource() === null) {
$this->thumbnailRepository->remove($thumbnail);
return null;
}
if (!$this->persistenceManager->isNewObject($asset)) {
$this->thumbnailRepository->add($thumbnail);
}
$asset->addThumbnail($thumbnail);
// Allow thumbnails to be persisted even if this is a "safe" HTTP request:
$this->persistenceManager->whiteListObject($thumbnail);
$this->thumbnailCache[$assetIdentifier][$configurationHash] = $thumbnail;
} catch (NoThumbnailAvailableException $exception) {
$this->systemLogger->logException($exception);
return null;
}
$this->persistenceManager->whiteListObject($thumbnail);
$this->thumbnailCache[$assetIdentifier][$configurationHash] = $thumbnail;
} elseif ($thumbnail->getResource() === null && $async === false) {
$this->refreshThumbnail($thumbnail);
}
return $thumbnail;
}
/**
* Extract metadata from the content and store it
*
* @param string $entryIdentifier The entry identifier
* @param string $content The raw content including serialized metadata
* @return string The content without metadata
* @throws InvalidDataException
*/
protected function extractMetadata($entryIdentifier, $content)
{
$separatorIndex = strpos($content, self::SEPARATOR);
if ($separatorIndex === FALSE) {
$exception = new InvalidDataException('Could not find cache metadata in entry with identifier ' . $entryIdentifier, 1433155925);
if ($this->environment->getContext()->isProduction()) {
$this->systemLogger->logException($exception);
} else {
throw $exception;
}
}
$metadataJson = substr($content, 0, $separatorIndex);
$metadata = json_decode($metadataJson, TRUE);
if ($metadata === NULL) {
$exception = new InvalidDataException('Invalid cache metadata in entry with identifier ' . $entryIdentifier, 1433155926);
if ($this->environment->getContext()->isProduction()) {
$this->systemLogger->logException($exception);
} else {
throw $exception;
}
}
$this->metadata[$entryIdentifier] = $metadata;
return substr($content, $separatorIndex + 1);
}
/**
* @param string $firstname
* @param string $lastname
* @param string $email
* @param string $username
* @param string $password
* @return \TYPO3\Flow\Error\Result
*/
public function addUser($firstname, $lastname, $email, $username, $password)
{
$result = new \TYPO3\Flow\Error\Result();
try {
$userData = ['name' => $username, 'first-name' => $firstname, 'last-name' => $lastname, 'email' => $email, 'password' => ['value' => $password], 'active' => TRUE];
$uri = rtrim($this->crowdBaseUri, '/') . '/rest/usermanagement/1/user';
$response = $this->httpClient->post($uri, array('body' => json_encode($userData)));
$responseData = json_decode($response->getBody()->getContents(), TRUE);
// TODO Check response data?
} catch (ClientException $e) {
$responseError = json_decode($e->getResponse()->getBody()->getContents());
if (isset($responseError->reason)) {
switch ($responseError->reason) {
case 'INVALID_USER':
$result->addError(new \TYPO3\Flow\Error\Error($responseError->message));
return $result;
}
}
$userData['password']['value'] = '********';
$this->systemLogger->logException($e, array('uri' => $uri, 'requestData' => $userData, 'responseStatus' => $e->getResponse()->getStatusCode(), 'responseBody' => $e->getResponse()->getBody()->getContents()));
$result->addError(new \TYPO3\Flow\Error\Error('There was an unspecified error'));
}
return $result;
}
/**
* @param array $source
* @param PropertyMappingConfigurationInterface $configuration
* @return PersistentResource|FlowError
* @throws \Exception
*/
protected function handleFileUploads(array $source, PropertyMappingConfigurationInterface $configuration = null)
{
if (!isset($source['error']) || $source['error'] === \UPLOAD_ERR_NO_FILE) {
if (isset($source['originallySubmittedResource']) && isset($source['originallySubmittedResource']['__identity'])) {
return $this->persistenceManager->getObjectByIdentifier($source['originallySubmittedResource']['__identity'], PersistentResource::class);
}
return null;
}
if ($source['error'] !== \UPLOAD_ERR_OK) {
switch ($source['error']) {
case \UPLOAD_ERR_INI_SIZE:
case \UPLOAD_ERR_FORM_SIZE:
case \UPLOAD_ERR_PARTIAL:
return new FlowError(Files::getUploadErrorMessage($source['error']), 1264440823);
default:
$this->systemLogger->log(sprintf('A server error occurred while converting an uploaded resource: "%s"', Files::getUploadErrorMessage($source['error'])), LOG_ERR);
return new FlowError('An error occurred while uploading. Please try again or contact the administrator if the problem remains', 1340193849);
}
}
if (isset($this->convertedResources[$source['tmp_name']])) {
return $this->convertedResources[$source['tmp_name']];
}
try {
$resource = $this->resourceManager->importUploadedResource($source, $this->getCollectionName($source, $configuration));
$this->convertedResources[$source['tmp_name']] = $resource;
return $resource;
} catch (\Exception $exception) {
$this->systemLogger->log('Could not import an uploaded file', LOG_WARNING);
$this->systemLogger->logException($exception);
return new FlowError('During import of an uploaded file an error occurred. See log for more details.', 1264517906);
}
}
/**
* @Flow\AfterThrowing("Ttree\Scheduler\Aspect\LoggingAspect->allTasks")
* @param JoinPoint $jointPoint
* @throws \Exception
*/
public function logTaskException(JoinPoint $jointPoint)
{
/** @var Task $task */
$exception = $jointPoint->getException();
$this->systemLogger->logException($exception, array('task' => $jointPoint->getClassName()));
}
/**
* @param string $pathAndFilename
* @return void
* @throws \Exception
*/
public function optimizeFile($pathAndFilename)
{
try {
$imageType = exif_imagetype($pathAndFilename);
$fileExtension = strtolower(pathinfo($pathAndFilename, PATHINFO_EXTENSION));
if ($imageType !== FALSE && !in_array($imageType, [\IMAGETYPE_JPEG, \IMAGETYPE_PNG, \IMAGETYPE_GIF], TRUE) || $imageType === FALSE && $fileExtension !== 'svg') {
return;
}
$pathAndFilename = realpath($pathAndFilename);
$cacheIdentifier = md5($pathAndFilename);
$lastModificationTime = \DateTime::createFromFormat('U', filemtime($pathAndFilename));
$cachedLastModificationTime = $this->processingCache->get($cacheIdentifier);
if ($cachedLastModificationTime instanceof \DateTime && $lastModificationTime->getTimestamp() === $lastModificationTime->getTimestamp()) {
return;
}
$useGlobalBinary = $this->settings['useGlobalBinary'];
$binaryRootPath = 'Private/Library/node_modules/';
$file = escapeshellarg($pathAndFilename);
if ($imageType !== FALSE) {
switch ($imageType) {
case \IMAGETYPE_JPEG:
if ($this->settings['formats']['jpg']['enabled'] === FALSE) {
return;
}
$library = 'jpegtran';
$binaryPath = sprintf('%1$s-bin/vendor/%s', $library);
$arguments = sprintf('-copy none -optimize %s -outfile %s %s', $this->settings['formats']['jpg']['progressive'] === TRUE ? '-progressive' : '', $file, $file);
if ($this->settings['formats']['jpg']['useGlobalBinary'] === TRUE) {
$useGlobalBinary = TRUE;
}
break;
case \IMAGETYPE_PNG:
if ($this->settings['formats']['png']['enabled'] === FALSE) {
return;
}
$library = 'optipng';
$binaryPath = sprintf('%1$s-bin/vendor/%s', $library);
$arguments = sprintf('-o%u -strip all -out %s %s', $this->settings['formats']['png']['optimizationLevel'], $file, $file);
if ($this->settings['formats']['png']['useGlobalBinary'] === TRUE) {
$useGlobalBinary = TRUE;
}
break;
case \IMAGETYPE_GIF:
if ($this->settings['formats']['gif']['enabled'] === FALSE) {
return;
}
$library = 'gifsicle';
$binaryPath = sprintf('%1$s/vendor/%1$s', $library);
$arguments = sprintf('--batch -O%u %s ', $this->settings['formats']['gif']['optimizationLevel'], $file);
if ($this->settings['formats']['gif']['useGlobalBinary'] === TRUE) {
$useGlobalBinary = TRUE;
}
break;
}
} else {
if ($this->settings['formats']['svg']['enabled'] === FALSE) {
return;
}
$library = 'svgo';
$binaryPath = sprintf('%1$s/bin/%1$s', $library);
$arguments = sprintf('%s %s', $this->settings['formats']['svg']['pretty'] === TRUE ? '--pretty' : '', $file);
if ($this->settings['formats']['svg']['useGlobalBinary'] === TRUE) {
$useGlobalBinary = TRUE;
}
}
$binaryPath = $useGlobalBinary === TRUE ? $this->settings['globalBinaryPath'] . $library : $this->packageManager->getPackageOfObject($this)->getResourcesPath() . $binaryRootPath . $binaryPath;
$cmd = escapeshellcmd($binaryPath) . ' ' . $arguments;
$output = [];
exec($cmd, $output, $result);
$this->systemLogger->log($cmd . ' (' . ((int) $result === 0 ? 'OK' : 'Error: ' . $result) . ')', LOG_INFO, $output);
$lastModificationTime = \DateTime::createFromFormat('U', filemtime($pathAndFilename));
$this->processingCache->set($cacheIdentifier, $lastModificationTime);
} catch (\Exception $exception) {
$this->systemLogger->logException($exception);
}
}
