Collection.php

<?php
 
namespace Bitrix\Im\V2;
 
use Bitrix\Main\ORM;
use Bitrix\Main\ORM\Data\DataManager;
use Bitrix\Main\ArgumentTypeException;
use Bitrix\Im\V2\Service\Context;
 
abstract class Collection extends Registry implements ActiveRecordCollection
{
    protected ?ORM\Objectify\Collection $dataEntityCollection = null;
 
    // temporary entity id in registry
    protected int $newEntityTmpId = 0;
 
    public function __construct($source = null)
    {
        parent::__construct();
 
        if (!empty($source))
        {
            $this->load($source);
        }
    }
 
    final public static function getDataClass(): string
    {
        return static::getCollectionElementClass()::getDataClass();
    }
 
    abstract public static function getCollectionElementClass(): string;
 
    abstract public static function find(array $filter, array $order, ?int $limit = null, ?Context $context = null): self;
 
    public function add(ActiveRecord $entry): self
    {
        $collectionElementClass = static::getCollectionElementClass();
 
        if (!($entry instanceof $collectionElementClass))
        {
            $entryClass = \get_class($entry);
            throw new ArgumentTypeException("Entry is instance of {$entryClass}, but collection support {$collectionElementClass}");
        }
 
        if ($entry instanceof RegistryEntry)
        {
            $entry->setRegistry($this);
        }
 
        if ($entry->getPrimaryId())
        {
            parent::offsetSet($entry->getPrimaryId(), $entry);
        }
        else
        {
            $this->newEntityTmpId --;
            parent::offsetSet($this->newEntityTmpId, $entry);
        }
 
        return $this;
    }
 
    public function offsetSet($offset, $entry): void
    {
        $collectionElementClass = static::getCollectionElementClass();
 
        if (!($entry instanceof $collectionElementClass))
        {
            $entryClass = \get_class($entry);
            throw new ArgumentTypeException("Entry is instance of {$entryClass}, but collection support {$collectionElementClass}");
        }
 
        if ($offset === null)
        {
            if ($entry->getPrimaryId())
            {
                $offset = $entry->getPrimaryId();
            }
            else
            {
                $this->newEntityTmpId --;
                $offset = $this->newEntityTmpId;
            }
        }
 
        parent::offsetSet($offset, $entry);
    }
 
    protected function prepareFields(): Result
    {
        $result = new Result;
 
        $this->dataEntityCollection = null; //Resetting the collection of entities before filling it
        $dataEntity = $this->getDataEntityCollection();
 
        foreach ($this as $entity)
        {
            if ($entity->isDeleted())
            {
                continue;
            }
 
            $resultFill = $entity->prepareFields();
 
            if (!$resultFill->isSuccess())
            {
                $result->addErrors($resultFill->getErrors());
                continue;
            }
 
            $dataEntity->add($entity->getDataEntity());
        }
 
        return $result;
    }
 
    public function getPrimaryIds(): array
    {
        $ids = [];
 
        foreach ($this as $item)
        {
            if ($item->getPrimaryId())
            {
                $ids[] = $item->getPrimaryId();
            }
        }
 
        return $ids;
    }
 
    public function load($source): Result
    {
        if (is_array($source))
        {
            if ($this->isArrayOfIds($source))
            {
                return $this->initByArrayOfPrimary($source);
            }
 
            return $this->initByArray($source);
        }
 
        if ($source instanceof ORM\Objectify\Collection)
        {
            return $this->initByEntitiesCollection($source);
        }
 
        return (new Result())->addError(new Error(Error::NOT_FOUND));
    }
 
 
    protected function setDataEntityCollection(ORM\Objectify\Collection $entityCollection): self
    {
        $this->dataEntityCollection = $entityCollection;
        return $this;
    }
 
    public function getDataEntityCollection(): ORM\Objectify\Collection
    {
        if ($this->dataEntityCollection === null)
        {
            $dataClass = static::getDataClass();
            $entityCollectionClass = $dataClass::getCollectionClass();
            $this->dataEntityCollection = new $entityCollectionClass;
        }
 
        return $this->dataEntityCollection;
    }
 
