AbstractRecordCollection.php

Go to the documentation of this file.

<?php
 
/*
 * 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!
 */
 
namespace ‪TYPO3\CMS\Core\Collection;
 
use ‪TYPO3\CMS\Core\Database\Connection;
use ‪TYPO3\CMS\Core\Database\ConnectionPool;
use ‪TYPO3\CMS\Core\Database\Query\Restriction\DeletedRestriction;
use ‪TYPO3\CMS\Core\DataHandling\DataHandler;
use ‪TYPO3\CMS\Core\Utility\GeneralUtility;
 
abstract class ‪AbstractRecordCollection implements ‪RecordCollectionInterface, ‪PersistableCollectionInterface, ‪SortableCollectionInterface
{
    protected static ‪$storageItemsField = 'items';
 
    protected static ‪$storageTableName = '';
 
    protected ‪$uid = 0;
 
    protected ‪$title;
 
    protected ‪$description;
 
    protected ‪$itemTableName;
 
    protected ‪$storage;
 
    public function ‪__construct()
    {
        $this->storage = new \SplDoublyLinkedList();
    }
 
    #[\ReturnTypeWillChange]
    public function ‪current()
    {
        return $this->storage->current();
    }
 
    #[\ReturnTypeWillChange]
    public function ‪next()
    {
        $this->storage->next();
    }
 
    #[\ReturnTypeWillChange]
    public function ‪key()
    {
        $currentRecord = $this->storage->current();
        return $currentRecord['uid'] ?? 0;
    }
 
    #[\ReturnTypeWillChange]
    public function ‪valid()
    {
        return $this->storage->valid();
    }
 
    #[\ReturnTypeWillChange]
    public function ‪rewind()
    {
        $this->storage->rewind();
    }
 
    public function ‪serialize()
    {
        return ‪serialize($this->‪__serialize());
    }
 
    public function ‪__serialize(): array
    {
        return [
            'uid' => $this->‪getIdentifier(),
        ];
    }
 
    public function ‪unserialize($serialized)
    {
        $this->‪__unserialize(‪unserialize($serialized));
    }
 
    public function ‪__unserialize(array $arrayRepresentation): void
    {
        ‪self::load($arrayRepresentation['uid']);
    }
 
    #[\ReturnTypeWillChange]
    public function ‪count()
    {
        return $this->storage->count();
    }
 
    public function ‪getTitle()
    {
        return ‪$this->title;
    }
 
    public function ‪getUid()
    {
        return ‪$this->uid;
    }
 
    public function ‪getDescription()
    {
        return ‪$this->description;
    }
 
    public function ‪setTitle(‪$title)
    {
        $this->title = ‪$title;
    }
 
    public function ‪setDescription($desc)
    {
        $this->description = $desc;
    }
 
    public function ‪getItemTableName()
    {
        return ‪$this->itemTableName;
    }
 
    public function ‪setItemTableName($tableName)
    {
        $this->itemTableName = $tableName;
    }
 
    public function ‪usort($callbackFunction)
    {
        // @todo Implement usort() method with TCEforms in mind
        throw new \RuntimeException('This method is not yet supported.', 1322545589);
    }
 
    public function ‪moveItemAt($currentPosition, $newPosition = 0)
    {
        // @todo Implement usort() method with TCEforms in mind
        throw new \RuntimeException('This method is not yet supported.', 1322545626);
    }
 
    public function ‪getIdentifier()
    {
        return ‪$this->uid;
    }
 
    public function ‪setIdentifier($id)
    {
        $this->uid = (int)$id;
    }
 
    public static function ‪load($id, $fillItems = false)
    {
        $queryBuilder = GeneralUtility::makeInstance(ConnectionPool::class)->getQueryBuilderForTable(static::getCollectionDatabaseTable());
        $queryBuilder->getRestrictions()->removeAll()->add(GeneralUtility::makeInstance(DeletedRestriction::class));
        $collectionRecord = $queryBuilder->select('*')
            ->from(static::getCollectionDatabaseTable())
            ->where($queryBuilder->expr()->eq('uid', $queryBuilder->createNamedParameter($id, ‪Connection::PARAM_INT)))
            ->executeQuery()
            ->fetchAssociative();
        return ‪self::create($collectionRecord ?: [], $fillItems);
    }
 
    public static function ‪create(array $collectionRecord, $fillItems = false)
    {
        // [phpstan] Unsafe usage of new static()
        // todo: Either mark this class or its constructor final or use new self instead.
        $collection = new static();
        $collection->fromArray($collectionRecord);
        if ($fillItems) {
            $collection->loadContents();
        }
        return $collection;
    }
 
    public function ‪persist()
    {
        ‪$uid = $this->‪getIdentifier() == 0 ? 'NEW' . random_int(100000, 999999) : $this->‪getIdentifier();
        $data = [
            trim(static::getCollectionDatabaseTable()) => [
                ‪$uid => $this->‪getPersistableDataArray(),
            ],
        ];
        // New records always must have a pid
        if ($this->‪getIdentifier() == 0) {
            $data[trim(static::getCollectionDatabaseTable())][‪$uid]['pid'] = 0;
        }
        $tce = GeneralUtility::makeInstance(DataHandler::class);
        $tce->start($data, []);
        $tce->process_datamap();
    }
 
    abstract protected function ‪getPersistableDataArray();
 
    protected function ‪getItemUidList($includeTableName = true)
    {
        $list = [];
        foreach ($this->storage as $entry) {
            $list[] = ($includeTableName ? $this->‪getItemTableName() . '_' : '') . $entry['uid'];
        }
        return implode(',', $list);
    }
 
    public function ‪toArray()
    {
        $itemArray = [];
        foreach ($this->storage as $item) {
            $itemArray[] = $item;
        }
        return [
            'uid' => $this->‪getIdentifier(),
            'title' => $this->‪getTitle(),
            'description' => $this->‪getDescription(),
            'table_name' => $this->‪getItemTableName(),
            'items' => $itemArray,
        ];
    }
 
    public function ‪fromArray(array $array)
    {
        $this->uid = $array['uid'];
        $this->title = $array['title'];
        $this->description = $array['description'];
        $this->itemTableName = $array['table_name'];
    }
 
    protected static function ‪getCollectionDatabaseTable(): string
    {
        if (!empty(static::$storageTableName)) {
            return static::$storageTableName;
        }
        throw new \RuntimeException('No storage table name was defined the class "' . static::class . '".', 1592207959);
    }
}