basketcomponenthelper.php

См. документацию.

<?php
namespace Bitrix\Sale;
 
use Bitrix\Catalog;
use Bitrix\Main;
use Bitrix\Main\Application;
use Bitrix\Main\Data\LocalStorage\SessionLocalStorage;
use Bitrix\Sale;
 
class BasketComponentHelper
{
    private const STORAGE_NAME = 'SALE_USER_BASKET';
    private const SECTION_QUANTITY = 'SALE_USER_BASKET_QUANTITY';
    private const SECTION_PRICE = 'SALE_USER_BASKET_PRICE';
 
    private static array $currentState;
 
    static array $cacheRatio = [];
    static array $cacheRatioData = [];

    public static function existsFUserBasketQuantity(?int $fuserId, ?string $siteId = null): bool
    {
        $siteId = self::prepareSiteId($siteId);
        $fuserId = self::prepareFuserId($fuserId);
 
        return self::getCurrentBasketQuantity($fuserId, $siteId) !== null;
    }

    public static function existsFUserBasketPrice(?int $fuserId, ?string $siteId = null): bool
    {
        $siteId = self::prepareSiteId($siteId);
        $fuserId = self::prepareFuserId($fuserId);
 
        return self::getCurrentBasketPrice($fuserId, $siteId) !== null;
    }

    public static function getFUserBasketQuantity($fuserId, $siteId = null)
    {
        $siteId = self::prepareSiteId($siteId);
        $fuserId = self::prepareFuserId($fuserId);
 
        $quantity = self::getCurrentBasketQuantity($fuserId, $siteId);
        if ($quantity === null)
        {
            static::updateFUserBasketQuantity($fuserId, $siteId);
            $quantity = self::getCurrentBasketQuantity($fuserId, $siteId);
        }
 
        return $quantity;
    }

    public static function getFUserBasketPrice($fuserId, $siteId = null)
    {
        $siteId = self::prepareSiteId($siteId);
        $fuserId = self::prepareFuserId($fuserId);
 
        $price = self::getCurrentBasketPrice($fuserId, $siteId);
        if ($price === null)
        {
            static::updateFUserBasketPrice($fuserId, $siteId);
            $price = self::getCurrentBasketPrice($fuserId, $siteId);
        }
 
        return $price;
    }

    public static function setFUserBasketQuantity($fuserId, $quantity, $siteId = null)
    {
        $siteId = self::prepareSiteId($siteId);
        $fuserId = self::prepareFuserId($fuserId);
        $quantity = self::prepareValue($quantity);
 
        self::setCurrentBasketQuantity($fuserId, $siteId, $quantity);
    }

    public static function clearFUserBasketQuantity($fuserId, $siteId = null)
    {
        $siteId = self::prepareSiteId($siteId);
        $fuserId = self::prepareFuserId($fuserId);
 
        self::clearCurrentBasketQuantity($fuserId, $siteId);
    }

    public static function setFUserBasketPrice($fuserId, $price, $siteId = null)
    {
        $siteId = self::prepareSiteId($siteId);
        $fuserId = self::prepareFuserId($fuserId);
        $price = self::prepareValue($price);
 
        self::setCurrentBasketPrice($fuserId, $siteId, $price);
    }

    public static function clearFUserBasketPrice($fuserId, $siteId = null)
    {
        $siteId = self::prepareSiteId($siteId);
        $fuserId = self::prepareFuserId($fuserId);
 
        self::clearCurrentBasketPrice($fuserId, $siteId);
    }

    public static function updateFUserBasketPrice($fuserId, $siteId = null, $basketList = null)
    {
        $siteId = self::prepareSiteId($siteId);
        $fuserId = self::prepareFuserId($fuserId);
 
        $price = 0;
 
        if ($basketList === null)
        {
            $basketList = static::getFUserBasketList($fuserId, $siteId);
        }
 
        if (!empty($basketList) && is_array($basketList))
        {
            $orderData = static::calculatePrice($fuserId, $basketList);
            $price = $orderData['ORDER_PRICE'];
        }
 
        static::setFUserBasketPrice($fuserId, $price, $siteId);
    }

