9.5/_element_entity_8php_source.html

<?php

namespace ‪TYPO3\CMS\Workspaces\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 = [], ‪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 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;

    }

}