collection.php

<?php
namespace Bitrix\Main\ORM\Objectify;
 
use Bitrix\Main\ArgumentException;
use Bitrix\Main\ORM\Data\DataManager;
use Bitrix\Main\ORM\Data\Result;
use Bitrix\Main\ORM\Entity;
use Bitrix\Main\ORM\Fields\Relations\Relation;
use Bitrix\Main\ORM\Fields\ScalarField;
use Bitrix\Main\ORM\Query\Query;
use Bitrix\Main\NotImplementedException;
use Bitrix\Main\ORM\Fields\FieldTypeMask;
use Bitrix\Main\SystemException;
use Bitrix\Main\Text\StringHelper;
use Bitrix\Main\Web\Json;
 
abstract class Collection implements \ArrayAccess, \Iterator, \Countable
{
    static public $dataClass;
 
    protected $_entity;
 
    protected $_objectClass;
 
    protected $_objects = [];
 
    protected $_isFilled = false;
 
    protected $_isSinglePrimary;
 
    protected $_objectsChanges;
 
    protected $_objectsRemoved;
 
    protected $_iterableObjects;
 
    const OBJECT_ADDED = 1;
 
    const OBJECT_REMOVED = 2;
 
    final public function __construct(Entity $entity = null)
    {
        if (empty($entity))
        {
            if (__CLASS__ !== get_called_class())
            {
                // custom collection class
                $dataClass = static::$dataClass;
                $this->_entity = $dataClass::getEntity();
            }
            else
            {
                throw new ArgumentException('Entity required when constructing collection');
            }
        }
        else
        {
            $this->_entity = $entity;
        }
 
        $this->_objectClass = $this->_entity->getObjectClass();
        $this->_isSinglePrimary = count($this->_entity->getPrimaryArray()) == 1;
    }
 
    public function __clone()
    {
        $this->_objects = \Bitrix\Main\Type\Collection::clone((array)$this->_objects);
        $this->_objectsRemoved = \Bitrix\Main\Type\Collection::clone((array)$this->_objectsRemoved);
        $this->_iterableObjects = null;
    }
 
    final public function add(EntityObject $object)
    {
        // check object class
        if (!($object instanceof $this->_objectClass))
        {
            throw new ArgumentException(sprintf(
                'Invalid object class %s for %s collection, expected "%s".',
                get_class($object), get_class($this), $this->_objectClass
            ));
        }
 
        $srPrimary = $this->sysGetPrimaryKey($object);
 
        if (!$object->sysHasPrimary())
        {
            // object is new and there is no primary yet
            $object->sysAddOnPrimarySetListener([$this, 'sysOnObjectPrimarySet']);
        }
 
        if (empty($this->_objects[$srPrimary])
            && (!isset($this->_objectsChanges[$srPrimary]) || $this->_objectsChanges[$srPrimary] != static::OBJECT_REMOVED))
        {
            $this->_objects[$srPrimary] = $object;
            $this->_objectsChanges[$srPrimary] = static::OBJECT_ADDED;
        }
        elseif (isset($this->_objectsChanges[$srPrimary]) && $this->_objectsChanges[$srPrimary] == static::OBJECT_REMOVED)
        {
            // silent add for removed runtime
            $this->_objects[$srPrimary] = $object;
 
            unset($this->_objectsChanges[$srPrimary]);
            unset($this->_objectsRemoved[$srPrimary]);
        }
    }
 
    final public function has(EntityObject $object)
    {
        // check object class
        if (!($object instanceof $this->_objectClass))
        {
            throw new ArgumentException(sprintf(
                'Invalid object class %s for %s collection, expected "%s".',
                get_class($object), get_class($this), $this->_objectClass
            ));
        }
 
        return array_key_exists($this->sysGetPrimaryKey($object), $this->_objects);
    }
 
    final public function hasByPrimary($primary)
    {
        $normalizedPrimary = $this->sysNormalizePrimary($primary);
        return array_key_exists($this->sysSerializePrimaryKey($normalizedPrimary), $this->_objects);
    }
 