    public static function updateFUserBasketQuantity($fuserId, $siteId = null, $basketList = null)
    {
        $siteId = self::prepareSiteId($siteId);
        $fuserId = self::prepareFuserId($fuserId);
 
        $quantity = 0;
 
        if ($basketList === null)
        {
            $basketList = static::getFUserBasketList($fuserId, $siteId);
        }
 
        if (!empty($basketList) && is_array($basketList))
        {
            $quantity = count($basketList);
        }
 
        static::setFUserBasketQuantity($fuserId, $quantity, $siteId);
    }

    public static function updateFUserBasket($fuserId, $siteId = null)
    {
        $siteId = self::prepareSiteId($siteId);
        $fuserId = self::prepareFuserId($fuserId);
 
        $basketList = static::getFUserBasketList($fuserId, $siteId);
 
        static::updateFUserBasketPrice($fuserId, $siteId, $basketList);
        static::updateFUserBasketQuantity($fuserId, $siteId, $basketList);
    }

    protected static function getFUserBasketList($fuserId, $siteId = null)
    {
        $siteId = self::prepareSiteId($siteId);
        $fuserId = self::prepareFuserId($fuserId);
 
        $registry = Registry::getInstance(Registry::REGISTRY_TYPE_ORDER);
        $basketClassName = $registry->getBasketClassName();
 
        $basketList = [];
        $res = $basketClassName::getList([
            'filter' => [
                '=FUSER_ID' => $fuserId,
                '=ORDER_ID' => null,
                '=LID' => $siteId,
                '=CAN_BUY' => 'Y',
                '=DELAY' => 'N',
            ],
        ]);
        while ($data = $res->fetch())
        {
            if (\CSaleBasketHelper::isSetItem($data))
                continue;
 
            if (!isset($data['BASE_PRICE']) || (float)$data['BASE_PRICE'] <= 0)
            {
                $data['BASE_PRICE'] = $data['PRICE'] + $data['DISCOUNT_PRICE'];
            }
 
            $basketList[] = $data;
        }
 
        return $basketList;
    }

    protected static function calculatePrice($fuserId, array $basketList)
    {
        $totalPrice = 0;
        $totalWeight = 0;
 
        foreach ($basketList as $basketData)
        {
            $totalPrice += $basketData["PRICE"] * $basketData["QUANTITY"];
            $totalWeight += $basketData["WEIGHT"] * $basketData["QUANTITY"];
        }
 
        $orderData = array(
            'SITE_ID' => SITE_ID,
            'ORDER_PRICE' => $totalPrice,
            'ORDER_WEIGHT' => $totalWeight,
            'BASKET_ITEMS' => $basketList
        );
 
        $registry = Registry::getInstance(Registry::REGISTRY_TYPE_ORDER);
 
        $basketClassName = $registry->getBasketClassName();

        $basket = $basketClassName::create(SITE_ID);
        $basket->setFUserId($fuserId);
        foreach ($basketList as $oldItem)
        {
            $item = $basket->createItem($oldItem['MODULE'], $oldItem['PRODUCT_ID']);
            unset($oldItem['MODULE'], $oldItem['PRODUCT_ID']);
            $item->initFields($oldItem);
        }
        $orderData['ORDER_PRICE'] = self::calculateBasketCost($basket);
        unset($basket);
 
        return $orderData;
    }
 

