basketbase.php

<?php
namespace Bitrix\Sale;
 
use Bitrix\Main;
use Bitrix\Main\Localization\Loc;
use Bitrix\Sale\Basket\RefreshFactory;
use Bitrix\Sale\Basket\RefreshStrategy;
use Bitrix\Sale\Internals;
 
Loc::loadMessages(__FILE__);
 
abstract class BasketBase extends BasketItemCollection
{
    protected $siteId = null;
 
    protected $fUserId = null;
 
    protected $order = null;
 
    protected $basketItemIndexMap = array();
 
    protected $maxItemSort = null;
 
    private $isLoadForFUserId = false;
 
    protected $isSaveExecuting = false;
 
    public function getItemByBasketCode($code)
    {
        if (
            isset($this->basketItemIndexMap[$code])
            && isset($this->collection[$this->basketItemIndexMap[$code]])
        )
        {
            return $this->collection[$this->basketItemIndexMap[$code]];
        }
 
        return parent::getItemByBasketCode($code);
    }
 
    protected function getEntityParent()
    {
        return $this->getOrder();
    }
 
    private static function createBasketObject()
    {
        $registry = Registry::getInstance(static::getRegistryType());
        $basketClassName = $registry->getBasketClassName();
 
        return new $basketClassName;
    }
 
    public static function loadItemsForFUser($fUserId, $siteId)
    {
        $basket = static::create($siteId);
 
        $basket->setFUserId($fUserId);
 
        $basket->isLoadForFUserId = true;
 
        return $basket->loadFromDb([
            "=FUSER_ID" => $fUserId,
            "=LID" => $siteId,
            "ORDER_ID" => null
        ]);
    }
 
    protected function loadFromDb(array $filter)
    {
        $select = [
            "ID", "LID", "MODULE", "PRODUCT_ID", "QUANTITY", "WEIGHT",
            "DELAY", "CAN_BUY", "PRICE", "CUSTOM_PRICE", "BASE_PRICE",
            'PRODUCT_PRICE_ID', 'PRICE_TYPE_ID', "CURRENCY", 'BARCODE_MULTI',
            "RESERVED", "RESERVE_QUANTITY", "NAME", "CATALOG_XML_ID",
            "VAT_RATE", "NOTES", "DISCOUNT_PRICE","PRODUCT_PROVIDER_CLASS",
            "CALLBACK_FUNC", "ORDER_CALLBACK_FUNC", "PAY_CALLBACK_FUNC",
            "CANCEL_CALLBACK_FUNC", "DIMENSIONS", "TYPE", "SET_PARENT_ID",
            "DETAIL_PAGE_URL", "FUSER_ID", 'MEASURE_CODE', 'MEASURE_NAME',
            'ORDER_ID', 'DATE_INSERT', 'DATE_UPDATE', 'PRODUCT_XML_ID',
            'SUBSCRIBE', 'RECOMMENDATION', 'VAT_INCLUDED', 'SORT',
            'DATE_REFRESH', 'DISCOUNT_NAME', 'DISCOUNT_VALUE', 'DISCOUNT_COUPON',
            'XML_ID', 'MARKING_CODE_GROUP'
        ];
 
        $itemList = [];
        $first = true;
 
        $res = static::getList([
            "select" => $select,
            "filter" => $filter,
            "order" => ['SORT' => 'ASC', 'ID' => 'ASC'],
        ]);
        while ($item = $res->fetch())
        {
            if ($first)
            {
                $this->setSiteId($item['LID']);
                $this->setFUserId($item['FUSER_ID']);
                $first = false;
            }
 
            $itemList[$item['ID']] = $item;
        }
 
        foreach ($itemList as $id => $item)
        {
            if ($item['SET_PARENT_ID'] > 0)
            {
                $itemList[$item['SET_PARENT_ID']]['ITEMS'][$id] = &$itemList[$id];
            }
        }
 
        $result = [];
        foreach ($itemList as $id => $item)
        {
            if ($item['SET_PARENT_ID'] == 0)
            {
                $result[$id] = $item;
            }
        }
 
        $this->loadFromArray($result);
 
        return $this;
    }
 
    public function setOrder(OrderBase $order)
    {
        $this->order = $order;
    }
 