    final public function getByPrimary($primary)
    {
        $normalizedPrimary = $this->sysNormalizePrimary($primary);
        $serializePrimaryKey = $this->sysSerializePrimaryKey($normalizedPrimary);
 
        if (isset($this->_objects[$serializePrimaryKey]))
        {
            return $this->_objects[$serializePrimaryKey];
        }
 
        return null;
    }
 
    final public function getAll()
    {
        return array_values($this->_objects);
    }
 
    final public function remove(EntityObject $object)
    {
        // check object class
        if (!($object instanceof $this->_objectClass))
        {
            throw new ArgumentException(sprintf(
                'Invalid object class %s for %s collection, expected "%s".',
                get_class($object), get_class($this), $this->_objectClass
            ));
        }
 
        // ignore deleted objects
        if ($object->state === State::DELETED)
        {
            return;
        }
 
        $srPrimary = $this->sysGetPrimaryKey($object);
        $this->sysRemove($srPrimary);
    }
 
    final public function removeByPrimary($primary)
    {
        $normalizedPrimary = $this->sysNormalizePrimary($primary);
        $srPrimary = $this->sysSerializePrimaryKey($normalizedPrimary);
 
        $this->sysRemove($srPrimary);
    }
 
    public function sysRemove($srPrimary)
    {
        $object = $this->_objects[$srPrimary];
 
        if (empty($object))
        {
            $object = $this->entity->wakeUpObject($srPrimary);
        }
 
        unset($this->_objects[$srPrimary]);
 
        if (!isset($this->_objectsChanges[$srPrimary]) || $this->_objectsChanges[$srPrimary] != static::OBJECT_ADDED)
        {
            // regular remove
            $this->_objectsChanges[$srPrimary] = static::OBJECT_REMOVED;
            $this->_objectsRemoved[$srPrimary] = $object;
        }
        elseif (isset($this->_objectsChanges[$srPrimary]) && $this->_objectsChanges[$srPrimary] == static::OBJECT_ADDED)
        {
            // silent remove for added runtime
            unset($this->_objectsChanges[$srPrimary]);
            unset($this->_objectsRemoved[$srPrimary]);
        }
    }
 
    final public function fill($fields = FieldTypeMask::ALL)
    {
        $entityPrimary = $this->_entity->getPrimaryArray();
 
        $primaryValues = [];
        $fieldsToSelect = [];
 
        // if field is the only one
        if (is_scalar($fields) && !is_numeric($fields))
        {
            $fields = [$fields];
        }
 
        // collect custom fields to select
        foreach ($this->_objects as $object)
        {
            $idleFields = is_array($fields)
                ? $object->sysGetIdleFields($fields)
                : $object->sysGetIdleFieldsByMask($fields);
 
            if (!empty($idleFields))
            {
                $fieldsToSelect = array_unique(array_merge($fieldsToSelect, $idleFields));
 
                // add object to query
                $objectPrimary = $object->sysRequirePrimary();
 
                $primaryValues[] = count($objectPrimary) == 1
                    ? current($objectPrimary)
                    : $objectPrimary;
            }
        }
 
        // add primary to select
        if (!empty($fieldsToSelect))
        {
            $fieldsToSelect = array_unique(array_merge($entityPrimary, $fieldsToSelect));
 
            // build primary filter
            $primaryFilter = Query::filter();
 
            if (count($entityPrimary) == 1)
            {
                // IN for single-primary objects
                $primaryFilter->whereIn($entityPrimary[0], $primaryValues);
            }
            else
            {
                // OR for multi-primary objects
                $primaryFilter->logic('or');
 
                foreach ($primaryValues as $objectPrimary)
                {
                    // add each object as a separate condition
                    $oneObjectFilter = Query::filter();
 
                    foreach ($objectPrimary as $primaryName => $primaryValue)
                    {
                        $oneObjectFilter->where($primaryName, $primaryValue);
                    }
 
                    $primaryFilter->where($oneObjectFilter);
                }
            }
 
            // build query
            $dataClass = $this->_entity->getDataClass();
            $result = $dataClass::query()->setSelect($fieldsToSelect)->where($primaryFilter)->exec();
 
            // set object to identityMap of result, and it will be partially completed by fetch
            $im = new IdentityMap;
 
            foreach ($this->_objects as $object)
            {
                $im->put($object);
            }
 
            $result->setIdentityMap($im);
            $result->fetchCollection();
        }
 
        // return field value it it was only one
        if (is_array($fields) && count($fields) == 1 && $this->entity->hasField(current($fields)))
        {
            $fieldName = current($fields);
            $field = $this->entity->getField($fieldName);
 
            return ($field instanceof Relation)
                ? $this->sysGetCollection($fieldName)
                : $this->sysGetList($fieldName);
        }
    }
 