    public function save(bool $isGroupSave = false): Result
    {
        $result = $this->prepareFields();
 
        if ($result->isSuccess())
        {
            if ($isGroupSave)
            {
                $resultSave = $this->getDataEntityCollection()->save(true);
                if (!$resultSave->isSuccess())
                {
                    $result->addErrors($resultSave->getErrors());
                }
            }
            else
            {
                $index = [];
                foreach ($this as $inx => $entity)
                {
                    $index[] = $inx;
                }
 
                foreach ($index as $inx)
                {
                    $entity = $this[$inx];
                    if ($entity instanceof RegistryEntry)
                    {
                        $entity->setRegistry($this);
                    }
                    $resultSave = $entity->save();
                    if (!$resultSave->isSuccess())
                    {
                        $result->addErrors($resultSave->getErrors());
                    }
                    elseif ($inx < 0 && isset($this[$entity->getPrimaryId()]))
                    {
                        unset($this[$inx]);// remove temporary object link from registry
                    }
                }
            }
        }
 
        return $result;
    }
 
    public function delete(): Result
    {
        $result = new Result();
 
        $idsToDelete = $this->getPrimaryIds();
        if (method_exists(static::getDataClass(), 'deleteByFilter'))
        {
            if (empty($idsToDelete))
            {
                return $result;
            }
 
            $primaryField = static::getPrimaryFieldName();
            static::getDataClass()::deleteByFilter(
                [
                    "={$primaryField}" => $idsToDelete
                ]
            );
 
            return $result;
        }
 
        foreach ($idsToDelete as $idToDelete)
        {
            $deleteResult = static::getDataClass()::delete($idToDelete);
            if (!$deleteResult->isSuccess())
            {
                $result->addErrors($deleteResult->getErrors());
            }
        }
 
        return $result;
    }
 
    public function hasUnsaved(): bool
    {
        foreach ($this as $entity)
        {
            if ($entity->getPrimaryId() === null)
            {
                return true;
            }
            if ($entity->isChanged())
            {
                return true;
            }
            if ($entity->isDeleted())
            {
                return true;
            }
        }
 
        return false;
    }
 
    protected function initByEntitiesCollection(ORM\Objectify\Collection $entitiesCollection): Result
    {
        $collectionClass = static::getDataClass()::getCollectionClass();
 
        if (!($entitiesCollection instanceof $collectionClass))
        {
            $entryClass = \get_class($entitiesCollection);
            throw new ArgumentTypeException("Entry is instance of {$entryClass}, but collection support {$collectionClass}");
        }
 
        $this->setDataEntityCollection($entitiesCollection);
 
        return $this->initForEach($entitiesCollection);
    }
 
    protected function initByArray(array $items): Result
    {
        return $this->initForEach($items);
    }
 
    protected function initByArrayOfPrimary(array $ids): Result
    {
        $primaryField = static::getPrimaryFieldName();
 
        if (empty($ids))
        {
            return new Result();
        }
 
        $entitiesCollection = static::getDataClass()::query()
            ->setSelect(['*'])
            ->whereIn($primaryField, $ids)
            ->fetchCollection()
        ;
 
        return $this->initByEntitiesCollection($entitiesCollection);
    }
 
    private function initForEach($entitiesCollection): Result
    {
        $result = new Result();
        $itemClass = static::getCollectionElementClass();
 
        foreach ($entitiesCollection as $entity)
        {
            $item = new $itemClass;
            $loadResult = $item->load($entity);
 
            if (!$loadResult->isSuccess())
            {
                $result->addErrors($loadResult->getErrors());
            }
            elseif ($item instanceof RegistryEntry)
            {
                $item->setRegistry($this);
            }
        }
 
        return $result;
    }
 
    private function isArrayOfIds(array $array): bool
    {
        foreach ($array as $key => $value)
        {
            if (!is_int($key) || !is_int($value))
            {
                return false;
            }
        }
 
        return true;
    }
 
    private static function getPrimaryFieldName(): string
    {
        $primaryField = static::getDataClass()::getEntity()->getPrimary();
 
        if (!is_scalar($primaryField))
        {
            throw new \Bitrix\Main\SystemException('Do not support composite primary keys');
        }
 
        return $primaryField;
    }
}