    public static function onSaleBasketItemEntitySaved(Main\Event $event): Main\EventResult
    {
        $fuserId = Fuser::getId(true);
        $basketItem = $event->getParameter('ENTITY');
 
        if (!($basketItem instanceof BasketItem))
        {
            return new Main\EventResult( Main\EventResult::SUCCESS, null, 'sale');
        }
        if ($basketItem->isBundleChild())
        {
            return new Main\EventResult( Main\EventResult::SUCCESS, null, 'sale');
        }

        if (!($basket = $basketItem->getCollection())
            || ($basketItem->getFUserId() != $fuserId)
        )
        {
            return new Main\EventResult( Main\EventResult::SUCCESS, null, 'sale');
        }
 
        if ($basketItem->isChanged())
        {
            $originalValues = $event->getParameter('VALUES');
 
            $updateSessionData = false;
 
            if (!$basket->getOrder())
            {
                if (!$updateSessionData && array_key_exists('QUANTITY', $originalValues))
                {
                    $updateSessionData = true;
                }
 
                if (!$updateSessionData && (array_key_exists('PRICE', $originalValues) && PriceMaths::roundPrecision($originalValues['PRICE']) !== PriceMaths::roundPrecision($basketItem->getPrice())))
                {
                    $updateSessionData = true;
                }
 
                if (!$updateSessionData && (array_key_exists('DISCOUNT_PRICE', $originalValues) && PriceMaths::roundPrecision($originalValues['DISCOUNT_PRICE']) !== PriceMaths::roundPrecision($basketItem->getDiscountPrice())))
                {
                    $updateSessionData = true;
                }
            }
 
            if (!$updateSessionData && (array_key_exists('ORDER_ID', $originalValues) && (intval($originalValues['ORDER_ID'])) == 0 && intval($basketItem->getField('ORDER_ID') > 0)))
            {
                $updateSessionData = true;
            }
 
            if (!$updateSessionData
                && (array_key_exists('CAN_BUY', $originalValues) && ($originalValues['CAN_BUY'] !== $basketItem->getField('CAN_BUY'))))
            {
                $updateSessionData = true;
            }
 
            if (!$updateSessionData
                && (array_key_exists('DELAY', $originalValues) && ($originalValues['DELAY'] !== $basketItem->getField('DELAY'))))
            {
                $updateSessionData = true;
            }
 
            if ($updateSessionData)
            {
                $siteId = $basket->getSiteId();
                static::clearFUserBasketPrice($fuserId, $siteId);
                static::clearFUserBasketQuantity($fuserId, $siteId);
            }
        }
 
        return new Main\EventResult( Main\EventResult::SUCCESS, null, 'sale');
    }

    public static function onSaleBasketItemDeleted(Main\Event $event): Main\EventResult
    {
        $fuserId = Fuser::getId(true);
        $originalValues = $event->getParameter('VALUES');
        if ($originalValues['FUSER_ID'] != $fuserId)
        {
            return new Main\EventResult( Main\EventResult::SUCCESS, null, 'sale');
        }
 
        static::clearFUserBasketPrice($fuserId, SITE_ID);
        static::clearFUserBasketQuantity($fuserId, SITE_ID);
 
        return new Main\EventResult( Main\EventResult::SUCCESS, null, 'sale');
    }

    public static function checkQuantityRatio(Basket $basket, BasketItem $item = null)
    {
        $result = new Result();
 
        $basketItemRatioList = array();
        $ratioList = array();
        $ratioResult = static::getRatio($basket, $item);
 
        if ($ratioResult->isSuccess())
        {
            $ratioData = $ratioResult->getData();
 
            if (!empty($ratioData['RATIO_LIST']) && is_array($ratioData['RATIO_LIST']))
            {
                $ratioList = $ratioData['RATIO_LIST'];
            }
        }

        foreach ($basket as $basketItem)
        {
            $basketItemCode = $basketItem->getBasketCode();
 
            if ($item === null || $item->getBasketCode() === $basketItemCode)
            {
                $basketItemRatioList[$basketItemCode] = false;
 
                if (isset($ratioList[$basketItemCode]))
                {
                    $basketItemQuantity = $basketItem->getQuantity();
                    $basketItemRatio = (float)$ratioList[$basketItemCode];
 
                    $mod = roundEx(($basketItemQuantity / $basketItemRatio - round($basketItemQuantity / $basketItemRatio)), 6);
 
                    if ($mod == 0)
                    {
                        $basketItemRatioList[$basketItemCode] = true;
                    }
                }
            }
        }
 
        if (!empty($basketItemRatioList))
        {
            $result->addData(array('CHECK_RATIO_LIST' => $basketItemRatioList));
        }
 
        return $result;
    }

