NodeService.php

<?php

declare(strict_types=1);

namespace Garagist\Mautic\Service;

use Neos\ContentRepository\Domain\Factory\NodeFactory;
use Neos\ContentRepository\Domain\Model\NodeInterface;
use Neos\ContentRepository\Domain\Repository\NodeDataRepository;
use Neos\ContentRepository\Domain\Repository\WorkspaceRepository;
use Neos\ContentRepository\Domain\Service\Context;
use Neos\ContentRepository\Domain\Service\ContextFactoryInterface;
use Neos\ContentRepository\Domain\Utility\NodePaths;
use Neos\ContentRepository\Security\Authorization\Privilege\Node\NodePrivilegeSubject;
use Neos\Eel\FlowQuery\FlowQuery;
use Neos\Flow\Annotations as Flow;
use Neos\Flow\Security\Authorization\PrivilegeManagerInterface;
use Neos\Neos\Domain\Repository\DomainRepository;
use Neos\Neos\Domain\Repository\SiteRepository;
use Neos\Neos\Domain\Service\ContentDimensionPresetSourceInterface;
use Neos\Neos\Domain\Service\SiteService;
use Neos\Neos\Security\Authorization\Privilege\NodeTreePrivilege;
use Neos\ContentRepository\Domain\Projection\Content\TraversableNodeInterface;

/**
 * A service for retrieving nodes from NeosCR
 * @api
 */
#[Flow\Scope('singleton')]
class NodeService
{
    #[Flow\Inject]
    protected ContentDimensionPresetSourceInterface $contentDimensionPresetSource;

    #[Flow\Inject]
    protected DomainRepository $domainRepository;

    #[Flow\Inject]
    protected SiteRepository $siteRepository;

    #[Flow\Inject]
    protected ContextFactoryInterface $contextFactory;

    #[Flow\Inject]
    protected PrivilegeManagerInterface $privilegeManager;

    #[Flow\Inject]
    protected WorkspaceRepository $workspaceRepository;

    #[Flow\Inject]
    protected NodeDataRepository $nodeDataRepository;

    #[Flow\Inject]
    protected NodeFactory $nodeFactory;

    /**
     * @var array
     */
    protected array $options = [];

    /**
     * Get the site node from a node
     *
     * @param NodeInterface $node
     * @return NodeInterface
     */
    public function getSiteNodeFromNode(NodeInterface $node): NodeInterface
    {
        if ($siteNode = $node->getContext()->getCurrentSiteNode()) {
            return $siteNode;
        }

        $flowQuery = new FlowQuery([$node]);
        $nodes = $flowQuery->parents('[instanceof Neos.Neos:Document]')->get();

        return end($nodes);
    }

    /**
     * Get site name based on node
     *
     * @param NodeInterface $node
     * @return string|null
     */
    public function getSiteNameBasedOnNode(NodeInterface $node): ?string
    {
        if ($site = $node->getContext()->getCurrentSite()) {
            return $site->getName();
        }

        $name = null;

        try {
            $nodePath = $node->findNodePath();
            $nodePathSegments = $nodePath->getParts();
            // Seems hacky, but we need to get the site by the node name here
            // and extract the site name by the node's path
            if (count($nodePathSegments) >= 3) {
                $siteName = $nodePathSegments[2];
                $site = $this->siteRepository->findOneByNodeName($siteName->__toString());
                if ($site && $site->isOnline()) {
                    $name = $site->getName();
                }
            }
        } catch (\Exception $th) {
        }

        return $name;
    }

    /**
     * Get all sites nodes
     *
     * @return NodeInterface[]
     */
    public function getSiteNodes() {
        $siteNodes = [];
        $liveWorkspace = $this->workspaceRepository->findByIdentifier('live');

        foreach ($this->siteRepository->findOnline() as $site) {
            $siteNodePath = NodePaths::addNodePathSegment(SiteService::SITES_ROOT_PATH, $site->getNodeName());
            $siteNodesInAllDimensions = $this->nodeDataRepository->findByPathWithoutReduce($siteNodePath, $liveWorkspace);

            foreach ($siteNodesInAllDimensions as $siteNodeData) {
                $siteNodeContext = $this->nodeFactory->createContextMatchingNodeData($siteNodeData);
                $siteNode = $this->nodeFactory->createFromNodeData($siteNodeData, $siteNodeContext);

                // if the node exists, check if the user is granted access to this node
                if ($this->privilegeManager->isGranted(NodeTreePrivilege::class, new NodePrivilegeSubject($siteNode))) {
                    $siteNodes[] = $siteNode;
                    break;
                }
            }
        }

        return $siteNodes;
    }

