WebsiteAttributesSynchronizer.php

Go to the documentation of this file.

<?php
namespace Magento\Catalog\Model\ResourceModel\Attribute;

use Magento\Catalog\Api\Data\CategoryInterface;
use Magento\Catalog\Api\Data\ProductInterface;
use Magento\Framework\App\ResourceConnection;
use Magento\Framework\DB\Adapter\AdapterInterface;
use Magento\Framework\DB\Query\Generator;
use Magento\Framework\EntityManager\MetadataPool;
use Magento\Framework\Exception\LocalizedException;
use Magento\Framework\FlagManager;

class WebsiteAttributesSynchronizer
{
    const FLAG_SYNCHRONIZED = 0;
    const FLAG_SYNCHRONIZATION_IN_PROGRESS = 1;
    const FLAG_REQUIRES_SYNCHRONIZATION = 2;
    const FLAG_NAME = 'catalog_website_attribute_is_sync_required';

    const ATTRIBUTE_WEBSITE = 2;
    const GLOBAL_STORE_VIEW_ID = 0;

    const MASK_ATTRIBUTE_VALUE = '%d_%d_%d';

    private $tableMetaDataClass = [
        'catalog_category_entity_datetime' => CategoryInterface::class,
        'catalog_category_entity_decimal' => CategoryInterface::class,
        'catalog_category_entity_int' => CategoryInterface::class,
        'catalog_category_entity_text' => CategoryInterface::class,
        'catalog_category_entity_varchar' => CategoryInterface::class,

        'catalog_product_entity_datetime' => ProductInterface::class,
        'catalog_product_entity_decimal' => ProductInterface::class,
        'catalog_product_entity_int' => ProductInterface::class,
        'catalog_product_entity_text' => ProductInterface::class,
        'catalog_product_entity_varchar' => ProductInterface::class,
    ];

    private $groupedStoreViews = [];

    private $processedAttributeValues = [];

    private $resourceConnection;

    private $connection;

    private $flagManager;

    private $batchQueryGenerator;

    private $metaDataPool;

    private $linkFields = [];

    public function __construct(
        ResourceConnection $resourceConnection,
        FlagManager $flagManager,
        Generator $batchQueryGenerator,
        MetadataPool $metadataPool
    ) {
        $this->resourceConnection = $resourceConnection;
        $this->connection = $this->resourceConnection->getConnection();
        $this->flagManager = $flagManager;
        $this->batchQueryGenerator = $batchQueryGenerator;
        $this->metaDataPool = $metadataPool;
    }

    public function synchronize()
    {
        $this->markSynchronizationInProgress();
        $this->connection->beginTransaction();
        try {
            foreach (array_keys($this->tableMetaDataClass) as $tableName) {
                $this->synchronizeTable($tableName);
            }

            $this->markSynchronized();
            $this->connection->commit();
        } catch (\Exception $exception) {
            $this->connection->rollBack();
            $this->scheduleSynchronization();
            throw $exception;
        }
    }

    public function isSynchronizationRequired()
    {
        return self::FLAG_REQUIRES_SYNCHRONIZATION === $this->flagManager->getFlagData(self::FLAG_NAME);
    }

    public function scheduleSynchronization()
    {
        $this->flagManager->saveFlag(self::FLAG_NAME, self::FLAG_REQUIRES_SYNCHRONIZATION);
    }

    private function markSynchronizationInProgress()
    {
        $this->flagManager->saveFlag(self::FLAG_NAME, self::FLAG_SYNCHRONIZATION_IN_PROGRESS);
    }

    private function markSynchronized()
    {
        $this->flagManager->saveFlag(self::FLAG_NAME, self::FLAG_SYNCHRONIZED);
    }

    private function synchronizeTable($tableName)
    {
        foreach ($this->fetchAttributeValues($tableName) as $attributeValueItems) {
            $this->processAttributeValues($attributeValueItems, $tableName);
        }
    }

    private function processAttributeValues(array $attributeValueItems, $tableName)
    {
        $this->resetProcessedAttributeValues();

        foreach ($attributeValueItems as $attributeValueItem) {
            if ($this->isAttributeValueProcessed($attributeValueItem, $tableName)) {
                continue;
            }

            $insertions = $this->generateAttributeValueInsertions($attributeValueItem, $tableName);
            if (!empty($insertions)) {
                $this->executeInsertions($insertions, $tableName);
            }

            $this->markAttributeValueProcessed($attributeValueItem, $tableName);
        }
    }