    public function getOrder()
    {
        return $this->order;
    }
 
 
    protected function verifyItemSort(BasketItemBase $item)
    {
        $itemSort = (int)$item->getField('SORT') ?: 100;
 
        if ($this->maxItemSort === null)
        {
            $this->maxItemSort = $itemSort;
        }
        else
        {
            if ($itemSort > $this->maxItemSort)
            {
                $this->maxItemSort = $itemSort;
            }
            else
            {
                $this->maxItemSort += 100 + $this->maxItemSort % 100;
            }
        }
 
        $item->setFieldNoDemand('SORT', $this->maxItemSort);
    }
 
    public static function create($siteId)
    {
        $basket = static::createBasketObject();
        $basket->setSiteId($siteId);
 
        return $basket;
    }
 
    public function getPrice()
    {
        $orderPrice = 0;
 
        foreach ($this->collection as $basketItem)
        {
            $orderPrice += $basketItem->getFinalPrice();
        }
 
        return $orderPrice;
    }
 
    public function getBasePrice()
    {
        $orderPrice = 0;
 
        foreach ($this->collection as $basketItem)
        {
            $orderPrice += PriceMaths::roundPrecision($basketItem->getBasePriceWithVat() * $basketItem->getQuantity());
        }
 
        return $orderPrice;
    }
 
    public function getVatSum()
    {
        $vatSum = 0;
 
        foreach ($this->collection as $basketItem)
        {
            // BasketItem that is removed is not involved
            if ($basketItem->getQuantity() == 0)
            {
                continue;
            }
 
            $vatSum += $basketItem->getVat();
        }
 
        return $vatSum;
    }
 
    public function getVatRate()
    {
        $vatRate = 0;
 
        foreach ($this->collection as $basketItem)
        {
            // BasketItem that is removed is not involved
            if ($basketItem->getQuantity() == 0)
            {
                continue;
            }
 
            if ($basketItem->getVatRate() > $vatRate)
            {
                $vatRate = $basketItem->getVatRate();
            }
        }
 
        return $vatRate;
    }
 
    public function verify()
    {
        $result = new Result();
 
        foreach ($this->collection as $basketItem)
        {
            $r = $basketItem->verify();
            if (!$r->isSuccess())
            {
                $result->addErrors($r->getErrors());
 
                if ($order = $this->getOrder())
                {
                    $registry = Registry::getInstance(static::getRegistryType());
 
                    $entityMarker = $registry->getEntityMarkerClassName();
                    $entityMarker::addMarker($order, $basketItem, $r);
                    $order->setField('MARKED', 'Y');
                }
            }
        }
 
        return $result;
    }
 
    public function getWeight()
    {
        $orderWeight = 0;
 
        foreach ($this->collection as $basketItem)
        {
            $orderWeight += $basketItem->getWeight() * $basketItem->getQuantity();
        }
 
        return $orderWeight;
    }
 
    private function getOriginalItemsValues()
    {
        $result = array();
 
        $order = $this->getOrder();
        $isNew = $order && $order->isNew();
 
        $filter = array();
        if (!$isNew && $order && $order->getId() > 0)
        {
            $filter['ORDER_ID'] = $order->getId();
        }
        else
        {
            if ($this->isLoadForFUserId)
            {
                $filter = array(
                    '=FUSER_ID' => $this->getFUserId(),
                    'ORDER_ID' => null,
                    '=LID' => $this->getSiteId()
                );
            }
 
            if ($isNew)
            {
                $fUserId = $this->getFUserId(true);
                if ($fUserId <= 0)
                {
                    $userId = $order->getUserId();
                    if (intval($userId) > 0)
                    {
                        $fUserId = Fuser::getIdByUserId($userId);
                        if ($fUserId > 0)
                            $this->setFUserId($fUserId);
                    }
                }
            }
        }
 
        if ($filter)
        {
            $dbRes = static::getList(
                array(
                    "select" => array("ID", 'TYPE', 'SET_PARENT_ID', 'PRODUCT_ID', 'NAME', 'QUANTITY', 'FUSER_ID', 'ORDER_ID'),
                    "filter" => $filter,
                )
            );
 
            while ($item = $dbRes->fetch())
            {
                if ((int)$item['SET_PARENT_ID'] > 0 && (int)$item['SET_PARENT_ID'] != $item['ID'])
                {
                    continue;
                }
 
                $result[$item["ID"]] = $item;
            }
        }
 
        return $result;
    }
 
    abstract protected function deleteInternal(array $itemValues);
 
