PropertyRepository.php

См. документацию.

<?php
 
namespace Bitrix\Catalog\v2\Property;
 
use Bitrix\Catalog\v2\BaseEntity;
use Bitrix\Catalog\v2\BaseIblockElementEntity;
use Bitrix\Catalog\v2\PropertyValue\PropertyValueFactory;
use Bitrix\Catalog\v2\Section\HasSectionCollection;
use Bitrix\Iblock\PropertyEnumerationTable;
use Bitrix\Iblock\PropertyTable;
use Bitrix\Main\Entity\ReferenceField;
use Bitrix\Main\Error;
use Bitrix\Main\Result;
use Bitrix\Main\Type\Collection;

class PropertyRepository implements PropertyRepositoryContract
{
    protected PropertyFactory $factory;
    private PropertyValueFactory $propertyValueFactory;
 
    private array $propertyWithoutLink = [];
 
    public function __construct(PropertyFactory $factory, PropertyValueFactory $propertyValueFactory)
    {
        $this->factory = $factory;
        $this->propertyValueFactory = $propertyValueFactory;
    }
 
    public function getEntityById(int $id): ?BaseEntity
    {
        if ($id <= 0)
        {
            throw new \OutOfRangeException($id);
        }
 
        $entities = $this->getEntitiesBy([
            'filter' => [
                '=ID' => $id,
            ],
        ]);
 
        return reset($entities) ?: null;
    }
 
    public function getEntitiesBy($params, array $propertySettings = []): array
    {
        $entities = [];
 
        $sortedSettings = [];
        foreach ($propertySettings as $setting)
        {
            if ((int)$setting['ID'] > 0)
            {
                $sortedSettings[(int)$setting['ID']] = $setting;
            }
        }
 
        foreach ($this->getList((array)$params) as $elementId => $properties)
        {
            if (!is_array($properties))
            {
                continue;
            }
 
            foreach ($properties as $propertyId => $item)
            {
                $settings = [];
                if (isset($sortedSettings[$propertyId]))
                {
                    $settings = $sortedSettings[$propertyId];
                    $settings['IBLOCK_ELEMENT_ID'] = $elementId;
                }
                $entities[] = $this->createEntity($item, $settings);
            }
        }
 
        return $entities;
    }
 
    public function save(BaseEntity ...$entities): Result
    {
        $result = new Result();

        $parentEntity = null;
        $props = [];

        foreach ($entities as $property)
        {
            if ($parentEntity && $parentEntity !== $property->getParent())
            {
                $result->addError(new Error('Saving should only be done with properties of a common parent.'));
            }
 
            if ($parentEntity === null)
            {
                $parentEntity = $property->getParent();
            }
 
            $valueCollection = $property->getPropertyValueCollection();
 
            $props[$property->getId()] = $valueCollection->toArray();
 
            if ($property->getPropertyType() === PropertyTable::TYPE_FILE)
            {
                foreach ($props[$property->getId()] as $id => $prop)
                {
                    if (is_numeric($id))
                    {
                        $props[$property->getId()][$id] = \CIBlock::makeFilePropArray(
                            $prop,
                            $prop['VALUE'] === '',
                            $prop['DESCRIPTION'],
                            ['allow_file_id' => true]
                        );
                    }
                }
 
                foreach ($valueCollection->getRemovedItems() as $removed)
                {
                    if ($removed->isNew())
                    {
                        continue;
                    }
 
                    $fieldsToDelete = \CIBlock::makeFilePropArray($removed->getFields(), true);
                    $props[$property->getId()][$removed->getId()] = $fieldsToDelete;
                }
            }
        }
 
        if (!$parentEntity)
        {
            $result->addError(new Error('Parent entity not found while saving properties.'));
        }
 
        if (!($parentEntity instanceof BaseIblockElementEntity))
        {
            $result->addError(new Error(sprintf(
                'Parent entity of property must be an instance of {%s}.',
                BaseIblockElementEntity::class
            )));
        }
 
        if (!empty($props) && $result->isSuccess())
        {
            $elementId = $parentEntity->getId();
            $element = new \CIBlockElement();
            $res = $element->update(
                $elementId,
                [
                    'PROPERTY_VALUES' => $props,
                ]
            );
            if (!$res)
            {
                $result->addError(new Error($element->getLastError()));
            }
            else
            {
                $ipropValues = new \Bitrix\Iblock\InheritedProperty\ElementValues(
                    \CIBlockElement::GetIBlockByID($elementId),
                    $elementId
                );
                $ipropValues->clearValues();
                unset($ipropValues);
            }
        }
 
        return $result;
    }
 
    public function delete(BaseEntity ...$entities): Result
    {
        return new Result();
    }
 
