basketitem.php

<?php
namespace Bitrix\Sale;
 
use Bitrix\Currency\CurrencyManager;
use Bitrix\Main;
use Bitrix\Main\ArgumentException;
use Bitrix\Main\ArgumentNullException;
use Bitrix\Main\ArgumentOutOfRangeException;
use Bitrix\Main\Config;
use Bitrix\Main\Localization\Loc;
use Bitrix\Main\ObjectNotFoundException;
use Bitrix\Sale\Internals;
 
Loc::loadMessages(__FILE__);
 
class BasketItem extends BasketItemBase
{
    public const TYPE_SET = 1;
    public const TYPE_SERVICE = 2;
 
    private $bundleCollection = null;
 
    protected $reserveQuantityCollection;
 
    public static function getRegistryType()
    {
        return Registry::REGISTRY_TYPE_ORDER;
    }
 
    public function save()
    {
        $result = parent::save();
        if (!$result->isSuccess())
        {
            return $result;
        }
 
        $reserveCollection = $this->getReserveQuantityCollection();
        if ($reserveCollection)
        {
            $r = $reserveCollection->save();
            if (!$r->isSuccess())
            {
                return $result->addErrors($r->getErrors());
            }
        }
 
        if ($this->isBundleParent())
        {
            $bundleCollection = $this->getBundleCollection();
            $itemsFromDb = [];
 
            $id = $this->getId();
            if ($id != 0)
            {
                $register = Registry::getInstance(static::getRegistryType());
                $basketClassName = $register->getBasketClassName();
 
                $itemsFromDbList = $basketClassName::getList(
                    [
                        'select' => ['ID'],
                        'filter' => ['SET_PARENT_ID' => $id],
                    ]
                );
                while ($itemsFromDbItem = $itemsFromDbList->fetch())
                {
                    if ($itemsFromDbItem['ID'] == $id)
                        continue;
 
                    $itemsFromDb[$itemsFromDbItem['ID']] = true;
                }
            }
 
            foreach ($bundleCollection as $bundleItem)
            {
                $parentId = (int)$bundleItem->getField('SET_PARENT_ID');
                if ($parentId <= 0)
                    $bundleItem->setFieldNoDemand('SET_PARENT_ID', $id);
 
                $saveResult = $bundleItem->save();
                if (!$saveResult->isSuccess())
                    $result->addErrors($saveResult->getErrors());
 
                if (isset($itemsFromDb[$bundleItem->getId()]))
                    unset($itemsFromDb[$bundleItem->getId()]);
            }
 
            foreach ($itemsFromDb as $id => $value)
            {
                $this->deleteInternal($id);
            }
        }
 
        return $result;
    }
 
    protected function add()
    {
        $logFields = $this->getLoggedFields();
 
        $result = parent::add();
 
        $collection = $this->getCollection();
 
        if (!$basket = $collection->getBasket())
        {
            throw new Main\ObjectNotFoundException('Entity "Basket" not found');
        }
 
        if ($basket->getOrderId() > 0)
        {
            $registry = Registry::getInstance(static::getRegistryType());
            $orderHistory = $registry->getOrderHistoryClassName();
 
            if (!$result->isSuccess())
            {
                $orderHistory::addAction(
                    'BASKET',
                    $basket->getOrderId(),
                    'BASKET_ITEM_ADD_ERROR',
                    null,
                    $this,
                    ["ERROR" => $result->getErrorMessages()]
                );
            }
            else
            {
                $orderHistory::addLog(
                    'BASKET',
                    $basket->getOrderId(),
                    "BASKET_ITEM_ADD",
                    $this->getId(),
                    $this,
                    $logFields,
                    $orderHistory::SALE_ORDER_HISTORY_LOG_LEVEL_1
                );
 
                $orderHistory::addAction(
                    'BASKET',
                    $basket->getOrderId(),
                    "BASKET_SAVED",
                    $this->getId(),
                    $this,
                    [],
                    $orderHistory::SALE_ORDER_HISTORY_ACTION_LOG_LEVEL_1
                );
            }
        }
 
        return $result;
    }
 
