payableitemcollection.php

<?php
 
namespace Bitrix\Sale;
 
use Bitrix\Main;
 
Main\Localization\Loc::loadMessages(__FILE__);
 
class PayableItemCollection extends Internals\EntityCollection
{
    protected $payment;
 
    protected function getEntityParent()
    {
        return $this->getPayment();
    }
 
    public function getPayment() : Payment
    {
        return $this->payment;
    }
 
    protected static function createCollectionObject()
    {
        $registry = Registry::getInstance(static::getRegistryType());
        $className = $registry->get(Registry::ENTITY_PAYABLE_ITEM_COLLECTION);
 
        return new $className();
    }
 
    public static function getRegistryType()
    {
        return Registry::REGISTRY_TYPE_ORDER;
    }
 
    public function setPayment(Payment $payment)
    {
        $this->payment = $payment;
    }
 
    public static function load(Payment $payment)
    {
        $collection = static::createCollectionObject();
        $collection->setPayment($payment);
 
        if ($payment->getId() > 0)
        {
            $registry = Registry::getInstance(static::getRegistryType());
 
            $entity = $registry->get(Registry::ENTITY_PAYABLE_SHIPMENT);
 
            $items = $entity::loadForPayment($payment->getId());
            foreach ($items as $item)
            {
                $item->setCollection($collection);
                $collection->addItem($item);
            }
 
            $entity = $registry->get(Registry::ENTITY_PAYABLE_BASKET_ITEM);
 
            $items = $entity::loadForPayment($payment->getId());
            foreach ($items as $item)
            {
                $item->setCollection($collection);
                $collection->addItem($item);
            }
        }
 
        return $collection;
    }
 
    public static function getList(array $parameters = array())
    {
        return Internals\PayableItemTable::getList($parameters);
    }
 
    protected function addItem(Internals\CollectableEntity $item)
    {
        if (!$item instanceof PayableItem)
        {
            throw new Main\SystemException(
                Main\Localization\Loc::getMessage(
                    'SALE_PAYABLE_ITEM_COLLECTION_INCOMPATIBLE_ITEM_TYPE',
                    ['#CLASS#' => PayableItem::class]
                )
            );
        }
 
        return parent::addItem($item);
    }
 
    public function createItemByBasketItem(BasketItem $basketItem) : PayableBasketItem
    {
        foreach ($this->getBasketItems() as $item)
        {
            $payableBasketItem = $item->getEntityObject();
            if (
                $payableBasketItem
                && $basketItem->getBasketCode() === $payableBasketItem->getBasketCode())
            {
                return $item;
            }
        }
 
        $registry = Registry::getInstance(static::getRegistryType());
 
        $payableItemClass = $registry->get(Registry::ENTITY_PAYABLE_BASKET_ITEM);
 
        $payableItem = $payableItemClass::create($this, $basketItem);
        $this->addItem($payableItem);
 
        return $payableItem;
    }
 
    public function onBeforeBasketItemDelete(BasketItem $basketItem)
    {
        $result = new Result();
 
        foreach ($this->getBasketItems() as $item)
        {
            $entity = $item->getEntityObject();
            if ($entity->getBasketCode() === $basketItem->getBasketCode())
            {
                $r = $item->delete();
                if (!$r->isSuccess())
                {
                    $result->addErrors($r->getErrors());
                }
            }
        }
 
        return $result;
    }
 
    public function createItemByShipment(Shipment $shipment) : PayableShipmentItem
    {
        foreach ($this->getShipments() as $item)
        {
            if ($shipment->getInternalIndex() === $item->getEntityObject()->getInternalIndex())
            {
                return $item;
            }
        }
 
        $registry = Registry::getInstance(static::getRegistryType());
 
        $payableItemClass = $registry->get(Registry::ENTITY_PAYABLE_SHIPMENT);
 
        $payableItem = $payableItemClass::create($this, $shipment);
        $this->addItem($payableItem);
 
        return $payableItem;
    }
 
    public function getBasketItems() : Internals\CollectionFilterIterator
    {
        $callback = function (PayableItem $entity)
        {
            return $entity instanceof PayableBasketItem;
        };
 
        return new Internals\CollectionFilterIterator($this->getIterator(), $callback);
    }
 
    public function getShipments() : Internals\CollectionFilterIterator
    {
        $callback = function (PayableItem $entity)
        {
            return $entity instanceof PayableShipmentItem;
        };
 
        return new Internals\CollectionFilterIterator($this->getIterator(), $callback);
    }
 
    public function save()
    {
        $result = new Result();
 
        $dbRes = static::getList([
            'filter' => ['PAYMENT_ID' => $this->getPayment()->getId()]
        ]);
 
        while ($item = $dbRes->fetch())
        {
            if (!$this->getItemById($item['ID']))
            {
                static::deleteInternal($item['ID']);
            }
        }
 
        foreach ($this->collection as $entity)
        {
            $r = $entity->save();
            if (!$r->isSuccess())
            {
                $result->addErrors($r->getErrors());
            }
        }
 
        $this->clearChanged();
 
        return $result;
    }
 
    public static function deleteNoDemand($paymentId)
    {
        $result = new Result();
 
        $dbRes = static::getList([
            "filter" => ["=PAYMENT_ID" => $paymentId],
            "select" => ["ID"]
        ]);
 
        while ($entity = $dbRes->fetch())
        {
            $r = static::deleteInternal($entity['ID']);
            if (!$r->isSuccess())
            {
                $result->addErrors($r->getErrors());
            }
        }
 
        return $result;
    }
 
    protected static function deleteInternal($primary)
    {
        return Internals\PayableItemTable::delete($primary);
    }
 
    public function createClone(\SplObjectStorage $cloneEntity)
    {
        if ($this->isClone() && $cloneEntity->contains($this))
        {
            return $cloneEntity[$this];
        }
 
        $payableItemCollection = parent::createClone($cloneEntity);
 
        if ($this->payment)
        {
            if ($cloneEntity->contains($this->payment))
            {
                $payableItemCollection->payment = $cloneEntity[$this->payment];
            }
        }
 
        return $payableItemCollection;
    }
}