    final public function save($ignoreEvents = false)
    {
        $result = new Result;
 
        $addObjects = [];
 
        $updateObjects = [];
 
        foreach ($this->_objects as $object)
        {
            if ($object->sysGetState() === State::RAW)
            {
                $addObjects[] = ['__object' => $object];
            }
            elseif ($object->sysGetState() === State::CHANGED)
            {
                $updateObjects[] = $object;
            }
        }
 
        $dataClass = static::$dataClass;
 
        // multi add
        if (!empty($addObjects))
        {
            $result = $dataClass::addMulti($addObjects, $ignoreEvents);
        }
 
        // multi update
        if (!empty($updateObjects))
        {
            $areEqual = true;
            $primaries = [];
 
            $dataSample = $updateObjects[0]->collectValues(Values::CURRENT, FieldTypeMask::SCALAR | FieldTypeMask::USERTYPE);
            asort($dataSample);
 
            // get only scalar & uf data and check its uniqueness
            foreach ($updateObjects as $object)
            {
                $objectData = $object->collectValues(Values::CURRENT, FieldTypeMask::SCALAR | FieldTypeMask::USERTYPE);
                asort($objectData);
 
                if ($dataSample !== $objectData)
                {
                    $areEqual = false;
                    break;
                }
 
                $primaries[] = $object->primary;
            }
 
            if ($areEqual)
            {
                // one query
                $result = $dataClass::updateMulti($primaries, $dataSample, $ignoreEvents);
 
                // post save
                foreach ($updateObjects as $object)
                {
                    $object->sysSaveRelations($result);
                    $object->sysPostSave();
                }
            }
            else
            {
                // each object separately
                foreach ($updateObjects as $object)
                {
                    $objectResult = $object->save();
 
                    if (!$objectResult->isSuccess())
                    {
                        $result->addErrors($objectResult->getErrors());
                    }
                }
            }
        }
 
        return $result;
    }
 
    final public static function wakeUp($rows)
    {
        // define object class
        $dataClass = static::$dataClass;
        $objectClass = $dataClass::getObjectClass();
 
        // complete collection
        $collection = new static;
 
        foreach ($rows as $row)
        {
            $collection->sysAddActual($objectClass::wakeUp($row));
        }
 
        return $collection;
    }
 
    public function __get($name)
    {
        switch ($name)
        {
            case 'entity':
                return $this->_entity;
            case 'dataClass':
                throw new SystemException('Property `dataClass` should be received as static.');
        }
 
        throw new SystemException(sprintf(
            'Unknown property `%s` for collection `%s`', $name, get_called_class()
        ));
    }
 
    public function __set($name, $value)
    {
        switch ($name)
        {
            case 'entity':
            case 'dataClass':
                throw new SystemException(sprintf(
                    'Property `%s` for collection `%s` is read-only', $name, get_called_class()
                ));
        }
 
        throw new SystemException(sprintf(
            'Unknown property `%s` for collection `%s`', $name, get_called_class()
        ));
    }
 