    protected function update()
    {
        $registry = Registry::getInstance(static::getRegistryType());
        $orderHistory = $registry->getOrderHistoryClassName();
 
        $collection = $this->getCollection();
 
        if (!$basket = $collection->getBasket())
        {
            throw new Main\ObjectNotFoundException('Entity "Basket" not found');
        }
 
        $logFields = $this->getLoggedFields();
 
        $result = parent::update();
 
        if (!$result->isSuccess())
        {
            if ($basket->getOrderId() > 0)
            {
                $orderHistory::addAction(
                    'BASKET',
                    $basket->getOrderId(),
                    'BASKET_ITEM_UPDATE_ERROR',
                    null,
                    $this,
                    ["ERROR" => $result->getErrorMessages()]
                );
            }
        }
        else
        {
            $orderHistory::addLog(
                'BASKET',
                $basket->getOrderId(),
                "BASKET_ITEM_UPDATE",
                $this->getId(),
                $this,
                $logFields,
                $orderHistory::SALE_ORDER_HISTORY_LOG_LEVEL_1
            );
 
            $orderHistory::addAction(
                'BASKET',
                $basket->getOrderId(),
                "BASKET_SAVED",
                $this->getId(),
                $this,
                [],
                $orderHistory::SALE_ORDER_HISTORY_ACTION_LOG_LEVEL_1
            );
        }
 
        return $result;
    }
 
    private function getLoggedFields()
    {
        $basket = $this->getCollection();
 
        $orderId = $basket->getOrderId();
 
        $changeMeaningfulFields = [
            "PRODUCT_ID",
            "QUANTITY",
            "PRICE",
            "DISCOUNT_VALUE",
            "VAT_RATE",
            "NAME",
        ];
 
        $logFields = [];
        if ($orderId > 0 && $this->isChanged())
        {
            $itemValues = $this->getFields();
            $originalValues = $itemValues->getOriginalValues();
 
            foreach($originalValues as $originalFieldName => $originalFieldValue)
            {
                if (in_array($originalFieldName, $changeMeaningfulFields) && $this->getField($originalFieldName) != $originalFieldValue)
                {
                    $logFields[$originalFieldName] = $this->getField($originalFieldName);
                    $logFields['OLD_'.$originalFieldName] = $originalFieldValue;
                }
            }
        }
 
        return $logFields;
    }
 
    protected function checkBeforeDelete()
    {
        $result = new Result();
 
        $collection = $this->getCollection();
 
        $order = $collection->getBasket()->getOrder();
 
        if ($order)
        {
            foreach ($order->getShipmentCollection() as $shipment)
            {
                if ($shipment->isSystem())
                {
                    continue;
                }
 
                if ($shipmentItemCollection = $shipment->getShipmentItemCollection())
                {
                    if ($shipmentItemCollection->getItemByBasketCode($this->getBasketCode())
                        && $shipment->isShipped()
                    )
                    {
                        $messageCode = 'SALE_BASKET_ITEM_REMOVE_IMPOSSIBLE_BECAUSE_SHIPPED';
                        if ($this->isService())
                        {
                            $messageCode = 'SALE_BASKET_ITEM_REMOVE_IMPOSSIBLE_BECAUSE_SERVICE_SHIPPED';
                        }
 
                        $result->addError(
                            new ResultError(
                                Loc::getMessage(
                                    $messageCode,
                                    [
                                        '#PRODUCT_NAME#' => $this->getField('NAME'),
                                    ]
                                ),
                                'SALE_BASKET_ITEM_REMOVE_IMPOSSIBLE_BECAUSE_SHIPPED'
                            )
                        );
 
                        return $result;
                    }
                }
            }
        }
 
        return $result;
    }
 