    private function fetchAttributeValues($tableName)
    {
        $batchSelectIterator = $this->batchQueryGenerator->generate(
            'value_id',
            $this->connection
                ->select()
                ->from(
                    ['cpei' => $this->resourceConnection->getTableName($tableName)],
                    '*'
                )
                ->join(
                    [
                        'cea' => $this->resourceConnection->getTableName('catalog_eav_attribute'),
                    ],
                    'cpei.attribute_id = cea.attribute_id',
                    ''
                )
                ->join(
                    [
                        'st' => $this->resourceConnection->getTableName('store'),
                    ],
                    'st.store_id = cpei.store_id',
                    'st.website_id'
                )
                ->where(
                    'cea.is_global = ?',
                    self::ATTRIBUTE_WEBSITE
                )
                ->where(
                    'cpei.store_id <> ?',
                    self::GLOBAL_STORE_VIEW_ID
                )
        );

        foreach ($batchSelectIterator as $select) {
            yield $this->connection->fetchAll($select);
        }
    }

    private function getGroupedStoreViews()
    {
        if (!empty($this->groupedStoreViews)) {
            return $this->groupedStoreViews;
        }

        $query = $this->connection
            ->select()
            ->from(
                $this->resourceConnection->getTableName('store'),
                '*'
            );

        $storeViews = $this->connection->fetchAll($query);

        $this->groupedStoreViews = [];

        foreach ($storeViews as $storeView) {
            if ($storeView['store_id'] != 0) {
                $this->groupedStoreViews[$storeView['website_id']][] = $storeView['store_id'];
            }
        }

        return $this->groupedStoreViews;
    }

    private function isAttributeValueProcessed(array $attributeValue, $tableName)
    {
        return in_array(
            $this->getAttributeValueKey(
                $attributeValue[$this->getTableLinkField($tableName)],
                $attributeValue['attribute_id'],
                $attributeValue['website_id']
            ),
            $this->processedAttributeValues
        );
    }

    private function resetProcessedAttributeValues()
    {
        $this->processedAttributeValues = [];
    }

    private function markAttributeValueProcessed(array $attributeValue, $tableName)
    {
        $this->processedAttributeValues[] = $this->getAttributeValueKey(
            $attributeValue[$this->getTableLinkField($tableName)],
            $attributeValue['attribute_id'],
            $attributeValue['website_id']
        );
    }

    private function getAttributeValueKey($entityId, $attributeId, $websiteId)
    {
        return sprintf(
            self::MASK_ATTRIBUTE_VALUE,
            $entityId,
            $attributeId,
            $websiteId
        );
    }

    private function generateAttributeValueInsertions(array $attributeValue, $tableName)
    {
        $groupedStoreViews = $this->getGroupedStoreViews();
        if (empty($groupedStoreViews[$attributeValue['website_id']])) {
            return null;
        }

        $currentStoreViewIds = $groupedStoreViews[$attributeValue['website_id']];
        $insertions = [];

        foreach ($currentStoreViewIds as $index => $storeViewId) {
            $insertions[] = [
                ':attribute_id' . $index => $attributeValue['attribute_id'],
                ':store_id' . $index => $storeViewId,
                ':entity_id' . $index => $attributeValue[$this->getTableLinkField($tableName)],
                ':value' . $index => $attributeValue['value'],
            ];
        }

        return $insertions;
    }

    private function executeInsertions(array $insertions, $tableName)
    {
        $rawQuery = sprintf(
            'INSERT INTO 
            %s(attribute_id, store_id, %s, `value`)
            VALUES 
            %s
            ON duplicate KEY UPDATE `value` = VALUES(`value`)',
            $this->resourceConnection->getTableName($tableName),
            $this->getTableLinkField($tableName),
            $this->prepareInsertValuesStatement($insertions)
        );

        $this->connection->query($rawQuery, $this->getPlaceholderValues($insertions));
    }

    private function getPlaceholderValues(array $insertions)
    {
        $placeholderValues = [];
        foreach ($insertions as $insertion) {
            $placeholderValues = array_merge(
                $placeholderValues,
                $insertion
            );
        }

        return $placeholderValues;
    }

    private function prepareInsertValuesStatement(array $insertions)
    {
        $statement = '';

        foreach ($insertions as $insertion) {
            $statement .= sprintf('(%s),', implode(',', array_keys($insertion)));
        }

        return rtrim($statement, ',');
    }

    private function getTableLinkField($tableName)
    {
        if (!isset($this->tableMetaDataClass[$tableName])) {
            throw new LocalizedException(
                sprintf(
                    'Specified table: %s is not defined in tables list',
                    $tableName
                )
            );
        }

        if (!isset($this->linkFields[$tableName])) {
            $this->linkFields[$tableName] = $this->metaDataPool
                ->getMetadata($this->tableMetaDataClass[$tableName])
                ->getLinkField();
        }

        return $this->linkFields[$tableName];
    }
}