ElementEntity.php

Go to the documentation of this file.

<?php
namespace TYPO3\CMS\Version\Dependency;

/*
 * This file is part of the TYPO3 CMS project.
 *
 * It is free software; you can redistribute it and/or modify it under
 * the terms of the GNU General Public License, either version 2
 * of the License, or any later version.
 *
 * For the full copyright and license information, please read the
 * LICENSE.txt file that was distributed with this source code.
 *
 * The TYPO3 project - inspiring people to share!
 */
use TYPO3\CMS\Core\Database\ConnectionPool;
use TYPO3\CMS\Core\Utility\GeneralUtility;

class ElementEntity
{
    const REFERENCES_ChildOf = 'childOf';
    const REFERENCES_ParentOf = 'parentOf';
    const EVENT_Construct = 'TYPO3\\CMS\\Version\\Dependency\\ElementEntity::construct';
    const EVENT_CreateChildReference = 'TYPO3\\CMS\\Version\\Dependency\\ElementEntity::createChildReference';
    const EVENT_CreateParentReference = 'TYPO3\\CMS\\Version\\Dependency\\ElementEntity::createParentReference';
    const RESPONSE_Skip = 'TYPO3\\CMS\\Version\\Dependency\\ElementEntity->skip';

    protected $invalid = false;

    protected $table;

    protected $id;

    protected $data;

    protected $record;

    protected $dependency;

    protected $children;

    protected $parents;

    protected $traversingParents = false;

    protected $outerMostParent;

    protected $nestedChildren;

    public function __construct($table, $id, array $data = [], \TYPO3\CMS\Version\Dependency\DependencyResolver $dependency)
    {
        $this->table = $table;
        $this->id = (int)$id;
        $this->data = $data;
        $this->dependency = $dependency;
        $this->dependency->executeEventCallback(self::EVENT_Construct, $this);
    }

    public function setInvalid($invalid)
    {
        $this->invalid = (bool)$invalid;
    }

    public function isInvalid()
    {
        return $this->invalid;
    }

    public function getTable()
    {
        return $this->table;
    }

    public function getId()
    {
        return $this->id;
    }

    public function setId($id)
    {
        $this->id = (int)$id;
    }

    public function getData()
    {
        return $this->data;
    }

    public function getDataValue($key)
    {
        $result = null;
        if ($this->hasDataValue($key)) {
            $result = $this->data[$key];
        }
        return $result;
    }

    public function setDataValue($key, $value)
    {
        $this->data[$key] = $value;
    }

    public function hasDataValue($key)
    {
        return isset($this->data[$key]);
    }

    public function __toString()
    {
        return self::getIdentifier($this->table, $this->id);
    }

    public function getDependency()
    {
        return $this->dependency;
    }

    public function getChildren()
    {
        if (!isset($this->children)) {
            $this->children = [];

            $queryBuilder = GeneralUtility::makeInstance(ConnectionPool::class)
                ->getQueryBuilderForTable('sys_refindex');

            $result = $queryBuilder
                ->select('*')
                ->from('sys_refindex')
                ->where(
                    $queryBuilder->expr()->eq(
                        'tablename',
                        $queryBuilder->createNamedParameter($this->table, \PDO::PARAM_STR)
                    ),
                    $queryBuilder->expr()->eq(
                        'recuid',
                        $queryBuilder->createNamedParameter($this->id, \PDO::PARAM_INT)
                    ),
                    $queryBuilder->expr()->eq(
                        'workspace',
                        $queryBuilder->createNamedParameter($this->dependency->getWorkspace(), \PDO::PARAM_INT)
                    )
                )
                ->orderBy('sorting')
                ->execute();

            while ($row = $result->fetch()) {
                if ($row['ref_table'] !== '_FILE' && $row['ref_table'] !== '_STRING') {
                    $arguments = [
                        'table' => $row['ref_table'],
                        'id' => $row['ref_uid'],
                        'field' => $row['field'],
                        'scope' => self::REFERENCES_ChildOf
                    ];

                    $callbackResponse = $this->dependency->executeEventCallback(
                        self::EVENT_CreateChildReference,
                        $this,
                        $arguments
                    );
                    if ($callbackResponse !== self::RESPONSE_Skip) {
                        $this->children[] = $this->getDependency()->getFactory()->getReferencedElement(
                            $row['ref_table'],
                            $row['ref_uid'],
                            $row['field'],
                            [],
                            $this->getDependency()
                        );
                    }
                }
            }
        }
        return $this->children;
    }