    public function delete()
    {
        $result = new Result();
 
        $deleteResult = parent::delete();
        if (!$deleteResult->isSuccess())
        {
            $result->addErrors($deleteResult->getErrors());
            return $result;
        }
 
        if ($this->isBundleParent())
        {
            $bundleCollection = $this->getBundleCollection();
            if ($bundleCollection)
            {
                foreach ($bundleCollection as $bundleItem)
                {
                    $deleteResult = $bundleItem->delete();
                    if (!$deleteResult->isSuccess())
                    {
                        $result->addErrors($deleteResult->getErrors());
                    }
                }
            }
        }
 
        $reserveQuantityCollection = $this->getReserveQuantityCollection();
        if ($reserveQuantityCollection)
        {
            foreach ($reserveQuantityCollection as $reserve)
            {
                $r = $reserve->delete();
                if (!$r->isSuccess())
                {
                    $result->addErrors($r->getErrors());
                }
            }
        }
 
        return $result;
    }
 
    public function getReserveQuantityCollection()
    {
        if (!$this->isReservableItem())
        {
            return null;
        }
 
        if ($this->reserveQuantityCollection === null)
        {
            $registry = Registry::getInstance(static::getRegistryType());
 
            $reserveCollectionClassName = $registry->getReserveCollectionClassName();
 
            $this->reserveQuantityCollection = $reserveCollectionClassName::load($this);
        }
 
        return $this->reserveQuantityCollection;
    }
 
    private function clearBundleItemFields(array $fields)
    {
        if (!empty($fields))
        {
            $settableFields = static::getAllFields();
 
            foreach ($fields as $name => $value)
            {
                if (!isset($settableFields[$name]))
                {
                    unset($fields[$name]);
                }
            }
        }
 
        return $fields;
    }
 
    public function getParentBasketItem()
    {
        $collection = $this->getCollection();
 
        if ($collection instanceof BundleCollection)
        {
            return $collection->getParentBasketItem();
        }
 
        return null;
    }
 
    public function getParentBasketItemId()
    {
        if ($parentBasketItem = $this->getParentBasketItem())
        {
            return $parentBasketItem->getId();
        }
        return null;
    }
 
    public function isBundleParent()
    {
        return (int)$this->getField('TYPE') === static::TYPE_SET;
    }
 
    public function isBundleChild()
    {
        return $this->collection instanceof BundleCollection;
    }
 
    public function getBundleBaseQuantity()
    {
        if ($this->isBundleParent())
        {
            if (!($bundleCollection = $this->getBundleCollection()))
            {
                throw new ObjectNotFoundException('Entity "BasketBundleCollection" not found');
            }
 
            $bundleChildList = [];
            $result = [];
 
            $originalQuantity = $this->getQuantity();
            $originalValues = $this->fields->getOriginalValues();
            if (array_key_exists('QUANTITY', $originalValues) && $originalValues['QUANTITY'] !== null)
            {
                $originalQuantity = $originalValues['QUANTITY'];
            }
            foreach ($bundleCollection as $bundleBasketItem)
            {
                $originalBundleQuantity = $bundleBasketItem->getQuantity();
                $originalBundleValues = $bundleBasketItem->getFields()->getOriginalValues();
                if (array_key_exists('QUANTITY', $originalBundleValues)  && $originalBundleValues['QUANTITY'] !== null)
                {
                    $originalBundleQuantity = $originalBundleValues['QUANTITY'];
                }
 
                if ($originalQuantity > 0)
                {
                    $bundleQuantity = $originalBundleQuantity / $originalQuantity;
                }
                else
                {
                    $bundleQuantity = 0;
                }
 
                $bundleChildList[]["ITEMS"][] = [
                        "PRODUCT_ID" => $bundleBasketItem->getProductId(),
                        "QUANTITY" => $bundleQuantity
                ];
 
            }
 
            if (empty($bundleChildList))
                return false;
 
            foreach ($bundleChildList as $bundleBasketListDat)
            {
                foreach ($bundleBasketListDat["ITEMS"] as $bundleDat)
                {
                    $result[$bundleDat['PRODUCT_ID']] = $bundleDat['QUANTITY'];
                }
            }
 
            return $result;
        }
 
        return false;
    }
 
