/**
* Add a domain record
*
* @param string $siteNodeName The nodeName of the site rootNode, e.g. "neostypo3org"
* @param string $hostname The hostname to match on, e.g. "flow.neos.io"
* @param string $scheme The scheme for linking (http/https)
* @param integer $port The port for linking (0-49151)
* @return void
*/
public function addCommand($siteNodeName, $hostname, $scheme = null, $port = null)
{
$site = $this->siteRepository->findOneByNodeName($siteNodeName);
if (!$site instanceof Site) {
$this->outputLine('<error>No site found with nodeName "%s".</error>', [$siteNodeName]);
$this->quit(1);
}
$domains = $this->domainRepository->findByHostname($hostname);
if ($domains->count() > 0) {
$this->outputLine('<error>The host name "%s" is not unique.</error>', [$hostname]);
$this->quit(1);
}
$domain = new Domain();
if ($scheme !== null) {
$domain->setScheme($scheme);
}
if ($port !== null) {
$domain->setPort($port);
}
$domain->setSite($site);
$domain->setHostname($hostname);
$domainValidator = $this->validatorResolver->getBaseValidatorConjunction(Domain::class);
$result = $domainValidator->validate($domain);
if ($result->hasErrors()) {
foreach ($result->getFlattenedErrors() as $propertyName => $errors) {
$firstError = array_pop($errors);
$this->outputLine('<error>Validation failed for "' . $propertyName . '": ' . $firstError . '</error>');
$this->quit(1);
}
}
$this->domainRepository->add($domain);
$this->outputLine('Domain entry created.');
}
/**
* Upload a new image, and return its metadata.
*
* Depending on the $metadata argument it will return asset metadata for the AssetEditor
* or image metadata for the ImageEditor
*
* @param Asset $asset
* @param string $metadata Type of metadata to return ("Asset" or "Image")
* @return string
*/
public function uploadAssetAction(Asset $asset, $metadata)
{
$this->response->setHeader('Content-Type', 'application/json');
/** @var Site $currentSite */
$currentSite = $this->siteRepository->findOneByNodeName($this->request->getInternalArgument('__siteNodeName'));
if ($currentSite !== null && $currentSite->getAssetCollection() !== null) {
$currentSite->getAssetCollection()->addAsset($asset);
$this->assetCollectionRepository->update($currentSite->getAssetCollection());
}
switch ($metadata) {
case 'Asset':
$result = $this->getAssetProperties($asset);
if ($this->persistenceManager->isNewObject($asset)) {
$this->assetRepository->add($asset);
}
break;
case 'Image':
$result = $this->getImageInterfacePreviewData($asset);
if ($this->persistenceManager->isNewObject($asset)) {
$this->imageRepository->add($asset);
}
break;
default:
$this->response->setStatus(400);
$result = array('error' => 'Invalid "metadata" type: ' . $metadata);
}
return json_encode($result);
}
/**
* Create a new empty site.
*
* @param string $packageKey Package Name to create
* @param string $siteName Site Name to create
* @param string $nodeType NodeType name for the root node to create
* @Flow\Validate(argumentName="$packageKey", type="\Neos\Neos\Validation\Validator\PackageKeyValidator")
* @return void
*/
public function createSiteNodeAction($packageKey, $siteName, $nodeType)
{
$nodeName = $this->nodeService->generateUniqueNodeName(SiteService::SITES_ROOT_PATH, $siteName);
if ($this->siteRepository->findOneByNodeName($nodeName)) {
$this->addFlashMessage('Error:A site with siteNodeName "%s" already exists', Message::SEVERITY_ERROR, [$nodeName], 1412372375);
$this->redirect('createSiteNode');
}
$siteNodeType = $this->nodeTypeManager->getNodeType($nodeType);
if ($siteNodeType === null || $siteNodeType->getName() === 'Neos.Neos:FallbackNode') {
$this->addFlashMessage('Error: The given node type "%s" was not found', 'Import error', Message::SEVERITY_ERROR, [$nodeType], 1412372375);
$this->redirect('createSiteNode');
}
if ($siteNodeType->isOfType('Neos.Neos:Document') === false) {
$this->addFlashMessage('Error: The given node type "%s" is not based on the superType "%s"', Message::SEVERITY_ERROR, [$nodeType, 'Neos.Neos:Document'], 1412372375);
$this->redirect('createSiteNode');
}
$rootNode = $this->nodeContextFactory->create()->getRootNode();
// We fetch the workspace to be sure it's known to the persistence manager and persist all
// so the workspace and site node are persisted before we import any nodes to it.
$rootNode->getContext()->getWorkspace();
$this->persistenceManager->persistAll();
$sitesNode = $rootNode->getNode(SiteService::SITES_ROOT_PATH);
if ($sitesNode === null) {
$sitesNode = $rootNode->createNode(NodePaths::getNodeNameFromPath(SiteService::SITES_ROOT_PATH));
}
$siteNode = $sitesNode->createNode($nodeName, $siteNodeType);
$siteNode->setProperty('title', $siteName);
$site = new Site($nodeName);
$site->setSiteResourcesPackageKey($packageKey);
$site->setState(Site::STATE_ONLINE);
$site->setName($siteName);
$this->siteRepository->add($site);
$this->addFlashMessage('Successfully created site "%s" with siteNode "%s", type "%s" and packageKey "%s"', '', null, [$siteName, $nodeName, $nodeType, $packageKey], 1412372266);
$this->unsetLastVisitedNodeAndRedirect('index');
}
/**
* Deactivate a site
*
* This command deactivates the specified site.
*
* @param string $siteNode The node name of the site to deactivate
* @return void
*/
public function deactivateCommand($siteNode)
{
$site = $this->siteRepository->findOneByNodeName($siteNode);
if (!$site instanceof Site) {
$this->outputLine('<error>Site not found.</error>');
$this->quit(1);
}
$site->setState(Site::STATE_OFFLINE);
$this->siteRepository->update($site);
$this->outputLine('Site deactivated.');
}
/**
* Updates or creates a site with the given $siteNodeName
*
* @param string $siteNodeName
* @return Site
*/
protected function getSiteByNodeName($siteNodeName)
{
$site = $this->siteRepository->findOneByNodeName($siteNodeName);
if ($site === null) {
$site = new Site($siteNodeName);
$this->siteRepository->add($site);
} else {
$this->siteRepository->update($site);
}
return $site;
}
/**
* Builds an array of changes for sites in the given workspace
*
* @param Workspace $selectedWorkspace
* @return array
*/
protected function computeSiteChanges(Workspace $selectedWorkspace)
{
$siteChanges = [];
foreach ($this->publishingService->getUnpublishedNodes($selectedWorkspace) as $node) {
/** @var NodeInterface $node */
if (!$node->getNodeType()->isOfType('Neos.Neos:ContentCollection')) {
$pathParts = explode('/', $node->getPath());
if (count($pathParts) > 2) {
$siteNodeName = $pathParts[2];
$q = new FlowQuery([$node]);
$document = $q->closest('[instanceof Neos.Neos:Document]')->get(0);
// $document will be null if we have a broken root line for this node. This actually should never happen, but currently can in some scenarios.
if ($document !== null) {
$documentPath = implode('/', array_slice(explode('/', $document->getPath()), 3));
$relativePath = str_replace(sprintf(SiteService::SITES_ROOT_PATH . '/%s/%s', $siteNodeName, $documentPath), '', $node->getPath());
if (!isset($siteChanges[$siteNodeName]['siteNode'])) {
$siteChanges[$siteNodeName]['siteNode'] = $this->siteRepository->findOneByNodeName($siteNodeName);
}
$siteChanges[$siteNodeName]['documents'][$documentPath]['documentNode'] = $document;
$change = ['node' => $node, 'contentChanges' => $this->renderContentChanges($node)];
if ($node->getNodeType()->isOfType('Neos.Neos:Node')) {
$change['configuration'] = $node->getNodeType()->getFullConfiguration();
}
$siteChanges[$siteNodeName]['documents'][$documentPath]['changes'][$relativePath] = $change;
}
}
}
}
$liveContext = $this->contextFactory->create(['workspaceName' => 'live']);
ksort($siteChanges);
foreach ($siteChanges as $siteKey => $site) {
foreach ($site['documents'] as $documentKey => $document) {
$liveDocumentNode = $liveContext->getNodeByIdentifier($document['documentNode']->getIdentifier());
$siteChanges[$siteKey]['documents'][$documentKey]['isMoved'] = $liveDocumentNode && $document['documentNode']->getPath() !== $liveDocumentNode->getPath();
$siteChanges[$siteKey]['documents'][$documentKey]['isNew'] = $liveDocumentNode === null;
foreach ($document['changes'] as $changeKey => $change) {
$liveNode = $liveContext->getNodeByIdentifier($change['node']->getIdentifier());
$siteChanges[$siteKey]['documents'][$documentKey]['changes'][$changeKey]['isNew'] = is_null($liveNode);
$siteChanges[$siteKey]['documents'][$documentKey]['changes'][$changeKey]['isMoved'] = $liveNode && $change['node']->getPath() !== $liveNode->getPath();
}
}
ksort($siteChanges[$siteKey]['documents']);
}
return $siteChanges;
}
/**
* Renders the URI to a given node instance or -path.
*
* @param ControllerContext $controllerContext
* @param mixed $node A node object or a string node path, if a relative path is provided the baseNode argument is required
* @param NodeInterface $baseNode
* @param string $format Format to use for the URL, for example "html" or "json"
* @param boolean $absolute If set, an absolute URI is rendered
* @param array $arguments Additional arguments to be passed to the UriBuilder (for example pagination parameters)
* @param string $section
* @param boolean $addQueryString If set, the current query parameters will be kept in the URI
* @param array $argumentsToBeExcludedFromQueryString arguments to be removed from the URI. Only active if $addQueryString = TRUE
* @param boolean $resolveShortcuts INTERNAL Parameter - if FALSE, shortcuts are not redirected to their target. Only needed on rare backend occasions when we want to link to the shortcut itself.
* @return string The rendered URI
* @throws \InvalidArgumentException if the given node/baseNode is not valid
* @throws NeosException if no URI could be resolved for the given node
*/
public function createNodeUri(ControllerContext $controllerContext, $node = null, NodeInterface $baseNode = null, $format = null, $absolute = false, array $arguments = array(), $section = '', $addQueryString = false, array $argumentsToBeExcludedFromQueryString = array(), $resolveShortcuts = true)
{
$this->lastLinkedNode = null;
if (!($node instanceof NodeInterface || is_string($node) || $baseNode instanceof NodeInterface)) {
throw new \InvalidArgumentException('Expected an instance of NodeInterface or a string for the node argument, or alternatively a baseNode argument.', 1373101025);
}
if (is_string($node)) {
$nodeString = $node;
if ($nodeString === '') {
throw new NeosException(sprintf('Empty strings can not be resolved to nodes.', $nodeString), 1415709942);
}
preg_match(NodeInterface::MATCH_PATTERN_CONTEXTPATH, $nodeString, $matches);
if (isset($matches['WorkspaceName']) && $matches['WorkspaceName'] !== '') {
$node = $this->propertyMapper->convert($nodeString, NodeInterface::class);
} else {
if ($baseNode === null) {
throw new NeosException('The baseNode argument is required for linking to nodes with a relative path.', 1407879905);
}
/** @var ContentContext $contentContext */
$contentContext = $baseNode->getContext();
$normalizedPath = $this->nodeService->normalizePath($nodeString, $baseNode->getPath(), $contentContext->getCurrentSiteNode()->getPath());
$node = $contentContext->getNode($normalizedPath);
}
if (!$node instanceof NodeInterface) {
throw new NeosException(sprintf('The string "%s" could not be resolved to an existing node.', $nodeString), 1415709674);
}
} elseif (!$node instanceof NodeInterface) {
$node = $baseNode;
}
if (!$node instanceof NodeInterface) {
throw new NeosException(sprintf('Node must be an instance of NodeInterface or string, given "%s".', gettype($node)), 1414772029);
}
$this->lastLinkedNode = $node;
if ($resolveShortcuts === true) {
$resolvedNode = $this->nodeShortcutResolver->resolveShortcutTarget($node);
} else {
// this case is only relevant in extremely rare occasions in the Neos Backend, when we want to generate
// a link towards the *shortcut itself*, and not to its target.
$resolvedNode = $node;
}
if (is_string($resolvedNode)) {
return $resolvedNode;
}
if (!$resolvedNode instanceof NodeInterface) {
throw new NeosException(sprintf('Could not resolve shortcut target for node "%s"', $node->getPath()), 1414771137);
}
/** @var ActionRequest $request */
$request = $controllerContext->getRequest()->getMainRequest();
$uriBuilder = clone $controllerContext->getUriBuilder();
$uriBuilder->setRequest($request);
$uri = $uriBuilder->reset()->setSection($section)->setArguments($arguments)->setAddQueryString($addQueryString)->setArgumentsToBeExcludedFromQueryString($argumentsToBeExcludedFromQueryString)->setFormat($format ?: $request->getFormat())->uriFor('show', array('node' => $resolvedNode), 'Frontend\\Node', 'Neos.Neos');
$siteNode = $resolvedNode->getContext()->getCurrentSiteNode();
if (NodePaths::isSubPathOf($siteNode->getPath(), $resolvedNode->getPath())) {
/** @var Site $site */
$site = $resolvedNode->getContext()->getCurrentSite();
} else {
$nodePath = NodePaths::getRelativePathBetween(SiteService::SITES_ROOT_PATH, $resolvedNode->getPath());
list($siteNodeName) = explode('/', $nodePath);
$site = $this->siteRepository->findOneByNodeName($siteNodeName);
}
if ($site->hasActiveDomains()) {
$requestUriHost = $request->getHttpRequest()->getBaseUri()->getHost();
$activeHostPatterns = $site->getActiveDomains()->map(function ($domain) {
return $domain->getHostPattern();
})->toArray();
if (!in_array($requestUriHost, $activeHostPatterns, true)) {
$uri = $this->createSiteUri($controllerContext, $site) . '/' . ltrim($uri, '/');
} elseif ($absolute === true) {
$uri = $request->getHttpRequest()->getBaseUri() . ltrim($uri, '/');
}
} elseif ($absolute === true) {
$uri = $request->getHttpRequest()->getBaseUri() . ltrim($uri, '/');
}
return $uri;
}
