Your IP : 3.16.48.201
<?php
/**
* Bitrix Framework
* @package bitrix
* @subpackage main
* @copyright 2001-2018 Bitrix
*/
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;
/**
* Collection of entity objects. Used to hold 1:N and N:M object collections.
*
* @property-read \Bitrix\Main\ORM\Entity $entity
*
* @package bitrix
* @subpackage main
*/
abstract class Collection implements \ArrayAccess, \Iterator, \Countable
{
/**
* Entity Table class. Read-only property.
* @var DataManager
*/
static public $dataClass;
/** @var Entity */
protected $_entity;
/** @var EntityObject */
protected $_objectClass;
/** @var EntityObject[] */
protected $_objects = [];
/** @var bool */
protected $_isFilled = false;
/** @var bool */
protected $_isSinglePrimary;
/** @var array [SerializedPrimary => OBJECT_CHANGE_CODE] */
protected $_objectsChanges;
/** @var EntityObject[] */
protected $_objectsRemoved;
/** @var EntityObject[] Used for Iterator interface, allows to delete elements during foreach loop */
protected $_iterableObjects;
/** @var int Code for $objectsChanged */
const OBJECT_ADDED = 1;
/** @var int Code for $objectsChanged */
const OBJECT_REMOVED = 2;
/**
* Collection constructor.
*
* @param Entity $entity
*
* @throws ArgumentException
* @throws SystemException
*/
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;
}
/**
* @param EntityObject $object
*
* @throws ArgumentException
* @throws SystemException
*/
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]);
}
}
/**
* @param EntityObject $object
*
* @return bool
* @throws ArgumentException
* @throws SystemException
*/
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);
}
/**
* @param $primary
*
* @return bool
* @throws ArgumentException
*/
final public function hasByPrimary($primary)
{
$normalizedPrimary = $this->sysNormalizePrimary($primary);
return array_key_exists($this->sysSerializePrimaryKey($normalizedPrimary), $this->_objects);
}
/**
* @param $primary
*
* @return EntityObject
* @throws ArgumentException
*/
final public function getByPrimary($primary)
{
$normalizedPrimary = $this->sysNormalizePrimary($primary);
$serializePrimaryKey = $this->sysSerializePrimaryKey($normalizedPrimary);
if (isset($this->_objects[$serializePrimaryKey]))
{
return $this->_objects[$serializePrimaryKey];
}
return null;
}
/**
* @return EntityObject[]
*/
final public function getAll()
{
return array_values($this->_objects);
}
/**
* @param EntityObject $object
*
* @return void
* @throws ArgumentException
* @throws SystemException
*/
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);
}
/**
* @param $primary
*
* @throws ArgumentException
*/
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]);
}
}
/**
* Fills all the values and relations of object
*
* @param int|string[] $fields Names of fields to fill
*
* @return array|Collection
* @throws ArgumentException
* @throws SystemException
*/
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;
/** @var EntityObject[] $addObjects */
$addObjects = [];
/** @var EntityObject[] $updateObjects */
$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;
}
/**
* Constructs set of existing objects from pre-selected data, including references and relations.
*
* @param $rows
*
* @return array|static
* @throws ArgumentException
* @throws SystemException
*/
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;
}
/**
* Magic read-only properties
*
* @param $name
*
* @return array|Entity
* @throws SystemException
*/
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()
));
}
/**
* Magic read-only properties
*
* @param $name
* @param $value
*
* @throws SystemException
*/
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()
));
}
/**
* Magic to handle getters, setters etc.
*
* @param $name
* @param $arguments
*
* @return array
* @throws ArgumentException
* @throws SystemException
*/
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()
));
}
/**
* @internal For internal system usage only.
*
* @param \Bitrix\Main\ORM\Objectify\EntityObject $object
*
* @throws ArgumentException
* @throws SystemException
*/
public function sysAddActual(EntityObject $object)
{
$this->_objects[$this->sysGetPrimaryKey($object)] = $object;
}
/**
* Callback for object event when it gets primary
*
* @param $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]);
}
}
}
/**
* @internal For internal system usage only.
*
* @return bool
*/
public function sysIsFilled()
{
return $this->_isFilled;
}
/**
* @internal For internal system usage only.
*
* @return bool
*/
public function sysIsChanged()
{
return !empty($this->_objectsChanges);
}
/**
* @internal For internal system usage only.
*
* @return array
* @throws SystemException
*/
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;
}
/**
* @internal For internal system usage only.
*
* @param bool $rollback
*/
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 = [];
}
/**
* @param $fieldName
*
* @return array
* @throws SystemException
*/
protected function sysGetList($fieldName)
{
$values = [];
// collect field values
foreach ($this->_objects as $objectPrimary => $object)
{
$values[] = $object->sysGetValue($fieldName);
}
return $values;
}
/**
* @param $fieldName
*
* @return Collection
* @throws ArgumentException
* @throws SystemException
*/
protected function sysGetCollection($fieldName)
{
/** @var Relation $field */
$field = $this->_entity->getField($fieldName);
/** @var Collection $values */
$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;
}
/**
* @internal For internal system usage only.
*/
public function sysReviseDeletedObjects()
{
// clear from deleted objects
foreach ($this->_objects as $k => $object)
{
if ($object->state === State::DELETED)
{
unset($this->_objects[$k]);
}
}
}
/**
* @internal For internal system usage only.
*
* @param bool $value
*/
public function sysSetFilled($value = true)
{
$this->_isFilled = $value;
}
/**
* @internal For internal system usage only.
*
* @param $primary
*
* @return array
* @throws ArgumentException
*/
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)
{
/** @var ScalarField $field */
$field = $this->_entity->getField($primaryName);
$normalizedPrimary[$primaryName] = $field->cast($primary[$primaryName]);
}
return $normalizedPrimary;
}
/**
* @internal For internal system usage only.
*
* @param \Bitrix\Main\ORM\Objectify\EntityObject $object
*
* @return false|mixed|string
* @throws ArgumentException
* @throws SystemException
*/
protected function sysGetPrimaryKey(EntityObject $object)
{
if ($object->sysHasPrimary())
{
return $this->sysSerializePrimaryKey($object->primary);
}
else
{
return spl_object_hash($object);
}
}
/**
* @internal For internal system usage only.
*
* @param $primary
*
* @return false|mixed|string
* @throws ArgumentException
*/
protected function sysSerializePrimaryKey($primary)
{
if ($this->_isSinglePrimary)
{
return current($primary);
}
return Json::encode(array_values($primary));
}
/**
* ArrayAccess implementation
*
* @param mixed $offset
* @param mixed $value
*
* @throws ArgumentException
* @throws SystemException
*/
public function offsetSet($offset, $value): void
{
$this->add($value);
}
/**
* ArrayAccess implementation
*
* @param mixed $offset
*
* @return bool
* @throws NotImplementedException
*/
public function offsetExists($offset): bool
{
throw new NotImplementedException;
}
/**
* ArrayAccess implementation
*
* @param mixed $offset
*
* @throws NotImplementedException
*/
public function offsetUnset($offset): void
{
throw new NotImplementedException;
}
/**
* ArrayAccess implementation
*
* @param mixed $offset
*
* @return mixed|void
* @throws NotImplementedException
*/
#[\ReturnTypeWillChange]
public function offsetGet($offset)
{
throw new NotImplementedException;
}
/**
* Iterator implementation
*/
public function rewind(): void
{
$this->_iterableObjects = $this->_objects;
reset($this->_iterableObjects);
}
/**
* Iterator implementation
*
* @return EntityObject|mixed
*/
#[\ReturnTypeWillChange]
public function current()
{
if ($this->_iterableObjects === null)
{
$this->_iterableObjects = $this->_objects;
}
return current($this->_iterableObjects);
}
/**
* Iterator implementation
*
* @return mixed
*/
#[\ReturnTypeWillChange]
public function key()
{
return key($this->_iterableObjects);
}
/**
* Iterator implementation
*/
public function next(): void
{
next($this->_iterableObjects);
}
/**
* Iterator implementation
*
* @return bool
*/
public function valid(): bool
{
return key($this->_iterableObjects) !== null;
}
/**
* Countable implementation
*
* @return int
*/
public function count(): int
{
return count($this->_objects);
}
/**
* @throws SystemException
* @throws ArgumentException
*/
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;
}
}