    public function getBundleCollection()
    {
        if ($this->bundleCollection === null)
        {
            if ($this->getId() > 0)
            {
                $this->bundleCollection = $this->loadBundleCollectionFromDb();
            }
            else
            {
                $this->bundleCollection = $this->loadBundleCollectionFromProvider();
            }
        }
 
        return $this->bundleCollection;
    }
 
    public function createBundleCollection()
    {
        if ($this->bundleCollection === null)
        {
            $registry = Registry::getInstance(static::getRegistryType());
            $bundleClassName = $registry->getBundleCollectionClassName();
 
            $this->bundleCollection = $bundleClassName::createBundleCollectionObject();
            $this->bundleCollection->setParentBasketItem($this);
 
            $this->setField('TYPE', static::TYPE_SET);
        }
 
        return $this->bundleCollection;
    }
 
    protected function loadBundleCollectionFromDb()
    {
        $collection = $this->createBundleCollection();
 
        if ($this->getId() > 0)
        {
            return $collection->loadFromDb(["SET_PARENT_ID" => $this->getId(), "TYPE" => false]);
        }
 
        return $collection;
    }
 
    protected function loadBundleCollectionFromProvider()
    {
        global $USER;
 
        $bundleChildList = [];
 
        if (!$basket = $this->getCollection())
        {
            throw new Main\ObjectNotFoundException('Entity "Basket" not found');
        }
 
        $order = $basket->getOrder();
        if ($order)
        {
            $context = [
                'SITE_ID' => $order->getSiteId(),
                'USER_ID' => $order->getUserId(),
                'CURRENCY' => $order->getCurrency(),
            ];
        }
        else
        {
            $context = [
                'SITE_ID' => SITE_ID,
                'USER_ID' => $USER && $USER->GetID() > 0 ? $USER->GetID() : 0,
                'CURRENCY' => CurrencyManager::getBaseCurrency(),
            ];
        }
 
        $creator = Internals\ProviderCreator::create($context);
        $creator->addBasketItem($this);
        $r = $creator->getBundleItems();
        if ($r->isSuccess())
        {
            $resultProductListData = $r->getData();
            if (!empty($resultProductListData['BUNDLE_LIST']))
            {
                $bundleChildList = $resultProductListData['BUNDLE_LIST'];
            }
        }
 
        if (empty($bundleChildList))
        {
            return null;
        }
 
        $this->bundleCollection = $this->setItemsAfterGetBundle($bundleChildList);
        return $this->bundleCollection;
    }
 
    private function setItemsAfterGetBundle(array $items)
    {
        $bundleCollection = $this->createBundleCollection();
        foreach ($items as $providerClassName => $products)
        {
            foreach ($products as $productId => $bundleBasketListDat)
            {
                foreach ($bundleBasketListDat["ITEMS"] as $bundleDat)
                {
                    $bundleFields = $this->clearBundleItemFields($bundleDat);
                    unset($bundleFields['ID']);
 
                    $bundleFields['CURRENCY'] = $this->getCurrency();
 
                    if ($this->getId() > 0)
                    {
                        $bundleFields['SET_PARENT_ID'] = $this->getId();
                    }
 
                    $bundleBasketItem = static::create($bundleCollection, $bundleFields['MODULE'], $bundleFields['PRODUCT_ID']);
 
                    if (!empty($bundleDat["PROPS"]) && is_array($bundleDat["PROPS"]))
                    {
                        $property = $bundleBasketItem->getPropertyCollection();
                        $property->setProperty($bundleDat["PROPS"]);
                    }
 
                    $bundleQuantity = $bundleFields['QUANTITY'] * $this->getQuantity();
                    unset($bundleFields['QUANTITY']);
 
                    $bundleBasketItem->setFieldsNoDemand($bundleFields);
                    $bundleBasketItem->setField('QUANTITY', $bundleQuantity);
                    $bundleCollection->addItem($bundleBasketItem);
                }
            }
        }
 
        return $bundleCollection;
    }
 