    /**
     * Get node by id
     *
     * @param string $identifier
     * @return NodeInterface
     */
    public function getNodeById(string $identifier): NodeInterface
    {
        $context = $this->getContentContextDimension();

        return $context->getNodeByIdentifier($identifier);
    }

    /**
     * Get nodes by type
     *
     * @param string $nodeTypeName The name of the node type
     * @param Context|null $context
     *
     * @return array
     * @throws Exception
     */
    public function getNodesByType(string $nodeTypeName, ?Context $context = null): array
    {
        if (!isset($context)) {
            $context = $this->getContentContextDimension();
        }

        $flowQuery = new FlowQuery(array($context->getCurrentSiteNode()));
        return $flowQuery->context([
            'invisibleContentShown' => false
        ])->find('[instanceof ' . $nodeTypeName . ']')->get();
    }

    /**
     * Get parent from a node with a given nodeTypeName
     *
     * @param NodeInterface $node
     * @param string $nodeTypeName
     *
     * @return NodeInterface|null
     */
    public function getParentByType(NodeInterface $node, string $nodeTypeName): ?NodeInterface
    {
        $flowQuery = new FlowQuery(array($node));
        return $flowQuery->parent()->closest('[instanceof ' . $nodeTypeName . ']')->get(0);
    }

    /**
     * Create Dimension Context
     *
     * @return Context
     */
    public function getContentContextDimension(): Context
    {
        $dimensionName = $this->options['dimensionName'] ?? 'language';
        $workspaceName = $this->options['workspaceName'] ?? 'live';

        if (!isset($this->options['dimensionValues']) || empty($this->options['dimensionValues'])) {
            $defaultPreset = $this->contentDimensionPresetSource->getDefaultPreset($dimensionName);
            if (!isset($defaultPreset['values'])) {
                return $this->createContentContext([], $workspaceName);
            }
            $dimensionValues = $defaultPreset['values'];
        }
        $dimensionArray[$dimensionName] = $dimensionValues;

        return $this->createContentContext($dimensionArray, $workspaceName);
    }


    /**
     * Create a ContentContext based on the given workspace name
     *
     * @param array  $dimensions Optional list of dimensions and their values which should be set
     * @param string $workspaceName Optional Name of the workspace to set for the context
     *
     * @return Context
     */
    protected function createContentContext(array $dimensions = [], string $workspaceName = 'live'): Context
    {
        $contextProperties = array(
            'workspaceName' => $workspaceName,
            'invisibleContentShown' => true,
            'inaccessibleContentShown' => true
        );

        if ($dimensions !== array()) {
            $contextProperties['dimensions'] = $dimensions;
            $contextProperties['targetDimensions'] = array_map(function ($dimensionValues) {
                return array_shift($dimensionValues);
            }, $dimensions);
        }

        $currentDomain = $this->domainRepository->findOneByActiveRequest();
        if ($currentDomain !== null) {
            $contextProperties['currentSite'] = $currentDomain->getSite();
            $contextProperties['currentDomain'] = $currentDomain;
        } else {
            $contextProperties['currentSite'] = $this->siteRepository->findFirstOnline();
        }

        return $this->contextFactory->create($contextProperties);
    }

    /**
     * Set options
     *
     * @param array $options Contains options
     *        like string $dimensionName Optional Dimension name,
     *        string $dimensionValues Optional The preferred dimension values, including the fallback dimension like array('en', 'de'); ,
     *        string $workspaceName Optional Name of the workspace to set for the context
     * @return void
     */
    public function setOptions(array $options): void
    {
        $this->options = $options;
    }
}