    public function __call($name, $arguments)
    {
        $first3 = substr($name, 0, 3);
        $last4 = substr($name, -4);
 
        // group getter
        if ($first3 == 'get' && $last4 == 'List')
        {
            $fieldName = EntityObject::sysMethodToFieldCase(substr($name, 3, -4));
 
            if ($fieldName == '')
            {
                $fieldName = StringHelper::strtoupper($arguments[0]);
 
                // check if custom method exists
                $personalMethodName = $first3.EntityObject::sysFieldToMethodCase($fieldName).$last4;
 
                if (method_exists($this, $personalMethodName))
                {
                    return $this->$personalMethodName(...array_slice($arguments, 1));
                }
 
                // hard field check
                $this->entity->getField($fieldName);
            }
 
            // check if field exists
            if ($this->_entity->hasField($fieldName))
            {
                return $this->sysGetList($fieldName);
            }
        }
 
        $last10 = substr($name, -10);
 
        if ($first3 == 'get' && $last10 == 'Collection')
        {
            $fieldName = EntityObject::sysMethodToFieldCase(substr($name, 3, -10));
 
            if ($fieldName == '')
            {
                $fieldName = StringHelper::strtoupper($arguments[0]);
 
                // check if custom method exists
                $personalMethodName = $first3.EntityObject::sysFieldToMethodCase($fieldName).$last10;
 
                if (method_exists($this, $personalMethodName))
                {
                    return $this->$personalMethodName(...array_slice($arguments, 1));
                }
 
                // hard field check
                $this->entity->getField($fieldName);
            }
 
            // check if field exists
            if ($this->_entity->hasField($fieldName) && $this->_entity->getField($fieldName) instanceof Relation)
            {
                return $this->sysGetCollection($fieldName);
            }
        }
 
        $first4 = substr($name, 0, 4);
 
        // filler
        if ($first4 == 'fill')
        {
            $fieldName = EntityObject::sysMethodToFieldCase(substr($name, 4));
 
            // check if field exists
            if ($this->_entity->hasField($fieldName))
            {
                return $this->fill([$fieldName]);
            }
        }
 
        throw new SystemException(sprintf(
            'Unknown method `%s` for object `%s`', $name, get_called_class()
        ));
    }
 
    public function sysAddActual(EntityObject $object)
    {
        $this->_objects[$this->sysGetPrimaryKey($object)] = $object;
    }
 
    public function sysOnObjectPrimarySet($object)
    {
        $srHash = spl_object_hash($object);
        $srPrimary = $this->sysSerializePrimaryKey($object->primary);
 
        if (isset($this->_objects[$srHash]))
        {
            // rewrite object
            unset($this->_objects[$srHash]);
            $this->_objects[$srPrimary] = $object;
 
            // rewrite changes
            if (isset($this->_objectsChanges[$srHash]))
            {
                $this->_objectsChanges[$srPrimary] = $this->_objectsChanges[$srHash];
                unset($this->_objectsChanges[$srHash]);
            }
 
            // rewrite removed registry
            if (isset($this->_objectsRemoved[$srHash]))
            {
                $this->_objectsRemoved[$srPrimary] = $this->_objectsRemoved[$srHash];
                unset($this->_objectsRemoved[$srHash]);
            }
        }
    }
 
    public function sysIsFilled()
    {
        return $this->_isFilled;
    }
 
    public function sysIsChanged()
    {
        return !empty($this->_objectsChanges);
    }
 
    public function sysGetChanges()
    {
        $changes = [];
 
        foreach ($this->_objectsChanges as $srPrimary => $changeCode)
        {
            if (isset($this->_objects[$srPrimary]))
            {
                $changedObject = $this->_objects[$srPrimary];
            }
            elseif (isset($this->_objectsRemoved[$srPrimary]))
            {
                $changedObject = $this->_objectsRemoved[$srPrimary];
            }
            else
            {
                $changedObject = null;
            }
 
            if (empty($changedObject))
            {
                throw new SystemException(sprintf(
                    'Object with primary `%s` was not found in `%s` collection', $srPrimary, get_class($this)
                ));
            }
 
            $changes[] = [$changedObject, $changeCode];
        }
 
        return $changes;
    }
 
    public function sysResetChanges($rollback = false)
    {
        if ($rollback)
        {
            foreach ($this->_objectsChanges as $srPrimary => $changeCode)
            {
                if ($changeCode === static::OBJECT_ADDED)
                {
                    unset($this->_objects[$srPrimary]);
                }
                elseif ($changeCode === static::OBJECT_REMOVED)
                {
                    $this->_objects[$srPrimary] = $this->_objectsRemoved[$srPrimary];
                }
            }
        }
 
        $this->_objectsChanges = [];
        $this->_objectsRemoved = [];
    }
 
