If the given node is a Document or has ContentCollection child nodes, these nodes are published as well.
|
public publishNode ( Neos\ContentRepository\Domain\Model\NodeInterface $node, |
||
| $node | Neos\ContentRepository\Domain\Model\NodeInterface | |
| $targetWorkspace | If not set the base workspace is assumed to be the publishing target | |
| return | void | |
/**
* Publish changes of a workspace
*
* This command publishes all modified, created or deleted nodes in the specified workspace to its base workspace.
* If a target workspace is specified, the content is published to that workspace instead.
*
* @param string $workspace Name of the workspace containing the changes to publish, for example "user-john"
* @param string $targetWorkspace If specified, the content will be published to this workspace instead of the base workspace
* @param boolean $verbose If enabled, some information about individual nodes will be displayed
* @param boolean $dryRun If set, only displays which nodes would be published, no real changes are committed
* @return void
*/
public function publishCommand($workspace, $targetWorkspace = null, $verbose = false, $dryRun = false)
{
$workspaceName = $workspace;
$workspace = $this->workspaceRepository->findOneByName($workspaceName);
if (!$workspace instanceof Workspace) {
$this->outputLine('Workspace "%s" does not exist', [$workspaceName]);
$this->quit(1);
}
if ($targetWorkspace === null) {
$targetWorkspace = $workspace->getBaseWorkspace();
$targetWorkspaceName = $targetWorkspace->getName();
} else {
$targetWorkspaceName = $targetWorkspace;
$targetWorkspace = $this->workspaceRepository->findOneByName($targetWorkspaceName);
if (!$targetWorkspace instanceof Workspace) {
$this->outputLine('Target workspace "%s" does not exist', [$targetWorkspaceName]);
$this->quit(2);
}
$possibleTargetWorkspaceNames = [];
$baseWorkspace = $workspace->getBaseWorkspace();
while ($targetWorkspace !== $baseWorkspace) {
if ($baseWorkspace === null) {
$this->outputLine('The target workspace must be a base workspace of "%s".', [$targetWorkspaceName]);
if (count($possibleTargetWorkspaceNames) > 1) {
$this->outputLine('For "%s" possible target workspaces currently are: %s', [$workspaceName, implode(', ', $possibleTargetWorkspaceNames)]);
} else {
$this->outputLine('For "%s" the only possible target workspace currently is "%s".', [$workspaceName, reset($possibleTargetWorkspaceNames)]);
}
$this->quit(3);
}
$possibleTargetWorkspaceNames[] = $baseWorkspace->getName();
$baseWorkspace = $baseWorkspace->getBaseWorkspace();
}
}
try {
$nodes = $this->publishingService->getUnpublishedNodes($workspace);
} catch (\Exception $exception) {
$this->outputLine('An error occurred while fetching unpublished nodes from workspace %s, publish aborted.', [$workspaceName]);
$this->quit(1);
}
$this->outputLine('The workspace %s contains %u unpublished nodes.', [$workspaceName, count($nodes)]);
foreach ($nodes as $node) {
/** @var NodeInterface $node */
if ($verbose) {
$this->outputLine(' ' . $node->getPath());
}
if (!$dryRun) {
$this->publishingService->publishNode($node, $targetWorkspace);
}
}
if (!$dryRun) {
$this->outputLine('Published all nodes in workspace %s to workspace %s', [$workspaceName, $targetWorkspaceName]);
}
}
/**
* @test
*/
public function publishNodePublishesTheNodeAndItsChildNodeCollectionsIfTheNodeTypeHasChildNodes()
{
$mockNode = $this->getMockBuilder(NodeInterface::class)->getMock();
$mockChildNode = $this->getMockBuilder(NodeInterface::class)->getMock();
$mockNodeType = $this->getMockBuilder(NodeType::class)->disableOriginalConstructor()->setMethods(array('hasConfiguration', 'isOfType'))->getMock();
$mockNodeType->expects($this->atLeastOnce())->method('hasConfiguration')->with('childNodes')->will($this->returnValue(true));
$mockNode->expects($this->atLeastOnce())->method('getNodeType')->will($this->returnValue($mockNodeType));
$mockNode->expects($this->atLeastOnce())->method('getWorkspace')->will($this->returnValue($this->mockWorkspace));
$mockNode->expects($this->atLeastOnce())->method('getChildNodes')->with('Neos.Neos:ContentCollection')->will($this->returnValue(array($mockChildNode)));
$mockTargetWorkspace = $this->getMockBuilder(Workspace::class)->disableOriginalConstructor()->getMock();
$this->mockWorkspace->expects($this->atLeastOnce())->method('publishNodes')->with(array($mockNode, $mockChildNode), $mockTargetWorkspace);
$this->publishingService->publishNode($mockNode, $mockTargetWorkspace);
}
/**
* Publishes or discards the given nodes
*
* @param array $nodes <\Neos\ContentRepository\Domain\Model\NodeInterface> $nodes
* @param string $action
* @param Workspace $selectedWorkspace
* @throws \Exception
* @throws \Neos\Flow\Property\Exception
* @throws \Neos\Flow\Security\Exception
*/
public function publishOrDiscardNodesAction(array $nodes, $action, Workspace $selectedWorkspace = null)
{
$propertyMappingConfiguration = $this->propertyMappingConfigurationBuilder->build();
$propertyMappingConfiguration->setTypeConverterOption(NodeConverter::class, NodeConverter::REMOVED_CONTENT_SHOWN, true);
foreach ($nodes as $key => $node) {
$nodes[$key] = $this->propertyMapper->convert($node, NodeInterface::class, $propertyMappingConfiguration);
}
switch ($action) {
case 'publish':
foreach ($nodes as $node) {
$this->publishingService->publishNode($node);
}
$this->addFlashMessage($this->translator->translateById('workspaces.selectedChangesHaveBeenPublished', [], null, null, 'Modules', 'Neos.Neos'));
break;
case 'discard':
$this->publishingService->discardNodes($nodes);
$this->addFlashMessage($this->translator->translateById('workspaces.selectedChangesHaveBeenDiscarded', [], null, null, 'Modules', 'Neos.Neos'));
break;
default:
throw new \RuntimeException('Invalid action "' . htmlspecialchars($action) . '" given.', 1346167441);
}
$this->redirect('show', null, null, ['workspace' => $selectedWorkspace]);
}
/**
* Publishes the given node to the specified targetWorkspace
*
* @param NodeInterface $node
* @param string $targetWorkspaceName
* @return void
*/
public function publishNodeAction(NodeInterface $node, $targetWorkspaceName = null)
{
$targetWorkspace = $targetWorkspaceName !== null ? $this->workspaceRepository->findOneByName($targetWorkspaceName) : null;
$this->publishingService->publishNode($node, $targetWorkspace);
$this->throwStatus(204, 'Node published', '');
}