    public function findItemByBasketCode($basketCode)
    {
        $item = parent::findItemByBasketCode($basketCode);
        if ($item !== null)
            return $item;
 
        if ($this->isBundleParent())
        {
            $collection = $this->getBundleCollection();
            foreach ($collection as $basketItem)
            {
                $item = $basketItem->findItemByBasketCode($basketCode);
                if ($item !== null)
                    return $item;
            }
        }
 
        return null;
    }
 
    public function findItemById($id)
    {
        $item = parent::findItemById($id);
        if ($item !== null)
            return $item;
 
        if ($this->isBundleParent())
        {
            $collection = $this->getBundleCollection();
            foreach ($collection as $basketItem)
            {
                $item = $basketItem->findItemById($id);
                if ($item !== null)
                    return $item;
            }
        }
 
        return null;
    }
 
    protected function addChangesToHistory($name, $oldValue = null, $value = null)
    {
        if ($this->getId() > 0)
        {
            $fields = [];
            if (!$basket = $this->getCollection())
            {
                throw new ObjectNotFoundException('Entity "Basket" not found');
            }
 
            if ($basket->getOrder() && $basket->getOrderId() > 0)
            {
                if ($name == "QUANTITY")
                {
                    if (floatval($value) == 0)
                    {
                        return;
                    }
                    $fields = [
                        'PRODUCT_ID' => $this->getProductId(),
                        'QUANTITY' => $this->getQuantity(),
                        'NAME' => $this->getField('NAME'),
                    ];
                }
 
                $registry = Registry::getInstance(static::getRegistryType());
 
                $orderHistory = $registry->getOrderHistoryClassName();
                $orderHistory::addField(
                    'BASKET',
                    $basket->getOrderId(),
                    $name,
                    $oldValue,
                    $value,
                    $this->getId(),
                    $this,
                    $fields
                );
            }
        }
    }
 
    public static function formatQuantity($quantity)
    {
        $format = Config\Option::get('sale', 'format_quantity', 'AUTO');
        if ($format == 'AUTO' || intval($format) <= 0)
        {
            $quantity = round($quantity, SALE_VALUE_PRECISION);
        }
        else
        {
            $quantity = number_format($quantity, intval($format), '.', '');
        }
 
        return $quantity;
    }
 
    protected static function getFieldsMap()
    {
        return Internals\BasketTable::getMap();
    }
 
    public function isChanged()
    {
        $isChanged = parent::isChanged();
 
        if ($isChanged === false)
        {
            $reserveCollection = $this->getReserveQuantityCollection();
            if ($reserveCollection)
            {
                $isChanged = $reserveCollection->isChanged();
            }
        }
 
        return $isChanged;
    }
 
    public function createClone(\SplObjectStorage $cloneEntity)
    {
        if ($this->isClone() && $cloneEntity->contains($this))
        {
            return $cloneEntity[$this];
        }
 
        $basketItemClone = parent::createClone($cloneEntity);
 
        if ($calculatedFields = $this->calculatedFields)
        {
            $basketItemClone->calculatedFields = $calculatedFields->createClone($cloneEntity);
        }
 
        if (!$cloneEntity->contains($this))
        {
            $cloneEntity[$this] = $basketItemClone;
        }
 
        if ($propertyCollection = $this->getPropertyCollection())
        {
            if (!$cloneEntity->contains($propertyCollection))
            {
                $cloneEntity[$propertyCollection] = $propertyCollection->createClone($cloneEntity);
            }
 
            if ($cloneEntity->contains($propertyCollection))
            {
                $basketItemClone->propertyCollection = $cloneEntity[$propertyCollection];
            }
        }
 
        if ($reservedCollection = $this->getReserveQuantityCollection())
        {
            if (!$cloneEntity->contains($reservedCollection))
            {
                $cloneEntity[$reservedCollection] = $reservedCollection->createClone($cloneEntity);
            }
 
            if ($cloneEntity->contains($reservedCollection))
            {
                $basketItemClone->reserveQuantityCollection = $cloneEntity[$reservedCollection];
            }
        }
 
        if ($this->isBundleParent())
        {
            if ($bundleCollection = $this->getBundleCollection())
            {
                if (!$cloneEntity->contains($bundleCollection))
                {
                    $cloneEntity[$bundleCollection] = $bundleCollection->createClone($cloneEntity);
                }
 
                if ($cloneEntity->contains($bundleCollection))
                {
                    $basketItemClone->bundleCollection = $cloneEntity[$bundleCollection];
                }
            }
        }
 
        return $basketItemClone;
    }
 