    private function getPropertyIteratorForEntity(BaseIblockElementEntity $entity, array $params = []): \Generator
    {
        $disabledPropertyIds = $params['filter']['!PROPERTY_ID'] ?? [];
        unset($params['filter']['!PROPERTY_ID']);
 
        if ($entity->isNew())
        {
            $entityFields = [];
        }
        else
        {
            $params['filter']['IBLOCK_ID'] = $entity->getIblockId();
            $params['filter']['ID'] = $entity->getId();
            $result = $this->getList($params);
            $entityFields = $result[$entity->getId()] ?? [];
        }
 
        yield from $this->loadCollection($entityFields, $entity, $disabledPropertyIds);
    }
 
    public function getCollectionByParent(BaseIblockElementEntity $entity): PropertyCollection
    {
        $callback = function (array $params) use ($entity) {
            yield from $this->getPropertyIteratorForEntity($entity, $params);
        };
 
        return
            $this->factory
                ->createCollection()
                ->setIteratorCallback($callback)
        ;
    }
 
    protected function getList(array $params): array
    {
        $result = [];
 
        $filter = $params['filter'] ?? [];
        $propertyFilter = [];
 
        if (isset($filter['PROPERTY_ID']))
        {
            $propertyFilter['ID'] = $filter['PROPERTY_ID'];
            unset($filter['PROPERTY_ID']);
        }
        if (isset($filter['PROPERTY_CODE']))
        {
            $propertyFilter['ID'] = $this->getPropertyIdByCode($filter['IBLOCK_ID'], $filter['PROPERTY_CODE']);
            if (!$propertyFilter['ID'])
            {
                return [];
            }
            unset($filter['PROPERTY_CODE']);
        }
 
        $propertyValuesIterator = \CIBlockElement::getPropertyValues($filter['IBLOCK_ID'], $filter, true, $propertyFilter);
        while ($propertyValues = $propertyValuesIterator->fetch())
        {
            $descriptions = $propertyValues['DESCRIPTION'] ?? [];
            $propertyValueIds = $propertyValues['PROPERTY_VALUE_ID'] ?? [];
            $elementId = $propertyValues['IBLOCK_ELEMENT_ID'];
            unset($propertyValues['IBLOCK_ELEMENT_ID'], $propertyValues['PROPERTY_VALUE_ID'], $propertyValues['DESCRIPTION']);
 
            $entityFields = [];
            // ToDo empty properties with false (?: '') or null?
            foreach ($propertyValues as $id => $value)
            {
                $entityFields[$id] = [];
                $description = $descriptions[$id] ?? null;
 
                if ($value !== false || $description !== null)
                {
                    if (is_array($value))
                    {
                        foreach ($value as $key => $item)
                        {
                            $fields = [
                                'VALUE' => $item ?? '',
                                'DESCRIPTION' => empty($description[$key]) ? null : $description[$key],
                            ];
 
                            if (isset($propertyValueIds[$id][$key]))
                            {
                                $fields['ID'] = $propertyValueIds[$id][$key];
                            }
 
                            $entityFields[$id][$key] = $fields;
                        }
                    }
                    else
                    {
                        $fields = [
                            'VALUE' => $value ?? '',
                            'DESCRIPTION' => empty($descriptions[$id]) ? null : $descriptions[$id],
                        ];
 
                        if (isset($propertyValueIds[$id]))
                        {
                            $fields['ID'] = $propertyValueIds[$id];
                        }
 
                        $entityFields[$id][] = $fields;
                    }
                }
            }
 
            $result[$elementId] = $entityFields;
        }
 
        return $result;
    }
 
    private function getPropertyIdByCode(int $iblockId, string $code): ?int
    {
        $propertyData = \Bitrix\Iblock\PropertyTable::getRow([
            'select' => ['ID'],
            'filter' => [
                '=CODE' => $code,
                '=IBLOCK_ID' => $iblockId,
            ],
            'cache' => [
                'ttl' => 86400,
            ],
        ]);
 
        return isset($propertyData['ID']) ? (int)$propertyData['ID'] : null;
    }
 
    public function createCollection(): PropertyCollection
    {
        return $this->factory->createCollection();
    }
 
    protected function loadCollection(array $entityFields, BaseIblockElementEntity $parent, array $disabledPropertyIds): \Generator
    {
        $propertySettings = [];
 
        if ($parent instanceof HasSectionCollection)
        {
            $linkedPropertyIds = $this->getLinkedPropertyIds($parent->getIblockId(), $parent);
            if (!empty($linkedPropertyIds))
            {
                $linkedPropertyIds = array_diff($linkedPropertyIds, $disabledPropertyIds);
                if (!empty($linkedPropertyIds))
                {
                    $propertySettings = $this->getPropertiesSettingsByFilter([
                        '@ID' => $linkedPropertyIds,
                    ]);
                }
            }
        }
        else
        {
            // variation properties don't use any section links right now
            $propertySettings = $this->getPropertiesSettingsByFilter([
                '=IBLOCK_ID' => $parent->getIblockId(),
                '!ID' => $disabledPropertyIds,
            ]);
        }
 
        foreach ($propertySettings as $settings)
        {
            $fields = $entityFields[$settings['ID']] ?? [];
            $settings['IBLOCK_ELEMENT_ID'] = $parent->getId();
 
            yield $this->createEntity($fields, $settings);
        }
    }
 