    public static function correctQuantityRatio(Basket $basket, BasketItem $item = null)
    {
        $result = new Result();
        $changedItems = array();
 
        $checkRatioList = array();
        $checkRatioResult = static::checkQuantityRatio($basket, $item);
 
        if ($checkRatioResult->isSuccess())
        {
            $checkRatioData = $checkRatioResult->getData();
 
            if (!empty($checkRatioData['CHECK_RATIO_LIST']) && is_array($checkRatioData['CHECK_RATIO_LIST']))
            {
                $checkRatioList = $checkRatioData['CHECK_RATIO_LIST'];
            }
        }
 
        $basketItemRatioList = array();
        $ratioList = null;

        foreach ($basket as $basketItem)
        {
            $basketItemCode = $basketItem->getBasketCode();
 
            if ($item === null || $item->getBasketCode() === $basketItemCode)
            {
                $basketItemRatioList[$basketItemCode] = false;
 
                if (isset($checkRatioList[$basketItemCode]) && $checkRatioList[$basketItemCode] === false)
                {
                    if ($ratioList === null)
                    {
                        $ratioList = array();
                        $ratioResult = static::getRatio($basket, $item);
 
                        if ($ratioResult->isSuccess())
                        {
                            $ratioData = $ratioResult->getData();
 
                            if (!empty($ratioData['RATIO_LIST']) && is_array($ratioData['RATIO_LIST']))
                            {
                                $ratioList = $ratioData['RATIO_LIST'];
                            }
                        }
                    }
 
                    if (!isset($ratioList[$basketItemCode]))
                    {
                        $result->addError(new ResultError(Main\Localization\Loc::getMessage('SALE_BASKET_COMPONENT_HELPER_PRODUCT_RATIO_NOT_FOUND', array(
                            '#PRODUCT_NAME#' => $basketItem->getField('NAME')
                        )), 'SALE_BASKET_COMPONENT_HELPER_PRODUCT_RATIO_NOT_FOUND'));
                        continue;
                    }
 
                    $basketItemQuantity = $basketItem->getQuantity();
                    $basketItemRatio = (float)$ratioList[$basketItemCode];
 
                    $mod = roundEx(($basketItemQuantity / $basketItemRatio - round($basketItemQuantity / $basketItemRatio)), 6);
 
                    if ($mod != 0)
                    {
                        $changedItems[] = $basketItemCode;
 
                        $closestQuantity = round($basketItemQuantity / $basketItemRatio) * $basketItemRatio;
                        if ($closestQuantity < $basketItemRatio)
                        {
                            $closestQuantity = $basketItemRatio;
                        }
 
                        $r = $basketItem->setField('QUANTITY', $closestQuantity);
                        if (!$r->isSuccess())
                        {
                            $floorQuantity = floor(ceil($basketItemQuantity) / $basketItemRatio) * $basketItemRatio;
                            if ($floorQuantity < $basketItemRatio)
                            {
                                $floorQuantity = $basketItemRatio;
                            }
 
                            if ($floorQuantity != $closestQuantity)
                            {
                                $r = $basketItem->setField('QUANTITY', $floorQuantity);
                            }
                        }
 
                        if (!$r->isSuccess())
                        {
                            $result->addErrors($r->getErrors());
 
                            $r = $basketItem->setField('CAN_BUY', 'N');
                            if (!$r->isSuccess())
                            {
                                $result->addErrors($r->getErrors());
                            }
                        }
                    }
                }
            }
        }
 
        $result->addData(array('CHANGED_BASKET_ITEMS' => $changedItems));
 
        return $result;
    }