    protected function onFieldModify($name, $oldValue, $value)
    {
        $result = new Result();
 
        $r = parent::onFieldModify($name, $oldValue, $value);
        if (!$r->isSuccess())
        {
            $result->addErrors($r->getErrors());
            return $result;
        }
        elseif ($r->hasWarnings())
        {
            $result->addWarnings($r->getWarnings());
        }
 
        if (!$this->isBundleParent())
            return $result;
 
        if ($name === 'QUANTITY')
        {
            $deltaQuantity = $value - $oldValue;
            if ($deltaQuantity != 0)
            {
                if ($bundleCollection = $this->getBundleCollection())
                {
                    $bundleBaseQuantity = $this->getBundleBaseQuantity();
 
                    foreach ($bundleCollection as $bundleItem)
                    {
                        $bundleProductId = $bundleItem->getProductId();
 
                        if (!isset($bundleBaseQuantity[$bundleProductId]))
                            throw new ArgumentOutOfRangeException('bundle product id');
 
                        $quantity = $bundleBaseQuantity[$bundleProductId] * $value;
 
                        $r = $bundleItem->setField('QUANTITY', $quantity);
                        if (!$r->isSuccess())
                        {
                            $result->addErrors($r->getErrors());
                        }
                    }
                }
            }
        }
        elseif ($name == "DELAY")
        {
            if ($bundleCollection = $this->getBundleCollection())
            {
                foreach ($bundleCollection as $bundleItem)
                {
                    $r = $bundleItem->setField('DELAY', $value);
                    if (!$r->isSuccess())
                    {
                        $result->addErrors($r->getErrors());
                    }
                }
            }
        }
        elseif ($name == "CAN_BUY")
        {
            if ($bundleCollection = $this->getBundleCollection())
            {
                foreach ($bundleCollection as $bundleItem)
                {
                    $r = $bundleItem->setField('CAN_BUY', $value);
                    if (!$r->isSuccess())
                    {
                        $result->addErrors($r->getErrors());
                    }
                }
            }
        }
 
        return $result;
    }
 
    public static function load(BasketItemCollection $basket, $data)
    {
        $bundleItems = [];
        if (isset($data['ITEMS']))
        {
            $bundleItems = $data['ITEMS'];
            unset($data['ITEMS']);
        }
 
        $basketItem = parent::load($basket, $data);
 
        if ($bundleItems)
        {
            $bundleCollection = $basketItem->createBundleCollection();
            $bundleCollection->loadFromArray($bundleItems);
        }
 
        return $basketItem;
    }
 
    protected function addInternal(array $fields)
    {
        return Internals\BasketTable::add($fields);
    }
 
    protected function updateInternal($primary, array $fields)
    {
        return Internals\BasketTable::update($primary, $fields);
    }
 
    protected function deleteInternal($primary)
    {
        return Internals\BasketTable::delete($primary);
    }
 
    public function getReservedQuantity()
    {
        $reserveQuantityCollection = $this->getReserveQuantityCollection();
        return $reserveQuantityCollection ? $reserveQuantityCollection->getQuantity() : 0;
    }
 
    public function isReservableItem(): bool
    {
        return !$this->isBundleParent() && !$this->isService();
    }
 
    public function getNotPurchasedQuantity() : float
    {
        $quantity = parent::getNotPurchasedQuantity();
 
        $order = $this->getCollection()->getOrder();
        if ($order)
        {
            $quantity -= $order->getShipmentCollection()->getBasketItemShippedQuantity($this);
        }
 
        return $quantity;
    }
 
    public function isService(): bool
    {
        return (int)$this->getField('TYPE') === static::TYPE_SERVICE;
    }
}