vendor/shopware/core/Content/Product/DataAbstractionLayer/CheapestPrice/CheapestPriceContainer.php line 12

  1. <?php declare(strict_types=1);
  3. namespace Shopware\Core\Content\Product\DataAbstractionLayer\CheapestPrice;
  5. use Shopware\Core\Checkout\Cart\Price\Struct\CartPrice;
  6. use Shopware\Core\Defaults;
  7. use Shopware\Core\Framework\Context;
  8. use Shopware\Core\Framework\DataAbstractionLayer\Pricing\Price;
  9. use Shopware\Core\Framework\DataAbstractionLayer\Pricing\PriceCollection;
  10. use Shopware\Core\Framework\Log\Package;
  11. use Shopware\Core\Framework\Struct\Struct;
  13. #[Package('core')]
  14. class CheapestPriceContainer extends Struct
  15. {
  16.     /**
  17.      * @var array<mixed>
  18.      */
  19.     protected array $value;
  21.     /**
  22.      * @var array<mixed>|null
  23.      */
  24.     protected ?array $default = null;
  26.     /**
  27.      * @var list<string>|null
  28.      */
  29.     private ?array $ruleIds = null;
  31.     /**
  32.      * @param array<mixed> $value
  33.      */
  34.     public function __construct(array $value)
  35.     {
  36.         if (isset($value['default'])) {
  37.             $this->default = $value['default'];
  38.             unset($value['default']);
  39.         }
  41.         $this->value = $value;
  42.     }
  44.     public function resolve(Context $context): ?CheapestPrice
  45.     {
  46.         $ruleIds = $context->getRuleIds();
  47.         $ruleIds[] = 'default';
  49.         $prices = [];
  50.         $defaultWasAdded = false;
  51.         foreach ($this->value as $variantId => $group) {
  52.             foreach ($ruleIds as $ruleId) {
  53.                 $price = $this->filterByRuleId($group, $ruleId, $defaultWasAdded);
  55.                 if ($price === null) {
  56.                     continue;
  57.                 }
  59.                 // overwrite the variantId in case the default price was added
  60.                 $price['variant_id'] = $variantId;
  61.                 $prices[] = $price;
  63.                 break;
  64.             }
  65.         }
  67.         if (empty($prices)) {
  68.             return null;
  69.         }
  71.         $cheapest = array_shift($prices);
  73.         $reference = $this->getPriceValue($cheapest, $context);
  75.         $hasRange = (bool) $cheapest['is_ranged'];
  77.         // NEXT-21735 - This is covered randomly
  78.         // @codeCoverageIgnoreStart
  79.         foreach ($prices as $price) {
  80.             $current = $this->getPriceValue($price, $context);
  82.             if ($current === null) {
  83.                 continue;
  84.             }
  86.             if ($current !== $reference || $price['is_ranged']) {
  87.                 $hasRange = true;
  88.             }
  90.             if ($current < $reference) {
  91.                 $reference = $current;
  92.                 $cheapest = $price;
  93.             }
  94.         }
  95.         // @codeCoverageIgnoreEnd
  97.         $object = new CheapestPrice();
  98.         $object->setRuleId($cheapest['rule_id']);
  99.         $object->setVariantId($cheapest['variant_id']);
  100.         $object->setParentId($cheapest['parent_id']);
  101.         $object->setHasRange($hasRange);
  102.         $object->setPurchase($cheapest['purchase_unit'] ? (float) $cheapest['purchase_unit'] : null);
  103.         $object->setReference($cheapest['reference_unit'] ? (float) $cheapest['reference_unit'] : null);
  104.         $object->setUnitId($cheapest['unit_id'] ?? null);
  106.         $prices = [];
  108.         $blueprint = new Price('', 1, 1, true);
  110.         foreach ($cheapest['price'] as $row) {
  111.             $price = clone $blueprint;
  112.             $price->setCurrencyId($row['currencyId']);
  113.             $price->setGross((float) $row['gross']);
  114.             $price->setNet((float) $row['net']);
  115.             $price->setLinked((bool) $row['linked']);
  117.             if (isset($row['listPrice'])) {
  118.                 $list = clone $blueprint;
  120.                 $list->setCurrencyId($row['currencyId']);
  121.                 $list->setGross((float) $row['listPrice']['gross']);
  122.                 $list->setNet((float) $row['listPrice']['net']);
  123.                 $list->setLinked((bool) $row['listPrice']['linked']);
  125.                 $price->setListPrice($list);
  126.             }
  128.             if (isset($row['regulationPrice'])) {
  129.                 $regulation = clone $blueprint;
  131.                 $regulation->setCurrencyId($row['currencyId']);
  132.                 $regulation->setGross((float) $row['regulationPrice']['gross']);
  133.                 $regulation->setNet((float) $row['regulationPrice']['net']);
  134.                 $regulation->setLinked((bool) $row['regulationPrice']['linked']);
  136.                 $price->setRegulationPrice($regulation);
  137.             }
  139.             if (isset($row['percentage'])) {
  140.                 $price->setPercentage([
  141.                     'gross' => $row['percentage']['gross'],
  142.                     'net' => $row['percentage']['net'],
  143.                 ]);
  144.             }
  146.             $prices[] = $price;
  147.         }
  149.         $object->setPrice(new PriceCollection($prices));
  151.         return $object;
  152.     }
  154.     public function getApiAlias(): string
  155.     {
  156.         return 'cheapest_price_container';
  157.     }
  159.     /**
  160.      * @return array<mixed>
  161.      */
  162.     public function getValue(): array
  163.     {
  164.         return $this->value;
  165.     }
  167.     /**
  168.      * @return array<mixed>
  169.      */
  170.     public function getPricesForVariant(string $variantId): array
  171.     {
  172.         return $this->value[$variantId] ?? [];
  173.     }
  175.     /**
  176.      * @return array<string>
  177.      */
  178.     public function getVariantIds(): array
  179.     {
  180.         return \array_keys($this->value);
  181.     }
  183.     /**
  184.      * @return array<mixed>
  185.      */
  186.     public function getDefault(): ?array
  187.     {
  188.         return $this->default;
  189.     }
  191.     /**
  192.      * @return list<string>
  193.      */
  194.     public function getRuleIds(): array
  195.     {
  196.         if ($this->ruleIds === null) {
  197.             $ruleIds = [];
  199.             foreach ($this->value as $group) {
  200.                 foreach ($group as $price) {
  201.                     /** @var string|null $ruleId */
  202.                     $ruleId = $price['rule_id'] ?? null;
  203.                     if ($ruleId === null) {
  204.                         continue;
  205.                     }
  207.                     $ruleIds[$price['rule_id']] = true;
  208.                 }
  209.             }
  211.             /** @var list<string> $ruleIds */
  212.             $ruleIds = array_keys($ruleIds);
  213.             $this->ruleIds = $ruleIds;
  214.         }
  216.         return $this->ruleIds;
  217.     }
  219.     /**
  220.      * @param array<mixed> $prices
  221.      *
  222.      * @return array<mixed>|null
  223.      */
  224.     private function filterByRuleId(array $prices, string $ruleId, bool &$defaultWasAdded): ?array
  225.     {
  226.         if (\array_key_exists($ruleId, $prices)) {
  227.             // Null Price is the marker that the default price is inherited
  228.             if ($prices[$ruleId] === null && !$defaultWasAdded) {
  229.                 // Make sure to add the default price only once, to not bloat up the intermediate prices array
  230.                 $defaultWasAdded = true;
  232.                 return $this->default;
  233.             }
  235.             return $prices[$ruleId];
  236.         }
  238.         return null;
  239.     }
  241.     /**
  242.      * @param array<mixed> $price
  243.      */
  244.     private function getPriceValue(array $price, Context $context): ?float
  245.     {
  246.         $currency = $this->getCurrencyPrice($price['price'], $context->getCurrencyId());
  248.         if (!$currency) {
  249.             return null;
  250.         }
  252.         $value = $context->getTaxState() === CartPrice::TAX_STATE_GROSS ? $currency['gross'] : $currency['net'];
  254.         if ($currency['currencyId'] !== $context->getCurrencyId()) {
  255.             $value *= $context->getCurrencyFactor();
  256.         }
  258.         return $value;
  259.     }
  261.     /**
  262.      * @param array<mixed> $collection
  263.      *
  264.      * @return array<mixed>|null
  265.      */
  266.     private function getCurrencyPrice(array $collection, string $currencyId, bool $fallback = true): ?array
  267.     {
  268.         foreach ($collection as $price) {
  269.             if ($price['currencyId'] === $currencyId) {
  270.                 return $price;
  271.             }
  272.         }
  274.         if (!$fallback) {
  275.             return null;
  276.         }
  278.         return $this->getCurrencyPrice($collection, Defaults::CURRENCY, false);
  279.     }
  280. }