    public function save()
    {
        $this->checkCallingContext();
 
        $result = new Result();
 
        $this->isSaveExecuting = true;
 
        $order = $this->getOrder();
        if (!$order)
        {
            $r = $this->verify();
            if (!$r->isSuccess())
            {
                return $result->addErrors($r->getErrors());
            }
 
            $r = $this->callEventOnSaleBasketBeforeSaved();
            if (!$r->isSuccess())
            {
                $this->isSaveExecuting = false;
 
                return $result->addErrors($r->getErrors());
            }
        }
 
        $originalItemsValues = $this->getOriginalItemsValues();
 
        foreach ($this->collection as $basketItem)
        {
            $r = $basketItem->save();
            if (!$r->isSuccess())
            {
                $result->addErrors($r->getErrors());
            }
 
            if (isset($originalItemsValues[$basketItem->getId()]))
            {
                unset($originalItemsValues[$basketItem->getId()]);
            }
        }
 
        if ($originalItemsValues)
        {
            foreach ($originalItemsValues as $itemValues)
            {
                $this->callEventOnBeforeSaleBasketItemDeleted($itemValues);
 
                $this->deleteInternal($itemValues);
 
                $this->callEventOnSaleBasketItemDeleted($itemValues);
            }
        }
 
        if (!$order)
        {
            $r = $this->callEventOnSaleBasketSaved();
            if (!$r->isSuccess())
            {
                $result->addErrors($r->getErrors());
            }
        }
 
        $this->clearChanged();
 
        $this->isSaveExecuting = false;
 
        return $result;
    }
 
    private function checkCallingContext() : void
    {
        $order = $this->getOrder();
 
        if (
            $order
            && !$order->isSaveRunning()
        )
        {
            trigger_error("Incorrect call to the save process. Use method save() on \Bitrix\Sale\Order entity.", E_USER_WARNING);
        }
    }
 
    private function callEventOnBeforeSaleBasketItemDeleted($itemValues)
    {
        $itemValues['ENTITY_REGISTRY_TYPE'] = static::getRegistryType();
 
        $event = new Main\Event('sale', "OnBeforeSaleBasketItemDeleted", array('VALUES' => $itemValues));
        $event->send();
    }
 
    protected function callEventOnSaleBasketItemDeleted($itemValues)
    {
        $itemValues['ENTITY_REGISTRY_TYPE'] = static::getRegistryType();
 
        $event = new Main\Event('sale', "OnSaleBasketItemDeleted", array('VALUES' => $itemValues));
        $event->send();
    }
 
    protected function callEventOnSaleBasketBeforeSaved()
    {
        $result = new Result();
 
        $event = new Main\Event(
            'sale',
            EventActions::EVENT_ON_BASKET_BEFORE_SAVED,
            array('ENTITY' => $this)
        );
        $event->send();
 
        if ($event->getResults())
        {
            foreach ($event->getResults() as $eventResult)
            {
                if ($eventResult->getType() == Main\EventResult::ERROR)
                {
                    $errorMsg = new ResultError(
                        Main\Localization\Loc::getMessage('SALE_EVENT_ON_BEFORE_BASKET_SAVED'),
                        'SALE_EVENT_ON_BEFORE_BASKET_SAVED'
                    );
                    if ($eventResultData = $eventResult->getParameters())
                    {
                        if (isset($eventResultData) && $eventResultData instanceof ResultError)
                        {
                            $errorMsg = $eventResultData;
                        }
                    }
 
                    $result->addError($errorMsg);
                }
            }
        }
 
        return $result;
    }
 
    protected function callEventOnSaleBasketSaved()
    {
        $result = new Result();
 
        $event = new Main\Event('sale', EventActions::EVENT_ON_BASKET_SAVED, array(
            'ENTITY' => $this
        ));
        $event->send();
 
        if ($event->getResults())
        {
            foreach($event->getResults() as $eventResult)
            {
                if($eventResult->getType() == Main\EventResult::ERROR)
                {
                    $errorMsg = new ResultError(
                        Main\Localization\Loc::getMessage('SALE_EVENT_ON_BASKET_SAVED'),
                            'SALE_EVENT_ON_BASKET_SAVED'
                    );
                    if ($eventResultData = $eventResult->getParameters())
                    {
                        if (isset($eventResultData) && $eventResultData instanceof ResultError)
                        {
                            $errorMsg = $eventResultData;
                        }
                    }
 
                    $result->addError($errorMsg);
                }
            }
        }
 
        return $result;
    }
 