    protected function getLinkedPropertyIds(int $iblockId, HasSectionCollection $parent): array
    {
        $linkedPropertyIds = [$this->loadPropertyIdsWithoutAnyLink($iblockId)];
 
        if ($parent->getSectionCollection()->isEmpty())
        {
            $linkedPropertyIds[] = array_keys(\CIBlockSectionPropertyLink::getArray($iblockId));
        }

        foreach ($parent->getSectionCollection() as $section)
        {
            $linkedPropertyIds[] = array_keys(\CIBlockSectionPropertyLink::getArray($iblockId, $section->getValue()));
        }
 
        if (!empty($linkedPropertyIds))
        {
            $linkedPropertyIds = array_merge(...$linkedPropertyIds);
            Collection::normalizeArrayValuesByInt($linkedPropertyIds, false);
            $linkedPropertyIds = array_unique($linkedPropertyIds);
        }
 
        return $linkedPropertyIds;
    }
 
    private function loadPropertyIdsWithoutAnyLink(int $iblockId): array
    {
        if (!isset($this->propertyWithoutLink[$iblockId]))
        {
            $this->propertyWithoutLink[$iblockId] = [];
            $iterator = PropertyTable::getList([
                'select' => ['ID'],
                'filter' => [
                    '=IBLOCK_ID' => $iblockId,
                    '==SECTION_LINK.SECTION_ID' => null,
                ],
                'runtime' => [
                    new ReferenceField(
                        'SECTION_LINK',
                        '\Bitrix\Iblock\SectionPropertyTable',
                        [
                            '=this.ID' => 'ref.PROPERTY_ID',
                            '=this.IBLOCK_ID' => 'ref.IBLOCK_ID',
                        ],
                        ['join_type' => 'LEFT']
                    ),
                ],
            ]);
            while ($row = $iterator->fetch())
            {
                $this->propertyWithoutLink[$iblockId][] = (int)$row['ID'];
            }
            unset($row, $iterator);
        }
 
        return $this->propertyWithoutLink[$iblockId];
    }
 
    public function getPropertiesSettingsByFilter(array $filter): array
    {
        $settings = PropertyTable::getList([
            'select' => ['*'],
            'filter' => $filter,
            'order' => [
                'SORT' => 'ASC',
                'ID' => 'ASC',
            ],
        ])
            ->fetchAll()
            ;
 
        return $this->loadEnumSettings($settings);
    }
 
    protected function prepareField(array $fields, array $settings): array
    {
        foreach ($fields as &$field)
        {
            if (!empty($settings['USER_TYPE']))
            {
                $userType = \CIBlockProperty::GetUserType($settings['USER_TYPE']);
 
                if (isset($userType['ConvertFromDB']))
                {
                    $field = call_user_func($userType['ConvertFromDB'], $settings, $field);
                }
            }
        }
 
        return $fields;
    }
 
    protected function prepareSettings(array $settings): array
    {
        if (isset($settings['USER_TYPE_SETTINGS_LIST']))
        {
            $settings['USER_TYPE_SETTINGS'] = $settings['USER_TYPE_SETTINGS_LIST'];
            unset($settings['USER_TYPE_SETTINGS_LIST']);
        }
 
        return $settings;
    }
 
    public function createEntity(array $fields = [], array $settings = []): Property
    {
        $entity = $this->factory->createEntity();
 
        if ($settings)
        {
            $settings = $this->prepareSettings($settings);
            $fields = $this->prepareField($fields, $settings);
            $entity->setSettings($settings);
        }
 
        $propertyValueCollection = $this->propertyValueFactory->createCollection();
        $propertyValueCollection->initValues($fields);
 
        $entity->setPropertyValueCollection($propertyValueCollection);
 
        return $entity;
    }
 
    private function loadEnumSettings(array $settings): array
    {
        if (empty($settings))
        {
            return $settings;
        }
 
        $enumIds = [];
        foreach ($settings as $setting)
        {
            if ($setting['PROPERTY_TYPE'] === PropertyTable::TYPE_LIST)
            {
                $enumIds[] = $setting['ID'];
            }
        }
        if (empty($enumIds))
        {
            return $settings;
        }
 
        $enumSettings = PropertyEnumerationTable::getList([
            'select' => [
                'ID',
                'PROPERTY_ID',
            ],
            'filter' => [
                '@PROPERTY_ID' => $enumIds,
                '=DEF' => 'Y',
            ],
        ])
            ->fetchAll()
        ;
        $enumSettings = array_column($enumSettings, 'ID', 'PROPERTY_ID');
 
        if (!empty($enumSettings))
        {
            foreach ($settings as &$setting)
            {
                if (isset($enumSettings[$setting['ID']]))
                {
                    $setting['DEFAULT_VALUE'] = $enumSettings[$setting['ID']];
                }
            }
        }
 
        return $settings;
    }
}