    public function getParents()
    {
        if (!isset($this->parents)) {
            $this->parents = [];

            $queryBuilder = GeneralUtility::makeInstance(ConnectionPool::class)
                ->getQueryBuilderForTable('sys_refindex');

            $result = $queryBuilder
                ->select('*')
                ->from('sys_refindex')
                ->where(
                    $queryBuilder->expr()->eq(
                        'deleted',
                        $queryBuilder->createNamedParameter(0, \PDO::PARAM_INT)
                    ),
                    $queryBuilder->expr()->eq(
                        'ref_table',
                        $queryBuilder->createNamedParameter($this->table, \PDO::PARAM_STR)
                    ),
                    $queryBuilder->expr()->eq(
                        'ref_uid',
                        $queryBuilder->createNamedParameter($this->id, \PDO::PARAM_INT)
                    ),
                    $queryBuilder->expr()->eq(
                        'workspace',
                        $queryBuilder->createNamedParameter($this->dependency->getWorkspace(), \PDO::PARAM_INT)
                    )
                )
                ->orderBy('sorting')
                ->execute();

            while ($row = $result->fetch()) {
                $arguments = [
                    'table' => $row['tablename'],
                    'id' => $row['recuid'],
                    'field' => $row['field'],
                    'scope' => self::REFERENCES_ParentOf
                ];
                $callbackResponse = $this->dependency->executeEventCallback(
                    self::EVENT_CreateParentReference,
                    $this,
                    $arguments
                );
                if ($callbackResponse !== self::RESPONSE_Skip) {
                    $this->parents[] = $this->getDependency()->getFactory()->getReferencedElement(
                        $row['tablename'],
                        $row['recuid'],
                        $row['field'],
                        [],
                        $this->getDependency()
                    );
                }
            }
        }
        return $this->parents;
    }

    public function hasReferences()
    {
        return !empty($this->getChildren()) || !empty($this->getParents());
    }

    public function getOuterMostParent()
    {
        if (!isset($this->outerMostParent)) {
            $parents = $this->getParents();
            if (empty($parents)) {
                $this->outerMostParent = $this;
            } else {
                $this->outerMostParent = false;
                foreach ($parents as $parent) {
                    $outerMostParent = $parent->getElement()->getOuterMostParent();
                    if ($outerMostParent instanceof \TYPO3\CMS\Version\Dependency\ElementEntity) {
                        $this->outerMostParent = $outerMostParent;
                        break;
                    }
                    if ($outerMostParent === false) {
                        break;
                    }
                }
            }
        }
        return $this->outerMostParent;
    }

    public function getNestedChildren()
    {
        if (!isset($this->nestedChildren)) {
            $this->nestedChildren = [];
            $children = $this->getChildren();
            foreach ($children as $child) {
                $this->nestedChildren = array_merge($this->nestedChildren, [$child->getElement()->__toString() => $child->getElement()], $child->getElement()->getNestedChildren());
            }
        }
        return $this->nestedChildren;
    }

    public static function getIdentifier($table, $id)
    {
        return $table . ':' . $id;
    }

    public function getRecord()
    {
        if (empty($this->record['uid']) || (int)$this->record['uid'] !== $this->getId()) {
            $this->record = [];

            $queryBuilder = GeneralUtility::makeInstance(ConnectionPool::class)
                ->getQueryBuilderForTable($this->getTable());
            $queryBuilder->getRestrictions()->removeAll();

            $row = $queryBuilder
                ->select('uid', 'pid', 't3ver_wsid', 't3ver_state', 't3ver_oid')
                ->from($this->getTable())
                ->where(
                    $queryBuilder->expr()->eq(
                        'uid',
                        $queryBuilder->createNamedParameter($this->getId(), \PDO::PARAM_INT)
                    )
                )
                ->execute()
                ->fetch();

            if (is_array($row)) {
                $this->record = $row;
            }
        }

        return $this->record;
    }
}