    public static function getRatio(Basket $basket, BasketItem $item = null)
    {
        $result = new Result();
        $ratioList = array();
        if (Main\Loader::includeModule('catalog'))
        {
            $map = array();
            $elementList = array();

            foreach ($basket as $basketItem)
            {
                $code = $basketItem->getBasketCode();
                if ($item !== null && $item->getBasketCode() != $code)
                {
                    continue;
                }
 
                $hash = md5((strval($basketItem->getField("PRODUCT_PROVIDER_CLASS")) != '' ? $basketItem->getField("PRODUCT_PROVIDER_CLASS"): "")."|".(strval($basketItem->getField("MODULE")) != '' ? $basketItem->getField("MODULE"): "")."|".$basketItem->getField("PRODUCT_ID"));
 
                if (array_key_exists($hash, static::$cacheRatio))
                {
                    $ratioList[$code] = static::$cacheRatio[$hash];
                }
                else
                {
                    $elementList[$basketItem->getField("PRODUCT_ID")] = $basketItem->getField("PRODUCT_ID");
                }
 
                if (!isset($map[$basketItem->getField("PRODUCT_ID")]))
                {
                    $map[$basketItem->getField("PRODUCT_ID")] = array();
                }
 
                $map[$basketItem->getField("PRODUCT_ID")][] = $code;
            }
 
            if (!empty($elementList))
            {
                $res = Catalog\MeasureRatioTable::getList(array(
                    'select' => array('*'),
                    'filter' => array('@PRODUCT_ID' => $elementList, '=IS_DEFAULT' => 'Y')
                ));
                while ($ratioData = $res->fetch())
                {
                    if (empty($map[$ratioData["PRODUCT_ID"]]))
                        continue;
 
                    foreach ($map[$ratioData["PRODUCT_ID"]] as $key)
                    {
                        $ratioList[$key] = $ratioData["RATIO"];
 
                        if (!$basketItem = $basket->getItemByBasketCode($key))
                            continue;
 
                        $hash = md5((strval($basketItem->getField("PRODUCT_PROVIDER_CLASS")) != '' ? $basketItem->getField("PRODUCT_PROVIDER_CLASS"): "")."|".(strval($basketItem->getField("MODULE")) != '' ? $basketItem->getField("MODULE"): "")."|".$basketItem->getField("PRODUCT_ID"));
 
                        static::$cacheRatio[$hash] = $ratioData["RATIO"];
                        static::$cacheRatioData[$hash] = $ratioData;
                    }
                    unset($key);
                }
                unset($ratioData, $dbRatio);
            }
            unset($elementList, $map);
        }
 
        if (!empty($ratioList))
            $result->addData(array('RATIO_LIST' => $ratioList));
 
        return $result;
    }

    protected static function calculateBasketCost(Basket $basket)
    {
        if ($basket->count() == 0)
            return 0;
 
        $oldApiStatus = Compatible\DiscountCompatibility::isUsed(); // TODO: remove this code after refactoring DiscountCompatibility
        if ($oldApiStatus)
            Compatible\DiscountCompatibility::stopUsageCompatible();
        DiscountCouponsManager::freezeCouponStorage();
        $basket->refreshData(array('PRICE', 'COUPONS'));
        $discounts = Discount::buildFromBasket($basket, new Discount\Context\Fuser($basket->getFUserId(true)));
        $discounts->calculate();
        $discountResult = $discounts->getApplyResult();
        DiscountCouponsManager::unFreezeCouponStorage();
        if ($oldApiStatus)
            Compatible\DiscountCompatibility::revertUsageCompatible();
 
        if (empty($discountResult['PRICES']['BASKET']))
            return 0;
 
        $result = 0;
        $discountResult = $discountResult['PRICES']['BASKET'];
        foreach ($basket as $basketItem)
        {
            if (!$basketItem->canBuy())
                continue;
            $code = $basketItem->getBasketCode();
            if (!empty($discountResult[$code]))
                $result += $discountResult[$code]['PRICE'] * $basketItem->getQuantity();
            unset($code);
        }
        unset($basketItem);
        unset($discountResult);
 
        return $result;
    }

    public static function getRatioCache()
    {
        return static::$cacheRatio;
    }

    public static function getRatioDataCache()
    {
        return static::$cacheRatioData;
    }
 
    private static function getLocalStorage(): SessionLocalStorage
    {
        return Application::getInstance()->getLocalSession(self::STORAGE_NAME);
    }
 
    private static function loadStateFromStorage(): void
    {
        if (isset(self::$currentState))
        {
            return;
        }
        $storage = self::getLocalStorage();
        self::$currentState = self::verifyState($storage->getData());
    }
 
    private static function saveStateToStorage(): void
    {
        if (!isset(self::$currentState))
        {
            return;
        }
        $storage = self::getLocalStorage();
        $storage->setData(self::$currentState);
    }
 
