TierPriceStorage.php

Go to the documentation of this file.

<?php
namespace Magento\Catalog\Model\Product\Price;

use Magento\Catalog\Api\Data\TierPriceInterface;

class TierPriceStorage implements \Magento\Catalog\Api\TierPriceStorageInterface
{
    private $tierPricePersistence;

    private $tierPriceValidator;

    private $tierPriceFactory;

    private $priceIndexer;

    private $productIdLocator;

    private $config;

    private $typeList;

    private $indexerChunkValue = 500;

    public function __construct(
        TierPricePersistence $tierPricePersistence,
        \Magento\Catalog\Model\Product\Price\Validation\TierPriceValidator $tierPriceValidator,
        TierPriceFactory $tierPriceFactory,
        \Magento\Catalog\Model\Indexer\Product\Price $priceIndexer,
        \Magento\Catalog\Model\ProductIdLocatorInterface $productIdLocator,
        \Magento\PageCache\Model\Config $config,
        \Magento\Framework\App\Cache\TypeListInterface $typeList
    ) {
        $this->tierPricePersistence = $tierPricePersistence;
        $this->tierPriceValidator = $tierPriceValidator;
        $this->tierPriceFactory = $tierPriceFactory;
        $this->priceIndexer = $priceIndexer;
        $this->productIdLocator = $productIdLocator;
        $this->config = $config;
        $this->typeList = $typeList;
    }

    public function get(array $skus)
    {
        $skus = $this->tierPriceValidator->validateSkus($skus);

        return $this->getExistingPrices($skus);
    }

    public function update(array $prices)
    {
        $affectedIds = $this->retrieveAffectedProductIdsForPrices($prices);
        $skus = array_unique(
            array_map(function ($price) {
                return $price->getSku();
            }, $prices)
        );
        $result = $this->tierPriceValidator->retrieveValidationResult($prices, $this->getExistingPrices($skus, true));
        $prices = $this->removeIncorrectPrices($prices, $result->getFailedRowIds());
        $formattedPrices = $this->retrieveFormattedPrices($prices);
        $this->tierPricePersistence->update($formattedPrices);
        $this->reindexPrices($affectedIds);
        $this->invalidateFullPageCache();

        return $result->getFailedItems();
    }

    public function replace(array $prices)
    {
        $result = $this->tierPriceValidator->retrieveValidationResult($prices);
        $prices = $this->removeIncorrectPrices($prices, $result->getFailedRowIds());
        $affectedIds = $this->retrieveAffectedProductIdsForPrices($prices);
        $formattedPrices = $this->retrieveFormattedPrices($prices);
        $this->tierPricePersistence->replace($formattedPrices, $affectedIds);
        $this->reindexPrices($affectedIds);
        $this->invalidateFullPageCache();

        return $result->getFailedItems();
    }

    public function delete(array $prices)
    {
        $affectedIds = $this->retrieveAffectedProductIdsForPrices($prices);
        $result = $this->tierPriceValidator->retrieveValidationResult($prices);
        $prices = $this->removeIncorrectPrices($prices, $result->getFailedRowIds());
        $priceIds = $this->retrieveAffectedPriceIds($prices);
        $this->tierPricePersistence->delete($priceIds);
        $this->reindexPrices($affectedIds);
        $this->invalidateFullPageCache();

        return $result->getFailedItems();
    }

    private function getExistingPrices(array $skus, $groupBySku = false)
    {
        $ids = $this->retrieveAffectedIds($skus);
        $rawPrices = $this->tierPricePersistence->get($ids);
        $prices = [];

        $linkField = $this->tierPricePersistence->getEntityLinkField();
        $skuByIdLookup = $this->buildSkuByIdLookup($skus);
        foreach ($rawPrices as $rawPrice) {
            $sku = $skuByIdLookup[$rawPrice[$linkField]];
            $price = $this->tierPriceFactory->create($rawPrice, $sku);
            if ($groupBySku) {
                $prices[$sku][] = $price;
            } else {
                $prices[] = $price;
            }
        }

        return $prices;
    }

    private function retrieveFormattedPrices(array $prices)
    {
        $formattedPrices = [];

        foreach ($prices as $price) {
            $idsBySku = $this->productIdLocator->retrieveProductIdsBySkus([$price->getSku()]);
            $ids = array_keys($idsBySku[$price->getSku()]);
            foreach ($ids as $id) {
                $formattedPrices[] = $this->tierPriceFactory->createSkeleton($price, $id);
            }
        }

        return $formattedPrices;
    }

    private function retrieveAffectedProductIdsForPrices(array $prices)
    {
        $skus = array_unique(
            array_map(function ($price) {
                return $price->getSku();
            }, $prices)
        );

        return $this->retrieveAffectedIds($skus);
    }

    private function retrieveAffectedIds(array $skus)
    {
        $affectedIds = [];

        foreach ($this->productIdLocator->retrieveProductIdsBySkus($skus) as $productId) {
            $affectedIds = array_merge($affectedIds, array_keys($productId));
        }

        return array_unique($affectedIds);
    }

    private function retrieveAffectedPriceIds(array $prices)
    {
        $affectedIds = $this->retrieveAffectedProductIdsForPrices($prices);
        $formattedPrices = $this->retrieveFormattedPrices($prices);
        $existingPrices = $this->tierPricePersistence->get($affectedIds);
        $priceIds = [];

        foreach ($formattedPrices as $price) {
            $priceIds[] = $this->retrievePriceId($price, $existingPrices);
        }

        return $priceIds;
    }

    private function retrievePriceId(array $price, array $existingPrices)
    {
        $linkField = $this->tierPricePersistence->getEntityLinkField();

        foreach ($existingPrices as $existingPrice) {
            if ($existingPrice['all_groups'] == $price['all_groups']
                && $existingPrice['customer_group_id'] == $price['customer_group_id']
                && $existingPrice['qty'] == $price['qty']
                && $this->isCorrectPriceValue($existingPrice, $price)
                && $existingPrice[$linkField] == $price[$linkField]
            ) {
                return $existingPrice['value_id'];
            }
        }

        return null;
    }

    private function isCorrectPriceValue(array $existingPrice, array $price)
    {
        return ($existingPrice['value'] != 0 && $existingPrice['value'] == $price['value'])
            || ($existingPrice['percentage_value'] !== null
                && $existingPrice['percentage_value'] == $price['percentage_value']);
    }

    private function buildSkuByIdLookup($skus)
    {
        $lookup = [];
        foreach ($this->productIdLocator->retrieveProductIdsBySkus($skus) as $sku => $ids) {
            foreach (array_keys($ids) as $id) {
                $lookup[$id] = $sku;
            }
        }

        return $lookup;
    }

    private function invalidateFullPageCache()
    {
        if ($this->config->isEnabled()) {
            $this->typeList->invalidate('full_page');
        }
    }

    private function reindexPrices(array $ids)
    {
        foreach (array_chunk($ids, $this->indexerChunkValue) as $affectedIds) {
            $this->priceIndexer->execute($affectedIds);
        }
    }

    private function removeIncorrectPrices(array $prices, array $ids)
    {
        foreach ($ids as $id) {
            unset($prices[$id]);
        }

        return $prices;
    }
}