    protected function sysGetList($fieldName)
    {
        $values = [];
 
        // collect field values
        foreach ($this->_objects as $objectPrimary => $object)
        {
            $values[] = $object->sysGetValue($fieldName);
        }
 
        return $values;
    }
 
    protected function sysGetCollection($fieldName)
    {
        $field = $this->_entity->getField($fieldName);
 
        $values = $field->getRefEntity()->createCollection();
 
        // collect field values
        foreach ($this->_objects as $objectPrimary => $object)
        {
            $value = $object->sysGetValue($fieldName);
 
            if ($value instanceof EntityObject)
            {
                $values[] = $value;
            }
            elseif ($value instanceof Collection)
            {
                foreach ($value->getAll() as $remoteObject)
                {
                    $values[] = $remoteObject;
                }
            }
        }
 
        return $values;
    }
 
    public function sysReviseDeletedObjects()
    {
        // clear from deleted objects
        foreach ($this->_objects as $k => $object)
        {
            if ($object->state === State::DELETED)
            {
                unset($this->_objects[$k]);
            }
        }
    }
 
    public function sysSetFilled($value = true)
    {
        $this->_isFilled = $value;
    }
 
    protected function sysNormalizePrimary($primary)
    {
        // normalize primary
        $primaryNames = $this->_entity->getPrimaryArray();
 
        if (!is_array($primary))
        {
            if (count($primaryNames) > 1)
            {
                throw new ArgumentException(sprintf(
                    'Only one value of primary found, when entity %s has %s primary keys',
                    $this->_entity->getDataClass(), count($primaryNames)
                ));
            }
 
            $primary = [$primaryNames[0] => $primary];
        }
 
        // check in $this->objects
        $normalizedPrimary = [];
 
        foreach ($primaryNames as $primaryName)
        {
            $field = $this->_entity->getField($primaryName);
            $normalizedPrimary[$primaryName] = $field->cast($primary[$primaryName]);
        }
 
        return $normalizedPrimary;
    }
 
    protected function sysGetPrimaryKey(EntityObject $object)
    {
        if ($object->sysHasPrimary())
        {
            return $this->sysSerializePrimaryKey($object->primary);
        }
        else
        {
            return spl_object_hash($object);
        }
    }
 
    protected function sysSerializePrimaryKey($primary)
    {
        if ($this->_isSinglePrimary)
        {
            return current($primary);
        }
 
        return Json::encode(array_values($primary));
    }
 
    public function offsetSet($offset, $value): void
    {
        $this->add($value);
    }
 
    public function offsetExists($offset): bool
    {
        throw new NotImplementedException;
    }
 
    public function offsetUnset($offset): void
    {
        throw new NotImplementedException;
    }
 
    #[\ReturnTypeWillChange]
    public function offsetGet($offset)
    {
        throw new NotImplementedException;
    }
 
    public function rewind(): void
    {
        $this->_iterableObjects = $this->_objects;
        reset($this->_iterableObjects);
    }
 
    #[\ReturnTypeWillChange]
    public function current()
    {
        if ($this->_iterableObjects === null)
        {
            $this->_iterableObjects = $this->_objects;
        }
 
        return current($this->_iterableObjects);
    }
 
    #[\ReturnTypeWillChange]
    public function key()
    {
        return key($this->_iterableObjects);
    }
 
    public function next(): void
    {
        next($this->_iterableObjects);
    }
 
    public function valid(): bool
    {
        return key($this->_iterableObjects) !== null;
    }
 
    public function count(): int
    {
        return count($this->_objects);
    }
 
    public function merge(?self $collection): self
    {
        if (is_null($collection))
        {
            return $this;
        }
 
        if (get_class($this) !== get_class($collection))
        {
            throw new ArgumentException(
                'Invalid object class ' . get_class($collection) . ' for merge, ' . get_class($this) . ' expected .'
            );
        }
 
        foreach ($collection as $item)
        {
            $this->add($item);
        }
 
        return $this;
    }
 
    public function isEmpty(): bool
    {
        return $this->count() === 0;
    }
}