vendor/shopware/core/Checkout/Cart/LineItem/Group/LineItemGroupBuilder.php line 15

Open in your IDE?
  1. <?php declare(strict_types=1);
  3. namespace Shopware\Core\Checkout\Cart\LineItem\Group;
  5. use Shopware\Core\Checkout\Cart\Cart;
  6. use Shopware\Core\Checkout\Cart\Exception\InvalidQuantityException;
  7. use Shopware\Core\Checkout\Cart\Exception\LineItemNotStackableException;
  8. use Shopware\Core\Checkout\Cart\LineItem\LineItemCollection;
  9. use Shopware\Core\Checkout\Cart\LineItem\LineItemFlatCollection;
  10. use Shopware\Core\Checkout\Cart\LineItem\LineItemQuantitySplitter;
  11. use Shopware\Core\Framework\Log\Package;
  12. use Shopware\Core\System\SalesChannel\SalesChannelContext;
  14. #[Package('checkout')]
  15. class LineItemGroupBuilder
  16. {
  17.     private LineItemGroupServiceRegistry $registry;
  19.     private LineItemGroupRuleMatcherInterface $ruleMatcher;
  21.     private LineItemQuantitySplitter $quantitySplitter;
  23.     private AbstractProductLineItemProvider $lineItemProvider;
  25.     /**
  26.      * @internal
  27.      */
  28.     public function __construct(
  29.         LineItemGroupServiceRegistry $registry,
  30.         LineItemGroupRuleMatcherInterface $ruleMatcher,
  31.         LineItemQuantitySplitter $lineItemQuantitySplitter,
  32.         AbstractProductLineItemProvider $lineItemProvider
  33.     ) {
  34.         $this->registry = $registry;
  35.         $this->ruleMatcher = $ruleMatcher;
  36.         $this->quantitySplitter = $lineItemQuantitySplitter;
  37.         $this->lineItemProvider = $lineItemProvider;
  38.     }
  40.     /**
  41.      * Searches for all packages that can be built from the provided list of groups.
  42.      * Every line item will be taken from the cart and only the ones that are left will
  43.      * be checked for upcoming groups.
  44.      *
  45.      * @param LineItemGroupDefinition[] $groupDefinitions
  46.      */
  47.     public function findGroupPackages(array $groupDefinitions, Cart $cart, SalesChannelContext $context): LineItemGroupBuilderResult
  48.     {
  49.         $result = new LineItemGroupBuilderResult();
  51.         // filter out all promotion items
  52.         $cartProducts = $this->lineItemProvider->getProducts($cart);
  54.         // split quantities into separate line items
  55.         // so we have a real list of products like we would have
  56.         // them when holding it in our actual hands.
  57.         $restOfCart = $this->splitQuantities($cartProducts, $context);
  59.         foreach ($groupDefinitions as $groupDefinition) {
  60.             $sorter = $this->registry->getSorter($groupDefinition->getSorterKey());
  61.             $packager = $this->registry->getPackager($groupDefinition->getPackagerKey());
  63.             // we have to sort our items first
  64.             // otherwise it would be a "random" order when
  65.             // adjusting the rest of our cart...
  66.             $restOfCart = $sorter->sort($restOfCart);
  68.             // try as long as groups can be
  69.             // found for the current definition
  70.             while (true) {
  71.                 $itemsToConsider = $this->ruleMatcher->getMatchingItems($groupDefinition, $restOfCart, $context);
  73.                 // now build a package with our packager
  74.                 $group = $packager->buildGroupPackage($groupDefinition->getValue(), $itemsToConsider, $context);
  76.                 // if we have no found items in our group, quit
  77.                 if (!$group->hasItems()) {
  78.                     break;
  79.                 }
  81.                 // append the currently found group of items
  82.                 // to our group definition inside our result object
  83.                 $result->addGroup($groupDefinition, $group);
  85.                 // decrease rest of cart items for next search
  86.                 $restOfCart = $this->adjustRestOfCart($group->getItems(), $restOfCart);
  87.             }
  88.         }
  90.         return $result;
  91.     }
  93.     /**
  94.      * This is a very important function.
  95.      * It removes our line items that are found in the group and returns the rest of the cart items.
  96.      * So if we have 4 line items of 2 products with each quantity 1, and want to remove a product with qt 2,
  97.      * then 2 line items will be removed and the new rest of the cart is being returned.
  98.      *
  99.      * @param LineItemQuantity[] $foundItems
  100.      */
  101.     private function adjustRestOfCart(array $foundItems, LineItemFlatCollection $restOfCart): LineItemFlatCollection
  102.     {
  103.         // a holder for all foundItems indexed by lineItemId
  104.         /** @var LineItemQuantity[] $lineItemsToRemove */
  105.         $lineItemsToRemove = [];
  107.         // we prepare the removeLineItemIds array with all LineItemQuantity objects indexed by lineItemId
  108.         foreach ($foundItems as $itemToRemove) {
  109.             if (isset($lineItemsToRemove[$itemToRemove->getLineItemId()])) {
  110.                 $quantity = $lineItemsToRemove[$itemToRemove->getLineItemId()];
  111.                 $lineItemsToRemove[$itemToRemove->getLineItemId()]->setQuantity($quantity->getQuantity() + $itemToRemove->getQuantity());
  113.                 continue;
  114.             }
  115.             $lineItemsToRemove[$itemToRemove->getLineItemId()] = $itemToRemove;
  116.         }
  118.         /** @var array $lineItemsToRemoveIDs */
  119.         $lineItemsToRemoveIDs = array_keys($lineItemsToRemove);
  121.         $newRestOfCart = new LineItemFlatCollection();
  123.         // this is our running buffer
  124.         // for the items that need to be removed
  125.         $deleteBuffer = [];
  127.         // make sure we have an ID index for
  128.         // all our delete-items with a qty of 0
  129.         foreach (array_keys($lineItemsToRemove) as $id) {
  130.             $deleteBuffer[$id] = 0;
  131.         }
  133.         foreach ($restOfCart as $item) {
  134.             // if its a totally different item
  135.             // just add it to the rest of our cart
  136.             if (!\in_array($item->getId(), $lineItemsToRemoveIDs, true)) {
  137.                 $newRestOfCart->add($item);
  138.             } else {
  139.                 // we have an item that should be removed
  140.                 // now we have to calculate how many of the item position (qty diff)
  141.                 // or if we have even reached our max amount of quantities to remove for this item
  142.                 $maxRemoveMeta = $lineItemsToRemove[$item->getId()]->getQuantity();
  144.                 $alreadyDeletedCount = $deleteBuffer[$item->getId()];
  146.                 // now check if we can remove our current item completely
  147.                 // or if we have a sub quantity that still needs to be
  148.                 // added to the rest of the cart
  149.                 if ($alreadyDeletedCount + $item->getQuantity() <= $maxRemoveMeta) {
  150.                     // remove completely
  151.                     $deleteBuffer[$item->getId()] += $item->getQuantity();
  152.                 } else {
  153.                     $toDeleteCount = $maxRemoveMeta - $alreadyDeletedCount;
  154.                     $keepCount = $item->getQuantity() - $toDeleteCount;
  156.                     // mark our diff as "deleted"
  157.                     $deleteBuffer[$item->getId()] += $toDeleteCount;
  159.                     // add the keep count to our item
  160.                     // and the item to the rest of our cart
  161.                     $item->setQuantity($keepCount);
  162.                     $newRestOfCart->add($item);
  163.                 }
  164.             }
  165.         }
  167.         return $newRestOfCart;
  168.     }
  170.     /**
  171.      * @throws InvalidQuantityException
  172.      * @throws LineItemNotStackableException
  173.      */
  174.     private function splitQuantities(LineItemCollection $cartItems, SalesChannelContext $context): LineItemFlatCollection
  175.     {
  176.         $items = [];
  178.         foreach ($cartItems as $item) {
  179.             $isStackable = $item->isStackable();
  181.             $item->setStackable(true);
  183.             for ($i = 1; $i <= $item->getQuantity(); ++$i) {
  184.                 $tmpItem = $this->quantitySplitter->split($item, 1, $context);
  186.                 $items[] = $tmpItem;
  187.             }
  189.             $item->setStackable($isStackable);
  190.         }
  192.         return new LineItemFlatCollection($items);
  193.     }
  194. }