UpgradeWebsiteAttributes.php

Go to the documentation of this file.

<?php
namespace Magento\Catalog\Setup\Patch\Data;

use Magento\Catalog\Api\Data\CategoryInterface;
use Magento\Catalog\Api\Data\ProductInterface;
use Magento\Framework\DB\Query\Generator;
use Magento\Framework\EntityManager\MetadataPool;
use Magento\Framework\Exception\LocalizedException;
use Magento\Framework\Setup\ModuleDataSetupInterface;
use Magento\Framework\Setup\Patch\DataPatchInterface;
use Magento\Framework\Setup\Patch\PatchVersionInterface;

class UpgradeWebsiteAttributes implements DataPatchInterface, PatchVersionInterface
{
    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 $batchQueryGenerator;

    private $metaDataPool;

    private $linkFields = [];

    private $moduleDataSetup;

    public function __construct(
        Generator $batchQueryGenerator,
        MetadataPool $metadataPool,
        ModuleDataSetupInterface $moduleDataSetup
    ) {
        $this->batchQueryGenerator = $batchQueryGenerator;
        $this->metaDataPool = $metadataPool;
        $this->moduleDataSetup = $moduleDataSetup;
    }

    public function apply()
    {
        foreach (array_keys($this->tableMetaDataClass) as $tableName) {
            $this->upgradeTable($tableName);
        }
    }

    private function upgradeTable($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->isProcessedAttributeValue($attributeValueItem, $tableName)) {
                continue;
            }

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

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

    private function fetchAttributeValues($tableName)
    {
        //filter store groups which have more than 1 store
        $multipleStoresInWebsite = array_values(
            array_reduce(
                array_filter($this->getGroupedStoreViews(), function ($storeViews) {
                    return is_array($storeViews) && count($storeViews) > 1;
                }),
                'array_merge',
                []
            )
        );

        if (count($multipleStoresInWebsite) < 1) {
            return [];
        }

        $connection = $this->moduleDataSetup->getConnection();
        $batchSelectIterator = $this->batchQueryGenerator->generate(
            'value_id',
            $connection
                ->select()
                ->from(
                    ['cpei' => $this->moduleDataSetup->getTable($tableName)],
                    '*'
                )
                ->join(
                    [
                        'cea' => $this->moduleDataSetup->getTable('catalog_eav_attribute'),
                    ],
                    'cpei.attribute_id = cea.attribute_id',
                    ''
                )
                ->join(
                    [
                        'st' => $this->moduleDataSetup->getTable('store'),
                    ],
                    'st.store_id = cpei.store_id',
                    'st.website_id'
                )
                ->where(
                    'cea.is_global = ?',
                    self::ATTRIBUTE_WEBSITE
                )
                ->where(
                    'cpei.store_id IN (?)',
                    $multipleStoresInWebsite
                ),
            1000
        );

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

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

        $connection = $this->moduleDataSetup->getConnection();
        $query = $connection
            ->select()
            ->from(
                $this->moduleDataSetup->getTable('store'),
                '*'
            );

        $storeViews = $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 isProcessedAttributeValue(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->moduleDataSetup->getTable($tableName),
            $this->getTableLinkField($tableName),
            $this->prepareInsertValuesStatement($insertions)
        );

        $this->moduleDataSetup->getConnection()->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];
    }

    public static function getDependencies()
    {
        return [
            UpgradeWidgetData::class,
        ];
    }

    public static function getVersion()
    {
        return '2.2.2';
    }

    public function getAliases()
    {
        return [];
    }
}