    public function setFUserId($fUserId)
    {
        $this->fUserId = (int)$fUserId > 0 ? (int)$fUserId : null;
    }
 
    protected function setSiteId($siteId)
    {
        $this->siteId = $siteId;
    }
 
    public function getFUserId($skipCreate = false)
    {
        if ($this->fUserId === null)
        {
            $this->fUserId = Fuser::getId($skipCreate);
        }
        return $this->fUserId;
    }
 
    public function getSiteId()
    {
        return $this->siteId;
    }
 
    public static function getList(array $parameters = array())
    {
        throw new Main\NotImplementedException();
    }
 
    public function onItemModify(Internals\CollectableEntity $item, $name = null, $oldValue = null, $value = null)
    {
        if (!($item instanceof BasketItemBase))
            throw new Main\ArgumentTypeException($item);
 
        $result = new Result();
 
        if ($order = $this->getOrder())
        {
            $r = $order->onBasketModify(EventActions::UPDATE, $item, $name, $oldValue, $value);
            if (!$r->isSuccess())
            {
                $result->addErrors($r->getErrors());
            }
            elseif ($r->hasWarnings())
            {
                $result->addWarnings($r->getWarnings());
            }
        }
 
        return $result;
    }
 
    public function refresh(RefreshStrategy $strategy = null)
    {
        $isStartField = $this->isStartField();
 
        $order = $this->getOrder();
        if ($order)
        {
            $r = $order->onBeforeBasketRefresh();
            if (!$r->isSuccess())
            {
                return $r;
            }
        }
 
        if ($strategy === null)
        {
            $strategy = RefreshFactory::create();
        }
 
        $result = $strategy->refresh($this);
 
        if ($order)
        {
            $r = $order->onAfterBasketRefresh();
            if (!$r->isSuccess())
            {
                return $r;
            }
        }
 
        $changedBasketItems = $result->get('CHANGED_BASKET_ITEMS');
        if (!empty($changedBasketItems))
        {
            $order = $this->getOrder();
            if ($order)
            {
                $r = $order->refreshData(array('PRICE', 'PRICE_DELIVERY'));
                if (!$r->isSuccess())
                {
                    $result->addErrors($r->getErrors());
                }
            }
        }
 
        if ($isStartField)
        {
            $hasMeaningfulFields = $this->hasMeaningfulField();
 
            $r = $this->doFinalAction($hasMeaningfulFields);
            if (!$r->isSuccess())
            {
                $result->addErrors($r->getErrors());
            }
        }
 
        return $result;
    }
 
    public function getOrderableItems()
    {
        $basket = static::create($this->getSiteId());
 
        if ($this->isLoadForFUserId)
        {
            $basket->setFUserId($this->getFUserId(true));
        }
 
        if ($order = $this->getOrder())
        {
            $basket->setOrder($order);
        }
 
        $sortedCollection = $this->collection;
        usort($sortedCollection, function(BasketItemBase $a, BasketItemBase $b){
            return (int)$a->getField('SORT') - (int)$b->getField('SORT');
        });
 
        foreach ($sortedCollection as $item)
        {
            if (!$item->canBuy() || $item->isDelay())
                continue;
 
            $item->setCollection($basket);
            $basket->addItem($item);
        }
 
        return $basket;
    }
 
    public function getBasket()
    {
        return $this;
    }
 
    public static function deleteNoDemand($idOrder)
    {
        throw new Main\NotImplementedException();
    }
 
    public function isSaveRunning()
    {
        return $this->isSaveExecuting;
    }
 
    public function getContext()
    {
        $context = array();
 
        $order = $this->getOrder();
        if ($order)
        {
            $context['USER_ID'] = $order->getUserId();
            $context['SITE_ID'] = $order->getSiteId();
            $context['CURRENCY'] = $order->getCurrency();
        }
        else
        {
            $context = parent::getContext();
        }
 
        return $context;
    }
 
    public function getQuantityList()
    {
        $quantityList = array();
 
        foreach ($this->collection as $basketKey => $basketItem)
        {
            $quantityList[$basketItem->getBasketCode()] = $basketItem->getQuantity();
        }
 
        return $quantityList;
    }
 
