UpdateHandler.php

Go to the documentation of this file.

<?php
namespace Magento\Eav\Model\ResourceModel;

use Magento\Framework\App\ObjectManager;
use Magento\Framework\EntityManager\MetadataPool;
use Magento\Eav\Api\AttributeRepositoryInterface as AttributeRepository;
use Magento\Framework\Api\SearchCriteriaBuilder;
use Magento\Framework\Model\Entity\ScopeResolver;
use Magento\Framework\EntityManager\Operation\AttributeInterface;

class UpdateHandler implements AttributeInterface
{
    private $attributeRepository;

    private $metadataPool;

    private $searchCriteriaBuilder;

    private $attributePersistor;

    private $readSnapshot;

    private $scopeResolver;

    private $readHandler;

    private $attributeLoader;

    public function __construct(
        AttributeRepository $attributeRepository,
        MetadataPool $metadataPool,
        SearchCriteriaBuilder $searchCriteriaBuilder,
        AttributePersistor $attributePersistor,
        ReadSnapshot $readSnapshot,
        ScopeResolver $scopeResolver,
        AttributeLoader $attributeLoader = null
    ) {
        $this->attributeRepository = $attributeRepository;
        $this->metadataPool = $metadataPool;
        $this->searchCriteriaBuilder = $searchCriteriaBuilder;
        $this->attributePersistor = $attributePersistor;
        $this->readSnapshot = $readSnapshot;
        $this->scopeResolver = $scopeResolver;
        $this->attributeLoader = $attributeLoader ?: ObjectManager::getInstance()->get(AttributeLoader::class);
    }

    protected function getAttributes($entityType, $attributeSetId = null)
    {
        return $this->attributeLoader->getAttributes($entityType, $attributeSetId);
    }

    public function execute($entityType, $entityData, $arguments = [])
    {
        $metadata = $this->metadataPool->getMetadata($entityType);
        if ($metadata->getEavEntityType()) {
            $context = $this->scopeResolver->getEntityContext($entityType, $entityData);
            $entityDataForSnapshot = [$metadata->getLinkField() => $entityData[$metadata->getLinkField()]];
            foreach ($context as $scope) {
                if (isset($entityData[$scope->getIdentifier()])) {
                    $entityDataForSnapshot[$scope->getIdentifier()] = $entityData[$scope->getIdentifier()];
                }
            }
            $attributeSetId = isset($entityData[AttributeLoader::ATTRIBUTE_SET_ID])
                ? $entityData[AttributeLoader::ATTRIBUTE_SET_ID]
                : null; // @todo verify is it normal to not have attribute_set_id
            if (!isset($entityDataForSnapshot['attribute_set_id'])) {
                $entityDataForSnapshot['attribute_set_id'] = $attributeSetId;
            }
            $snapshot = $this->readSnapshot->execute($entityType, $entityDataForSnapshot);
            foreach ($this->getAttributes($entityType, $attributeSetId) as $attribute) {
                $code = $attribute->getAttributeCode();
                $isAllowedValueType = array_key_exists($code, $entityData)
                    && (is_scalar($entityData[$code]) || $entityData[$code] === null);

                if ($attribute->isStatic() || !$isAllowedValueType) {
                    continue;
                }

                $newValue = $entityData[$code];
                $isValueEmpty = $attribute->isValueEmpty($newValue);
                $isAllowedEmptyStringValue = $attribute->isAllowedEmptyTextValue($newValue);

                if (array_key_exists($code, $snapshot)) {
                    $snapshotValue = $snapshot[$code];
                    if ($snapshotValue === false) {
                        continue;
                    }

                    if (!$isValueEmpty || $isAllowedEmptyStringValue) {
                        if ($snapshotValue === $newValue) {
                            continue;
                        }

                        $this->attributePersistor->registerUpdate(
                            $entityType,
                            $entityData[$metadata->getLinkField()],
                            $code,
                            $newValue
                        );
                    } else {
                        $this->attributePersistor->registerDelete(
                            $entityType,
                            $entityData[$metadata->getLinkField()],
                            $code
                        );
                    }
                } else {
                    if (!$isValueEmpty || $isAllowedEmptyStringValue) {
                        $this->attributePersistor->registerInsert(
                            $entityType,
                            $entityData[$metadata->getLinkField()],
                            $code,
                            $newValue
                        );
                    }
                }
            }
            $this->attributePersistor->flush($entityType, $context);
        }

        return $this->getReadHandler()->execute($entityType, $entityData, $arguments);
    }

    protected function getReadHandler()
    {
        if (!$this->readHandler) {
            $this->readHandler = ObjectManager::getInstance()->get(ReadHandler::class);
        }

        return $this->readHandler;
    }
}