    private static function getEmptyState(): array
    {
        return [
            self::SECTION_PRICE => [],
            self::SECTION_QUANTITY => [],
        ];
    }
 
    private static function verifyState(array $state): array
    {
        $emptyState = self::getEmptyState();
        $state = array_intersect_key($state, $emptyState);
 
        $result = [];
        foreach ($state as $sectionId => $sites)
        {
            if (!is_array($sites))
            {
                continue;
            }
            $result[$sectionId] = self::verifySection($sites);
        }
 
        return array_merge($emptyState, $result);
    }
 
    private static function verifySection(array $section): array
    {
        $result = [];
        foreach ($section as $siteId => $users)
        {
            if (!is_string($siteId) || !is_array($users))
            {
                continue;
            }
            $newUsers = [];
            foreach ($users as $userId => $value)
            {
                if (!is_int($userId))
                {
                    continue;
                }
                $newUsers[$userId] = (float)$value;
            }
            $result[$siteId] = $newUsers;
            unset($newUsers);
        }
 
        return $result;
    }
 
    private static function getCurrentValue(string $sectionId, ?int $fuserId, string $siteId): null|int|float
    {
        if ($fuserId === null)
        {
            return 0;
        }
        self::loadStateFromStorage();
 
        return (self::$currentState[$sectionId][$siteId][$fuserId] ?? null);
    }
 
    private static function setCurrentValue(string $sectionId, ?int $fuserId, string $siteId, int|float $value): void
    {
        if ($fuserId === null)
        {
            return;
        }
        if (!isset(self::$currentState[$sectionId]))
        {
            return;
        }
        self::$currentState[$sectionId][$siteId] ??= [];
        self::$currentState[$sectionId][$siteId][$fuserId] = $value;
        self::saveStateToStorage();
    }
 
    private static function clearCurrentValue(string $sectionId, ?int $fuserId, string $siteId): void
    {
        if ($fuserId === null)
        {
            return;
        }
        self::loadStateFromStorage();
        if (!isset(self::$currentState[$sectionId]))
        {
            return;
        }
        unset(self::$currentState[$sectionId][$siteId][$fuserId]);
        self::saveStateToStorage();
    }
 
    private static function getCurrentBasketPrice(?int $fuserId, string $siteId): null|int|float
    {
        return self::getCurrentValue(self::SECTION_PRICE, $fuserId, $siteId);
    }
 
    private static function setCurrentBasketPrice(?int $fuserId, string $siteId, int|float $price): void
    {
        self::setCurrentValue(self::SECTION_PRICE, $fuserId, $siteId, $price);
    }
 
    private static function clearCurrentBasketPrice(?int $fuserId, string $siteId): void
    {
        self::clearCurrentValue(self::SECTION_PRICE, $fuserId, $siteId);
    }
 
    private static function getCurrentBasketQuantity(?int $fuserId, string $siteId): null|int|float
    {
        return self::getCurrentValue(self::SECTION_QUANTITY, $fuserId, $siteId);
    }
 
    private static function setCurrentBasketQuantity(?int $fuserId, string $siteId, int|float $quantity): void
    {
        self::setCurrentValue(self::SECTION_QUANTITY, $fuserId, $siteId, $quantity);
    }
 
    private static function clearCurrentBasketQuantity(?int $fuserId, string $siteId): void
    {
        self::clearCurrentValue(self::SECTION_QUANTITY, $fuserId, $siteId);
    }
 
    private static function prepareSiteId(mixed $siteId): string
    {
        if ($siteId !== null)
        {
            $siteId = trim((string)$siteId);
            if ($siteId === '')
            {
                $siteId = null;
            }
        }
        if ($siteId === null)
        {
            $siteId = SITE_ID;
        }
 
        return $siteId;
    }
 
    private static function prepareFuserId(mixed $fuserId): ?int
    {
        if ($fuserId !== null)
        {
            $fuserId = (int)$fuserId;
            if ($fuserId <= 0)
            {
                $fuserId = null;
            }
        }
 
        return $fuserId;
    }
 
    private static function prepareValue(mixed $value): int|float
    {
        if (is_int($value) || is_float($value))
        {
            return $value;
        }
 
        return (float)$value;
    }
}