commonelement.php

<?php
namespace Bitrix\Iblock\ORM;
 
use Bitrix\Iblock\ORM\Fields\PropertyOneToMany;
use Bitrix\Iblock\ORM\Fields\PropertyReference;
use Bitrix\Iblock\PropertyTable;
use Bitrix\Iblock\SectionTable;
use Bitrix\Main\ORM\Objectify\Collection;
use Bitrix\Main\ORM\Objectify\EntityObject;
use Bitrix\Main\ORM\Objectify\State;
use Bitrix\Main\Text\StringHelper;
 
abstract class CommonElement extends EO_CommonElement
{
    public function setIblockSectionId($iblockSectionId)
    {
        $newIblockSectionId = (int) $iblockSectionId;
        $actualIblockSectionId = 0;
 
        if ($this->state !== State::RAW)
        {
            $this->fill('IBLOCK_SECTION_ID');
            $actualIblockSectionId = $this->remindActual('IBLOCK_SECTION_ID');
        }
 
        if ($newIblockSectionId !== $actualIblockSectionId)
        {
            // remove old
            if ($actualIblockSectionId > 0)
            {
                $oldSection = SectionTable::wakeUpObject($actualIblockSectionId);
                $this->removeFrom('SECTIONS', $oldSection);
            }
 
            // add new
            if ($newIblockSectionId > 0)
            {
                $newSection = SectionTable::wakeUpObject($newIblockSectionId);
                $this->addTo('SECTIONS', $newSection);
            }
 
            // rewrite value
            parent::sysSetValue('IBLOCK_SECTION_ID', $newIblockSectionId);
        }
 
        return $this;
    }
 
    public function sysSetValue($fieldName, $value)
    {
        $field = $this->entity->getField($fieldName);
 
        if ($field instanceof PropertyReference)
        {
            // convert PropertyValue to regular reference
            $value = $this->sysConvertPropertyValue($value, $field);
 
            $currentValue = $this->get($fieldName);
 
            if (empty($currentValue))
            {
                parent::sysSetValue($fieldName, $value);
            }
            else
            {
                // set value directly
                $currentValue->set('VALUE', $value->get('VALUE'));
 
                if ($this->entity->hasField('DESCRIPTION') && $value->sysHasValue('DESCRIPTION'))
                {
                    $currentValue->set('DESCRIPTION', $value->get('DESCRIPTION'));
                }
            }
 
            // mark current object as changed, or else save() will be skipped
            if ($this->state === State::ACTUAL)
            {
                $this->sysChangeState(State::CHANGED);
            }
 
            return $this;
        }
 
        return parent::sysSetValue($fieldName, $value);
    }
 
    public function sysAddToCollection($fieldName, $remoteObject)
    {
        $fieldName = StringHelper::strtoupper($fieldName);
        $field = $this->entity->getField($fieldName);
 
        if ($field instanceof PropertyOneToMany)
        {
            // convert PropertyValue to regular relation object
            $remoteObject = $this->sysConvertPropertyValue($remoteObject, $field);
 
            // check for duplicates
            if (in_array(
                $field->getIblockElementProperty()->getPropertyType(),
                [PropertyTable::TYPE_STRING, PropertyTable::TYPE_NUMBER],
                true
            ))
            {
                // it's ok to have duplicates for this type
            }
            else
            {
                // check for duplicates and skip ot
                $collection = $this->get($fieldName);
 
                // we need filled collection to check value in it
                if (empty($collection) || !$collection->sysIsFilled())
                {
                    $collection = $this->fill($fieldName);
                }
 
                foreach ($collection as $refObject)
                {
                    // we have original scalar in VALUE
                    if ($refObject->get('VALUE') === $remoteObject->get('VALUE'))
                    {
                        // skip duplicate
                        return false;
                    }
                }
            }
        }
 
        return parent::sysAddToCollection($fieldName, $remoteObject);
    }
 
    public function sysRemoveFromCollection($fieldName, $remoteObject)
    {
        $fieldName = StringHelper::strtoupper($fieldName);
        $field = $this->entity->getField($fieldName);
 
        if ($field instanceof PropertyOneToMany)
        {
            // convert PropertyValue to regular relation object
            $valueObject = $this->sysConvertPropertyValue($remoteObject, $field);
 
            if ($valueObject->sysHasPrimary())
            {
                // existing object. nothing to do, just call parent remove
                $remoteObject = $valueObject;
            }
            else
            {
                // find relation object by value and remove it
                $collection = $this->get($fieldName);
 
                // we need filled collection to check value in it
                if (empty($collection) || !$collection->sysIsFilled())
                {
                    $collection = $this->fill($fieldName);
                }
 
                $foundValue = false;
 
                foreach ($collection as $refObject)
                {
                    // find original object with that value
                    if ($valueObject->get('VALUE') === $refObject->get('VALUE'))
                    {
                        $foundValue = true;
                        $remoteObject = $refObject;
                        break;
                    }
                }
 
                if (!$foundValue)
                {
                    // nothing to do, value was not found in collection
                    return false;
                }
            }
        }
 
        return parent::sysRemoveFromCollection($fieldName, $remoteObject);
    }
 
    public function sysSaveCurrentReferences()
    {
        return;
    }
 
    protected function sysConvertPropertyValue($value, $field)
    {
        $valueEntity = $field->getRefEntity();
        $valueObjectClass = $valueEntity->getObjectClass();
 
        if ($value instanceof $valueObjectClass)
        {
            // nothing to do
            return $value;
        }
 
        $valueObject = $valueEntity->createObject();
 
        // if we don't have primary right now, repeat setter later
        if ($this->state == State::RAW)
        {
            $this->sysAddOnPrimarySetListener(function (EntityObject $localObject) use ($valueObject) {
                $valueObject->set('IBLOCK_ELEMENT_ID', $localObject->get('ID'));
            });
        }
        else
        {
            // set base fields
            $valueObject->set('IBLOCK_ELEMENT_ID', $this->get('ID'));
        }
 
        if ($valueEntity->hasField('IBLOCK_PROPERTY_ID'))
        {
            $valueObject->set('IBLOCK_PROPERTY_ID', $field->getIblockElementProperty()->getId());
        }
 
        // set value fields
        if ($value instanceof PropertyValue)
        {
            $valueObject->set('VALUE', $value->getValue());
 
            if ($value->hasDescription())
            {
                $valueObject->set('DESCRIPTION', $value->getDescription());
            }
        }
        else
        {
            $valueObject->set('VALUE', $value);
        }
 
        return $valueObject;
    }
}