tradebindingcollection.php

<?php
 
namespace Bitrix\Sale;
 
use Bitrix\Main;
use Bitrix\Sale\Internals\CollectableEntity;
use Bitrix\Sale\TradingPlatform;
 
class TradeBindingCollection extends Internals\EntityCollection
{
    protected $order = null;
 
    protected function getEntityParent()
    {
        return $this->order;
    }
 
    public function getOrder()
    {
        return $this->order;
    }
 
    private static function createCollectionObject()
    {
        $registry = Registry::getInstance(static::getRegistryType());
        $className = $registry->get(Registry::ENTITY_TRADE_BINDING_COLLECTION);
 
        return new $className();
    }
 
    public static function getRegistryType()
    {
        return Registry::REGISTRY_TYPE_ORDER;
    }
 
    public function setOrder(Order $order)
    {
        $this->order = $order;
    }
 
    public static function load(Order $order)
    {
        $collection = static::createCollectionObject();
        $collection->setOrder($order);
 
        if (!$order->isNew())
        {
            $registry = Registry::getInstance(static::getRegistryType());
 
            $entity = $registry->get(Registry::ENTITY_TRADE_BINDING_ENTITY);
 
            $bindingList = $entity::loadForOrder($order->getId());
            foreach ($bindingList as $item)
            {
                $item->setCollection($collection);
                $collection->addItem($item);
            }
        }
 
        return $collection;
    }
 
    public static function getList(array $parameters = array())
    {
        return TradingPlatform\OrderTable::getList($parameters);
    }
 
    public function createItem(TradingPlatform\Platform $platform = null)
    {
        $registry = Registry::getInstance(static::getRegistryType());
 
        $tradeBindingEntity = $registry->get(Registry::ENTITY_TRADE_BINDING_ENTITY);
 
        $tradeBinding = $tradeBindingEntity::create($this, $platform);
        $this->addItem($tradeBinding);
 
        return $tradeBinding;
    }
 
    public function onItemModify(CollectableEntity $item, $name = null, $oldValue = null, $value = null)
    {
        $order = $this->getOrder();
 
        if ($item instanceof TradeBindingEntity)
        {
            $order->onTradeBindingCollectionModify(EventActions::UPDATE, $item, $name, $oldValue, $value);
        }
 
        return parent::onItemModify($item, $name, $oldValue, $value);
    }
 
    public function addItem(Internals\CollectableEntity $item)
    {
        if (!($item instanceof TradeBindingEntity))
        {
            throw new Main\NotSupportedException();
        }
 
        $entity = parent::addItem($item);
 
        $order = $this->getOrder();
        $order->onTradeBindingCollectionModify(EventActions::ADD, $entity);
 
        return  $entity;
    }
 
    public function deleteItem($index)
    {
        $oldItem = parent::deleteItem($index);
 
        $order = $this->getOrder();
        $order->onTradeBindingCollectionModify(EventActions::DELETE, $oldItem);
    }
 
    public function save()
    {
        $result = new Result();
 
        if (!$order = $this->getEntityParent())
        {
            throw new Main\ObjectNotFoundException('Entity "Order" not found');
        }
 
        if (!$order->isNew())
        {
            $itemsFromDbList = static::getList(
                array(
                    "filter" => array("ORDER_ID" => $order->getId())
                )
            );
 
            while ($item = $itemsFromDbList->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($idOrder)
    {
        $result = new Result();
 
        $dbRes = static::getList(
            array(
                "filter" => array("=ORDER_ID" => $idOrder),
                "select" => array("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 TradingPlatform\OrderTable::delete($primary);
    }
 
    public function createClone(\SplObjectStorage $cloneEntity)
    {
        if ($this->isClone() && $cloneEntity->contains($this))
        {
            return $cloneEntity[$this];
        }
 
        $tradeBindingCollection = parent::createClone($cloneEntity);
 
        if ($this->order)
        {
            if ($cloneEntity->contains($this->order))
            {
                $tradeBindingCollection->order = $cloneEntity[$this->order];
            }
        }
 
        return $tradeBindingCollection;
    }
 
    public function hasTradingPlatform(string $platformCode, string $type = null): bool
    {
        return $this->getTradingPlatform($platformCode, $type) ? true : false;
    }
 
    public function getTradingPlatform(string $platformCode, string $type = null)
    {
        foreach ($this->collection as $item)
        {
            $tradingPlatform = $item->getTradePlatform();
            if (!$tradingPlatform || $tradingPlatform::TRADING_PLATFORM_CODE !== $platformCode)
            {
                continue;
            }
 
            if (!is_null($type) && !$tradingPlatform->isOfType($type))
            {
                continue;
            }
 
            return $tradingPlatform;
        }
 
        return null;
    }
 
    public function getTradingPlatformIdList() : array
    {
        $result = [];
 
        foreach ($this->collection as $item)
        {
            $result[] = $item->getField('TRADING_PLATFORM_ID');
        }
 
        return $result;
    }
}