    public function deleteItem($index)
    {
        $oldItem = parent::deleteItem($index);
 
        unset($this->basketItemIndexMap[$oldItem->getBasketCode()]);
 
        if ($order = $this->getOrder())
        {
            $order->onBasketModify(EventActions::DELETE, $oldItem);
        }
 
        return $oldItem;
    }
 
    public function applyDiscount(array $basketRows)
    {
        $result = new Result();
 
        if ($this->count() == 0 || empty($basketRows))
            return $result;
 
        foreach ($this->collection as $basketItem)
        {
            if ($basketItem->isCustomPrice())
                continue;
            $basketCode = $basketItem->getBasketCode();
            if (!isset($basketRows[$basketCode]))
                continue;
 
            $fields = $basketRows[$basketCode];
 
            if (isset($fields['PRICE']) && isset($fields['DISCOUNT_PRICE']))
            {
                $fields['PRICE'] = (float)$fields['PRICE'];
                $fields['DISCOUNT_PRICE'] = (float)$fields['DISCOUNT_PRICE'];
 
                if ($fields['PRICE'] >= 0
                    && $basketItem->getPrice() != $fields['PRICE'])
                {
                    $fields['PRICE'] = PriceMaths::roundPrecision($fields['PRICE']);
                    $basketItem->setFieldNoDemand('PRICE', $fields['PRICE']);
                }
 
                if ($basketItem->getDiscountPrice() != $fields['DISCOUNT_PRICE'])
                {
                    $fields['DISCOUNT_PRICE'] = PriceMaths::roundPrecision($fields['DISCOUNT_PRICE']);
                    $basketItem->setFieldNoDemand('DISCOUNT_PRICE', $fields['DISCOUNT_PRICE']);
                }
 
                if (isset($fields['DISCOUNT_VALUE']))
                    $basketItem->setFieldNoDemand('DISCOUNT_VALUE', $fields['DISCOUNT_VALUE']);
            }
        }
        unset($fields, $basketCode, $basketItem);
 
        return $result;
    }
 
    public function createClone(\SplObjectStorage $cloneEntity = null)
    {
        if ($cloneEntity === null)
        {
            $cloneEntity = new \SplObjectStorage();
        }
 
        $basketClone = parent::createClone($cloneEntity);
 
        if ($this->order)
        {
            if ($cloneEntity->contains($this->order))
            {
                $basketClone->order = $cloneEntity[$this->order];
            }
        }
 
        return $basketClone;
    }
 
    public function copy()
    {
        if($this->order !== null)
        {
            throw new Main\SystemException('Could not clone basket which has order.');
        }
 
        $basket = static::create($this->siteId);
        foreach($this as $originalItem)
        {
            $item = $basket->createItem($originalItem->getField("MODULE"), $originalItem->getProductId());
            $item->initFields($originalItem->getFields()->getValues());
        }
 
        return $basket;
    }
 
    public static function loadItemsForOrder(OrderBase $order)
    {
        $basket = static::createBasketObject();
        $basket->setOrder($order);
        $basket->setSiteId($order->getSiteId());
 
        return $basket->loadFromDb(array("=ORDER_ID" => $order->getId()));
    }
 
    public function addItem(Internals\CollectableEntity $basketItem)
    {
        $basketItem = parent::addItem($basketItem);
 
        $this->basketItemIndexMap[$basketItem->getBasketCode()] = $basketItem->getInternalIndex();
 
        $this->verifyItemSort($basketItem);
 
        $basketItem->setCollection($this);
 
        if ($order = $this->getOrder())
        {
            $order->onBasketModify(EventActions::ADD, $basketItem);
        }
    }
 
    public function refreshData($select = array(), BasketItemBase $refreshItem = null)
    {
        if ($refreshItem !== null)
        {
            $strategy = RefreshFactory::createSingle($refreshItem->getBasketCode());
        }
        else
        {
            $strategy = RefreshFactory::create(RefreshFactory::TYPE_FULL);
        }
 
        return $this->refresh($strategy);
    }
 
    public function getExistsItemByItem(BasketItemBase $item)
    {
        $propertyList = [];
        $propertyCollection = $item->getPropertyCollection();
        if ($propertyCollection)
        {
            $propertyList = $propertyCollection->getPropertyValues();
        }
 
        return $this->getExistsItem($item->getField('MODULE'), $item->getField('PRODUCT_ID'), $propertyList);
    }
}