shipmentitemcollection.php

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

<?php
namespace Bitrix\Sale;
 
use Bitrix\Main;
use Bitrix\Main\Localization\Loc;
use Bitrix\Sale\Internals;
use Bitrix\Sale\Internals\CollectableEntity;
 
Loc::loadMessages(__FILE__);
 
class ShipmentItemCollection
    extends Internals\EntityCollection
{
    protected $shipment;
 
    protected $shipmentItemIndexMap = array();

    protected function getEntityParent()
    {
        return $this->getShipment();
    }

    public function resetCollection(Basket $basket)
    {
        if ($this->getShipment()->isShipped())
        {
            throw new Main\NotSupportedException();
        }
 
        if (!empty($this->collection))
        {
            foreach ($this->collection as $shipmentItem)
            {
                $shipmentItem->setFieldNoDemand('QUANTITY', 0);
                $shipmentItem->delete();
            }
        }
 
        $quantityList = [];

        $shipmentCollection = $this->getShipment()->getCollection();

        foreach ($basket as $basketItem)
        {
            $quantityList[$basketItem->getBasketCode()] = $shipmentCollection->getBasketItemDistributedQuantity($basketItem);
        }

        $itemClassName = static::getItemCollectionClassName();

        foreach ($basket as $basketItem)
        {
            $shipmentItem = $itemClassName::create($this, $basketItem);
            $this->addItem($shipmentItem);
 
            $basketItemQuantity = 0;
 
            if (array_key_exists($basketItem->getBasketCode(), $quantityList))
            {
                $basketItemQuantity = $quantityList[$basketItem->getBasketCode()];
            }
 
            $quantity = $basketItem->getQuantity() - $basketItemQuantity;
 
            $shipmentItem->setFieldNoDemand("QUANTITY", $quantity);
 
            if ($basketItem->isBundleParent())
            {
                $this->addBundleToCollection($basketItem);
            }
        }
    }

    public function createItem(BasketItem $basketItem)
    {
        if ($this->getShipment()->isShipped())
        {
            return null;
        }
 
        $shipmentItem = $this->getItemByBasketCode($basketItem->getBasketCode());
        if ($shipmentItem !== null)
        {
            return $shipmentItem;
        }

        $itemClassName = static::getItemCollectionClassName();
 
        $shipmentItem = $itemClassName::create($this, $basketItem);
 
        $shipmentItem->setCollection($this);
        $this->addItem($shipmentItem);
 
        $shipment = $this->getShipment();
 
        if ($basketItem->isBundleParent() && !$shipment->isSystem())
        {
            $this->addBundleToCollection($basketItem);
        }
 
        return $shipmentItem;
    }

    private function addBundleToCollection(BasketItem $basketItem)
    {
        $result = new Result();

        if (!$bundleCollection = $basketItem->getBundleCollection())
        {
            throw new Main\ObjectNotFoundException('Entity "BundleCollection" not found');
        }
 
        if ($bundleCollection->getOrder() === null)
        {
            if ($basketCollection = $basketItem->getCollection())
            {
                if ($order = $basketCollection->getOrder())
                {
                    $bundleCollection->setOrder($order);
                }
            }
        }

        $shipment = $this->getShipment();

        if (!$shipmentCollection = $shipment->getCollection())
        {
            throw new Main\ObjectNotFoundException('Entity "ShipmentCollection" not found');
        }

        if (!$systemShipment = $shipmentCollection->getSystemShipment())
        {
            throw new Main\ObjectNotFoundException('Entity "System Shipment" not found');
        }

        if (!$systemShipmentItemCollection = $systemShipment->getShipmentItemCollection())
        {
            throw new Main\ObjectNotFoundException('Entity "ShipmentItemCollection" not found');
        }
 
        $baseQuantity = $basketItem->getQuantity();

        if ($systemShipmentItem = $systemShipmentItemCollection->getItemByBasketCode($basketItem->getBasketCode()))
        {
            $baseQuantity = $systemShipmentItem->getQuantity();
        }
 
        $bundleBaseQuantity = $basketItem->getBundleBaseQuantity();

        foreach ($bundleCollection as $bundleBasketItem)
        {
 
            if ($this->isExistsBasketItem($bundleBasketItem))
            {
                continue;
            }
 
            $bundleProductId = $bundleBasketItem->getProductId();
 
            if (!isset($bundleBaseQuantity[$bundleProductId]))
                throw new Main\ArgumentOutOfRangeException("bundle product id");
 
            $quantity = $bundleBaseQuantity[$bundleProductId] * $baseQuantity;
 
            if ($quantity == 0)
                continue;

            $itemClassName = static::getItemCollectionClassName();
            $shipmentItemBundle = $itemClassName::create($this, $bundleBasketItem);
            $this->addItem($shipmentItemBundle);
 
            if ($shipment->isSystem())
            {
                $shipmentItemBundle->setFieldNoDemand('QUANTITY', $quantity);
            }
            else
            {
                $r = $shipmentItemBundle->setQuantity($quantity);
                if (!$r->isSuccess())
                {
                    $result->addErrors($r->getErrors());
                }
            }
        }
 
        return $result;
    }

    protected function addItem(Internals\CollectableEntity $shipmentItem)
    {
        parent::addItem($shipmentItem);

        $shipment = $this->getShipment();
        $shipment->onShipmentItemCollectionModify(EventActions::ADD, $shipmentItem);
    }
 
    protected function bindItem(CollectableEntity $shipmentItem): CollectableEntity
    {
        $item = parent::bindItem($shipmentItem);
 
        $this->shipmentItemIndexMap[$shipmentItem->getBasketCode()] = $shipmentItem->getInternalIndex();
 
        return $item;
    }
 
    protected function createIndex()
    {
        $index = parent::createIndex();
        $shipment = $this->getShipment();
        return $shipment->getInternalIndex()."_".$index;
    }

    public function deleteItem($index)
    {
        $oldShipmentItem = parent::deleteItem($index);
 
        unset($this->shipmentItemIndexMap[$oldShipmentItem->getBasketCode()]);
 
        $shipment = $this->getShipment();
        $shipment->onShipmentItemCollectionModify(EventActions::DELETE, $oldShipmentItem);
    }

    public function onItemModify(Internals\CollectableEntity $item, $name = null, $oldValue = null, $value = null)
    {
        $shipment = $this->getShipment();
        return $shipment->onShipmentItemCollectionModify(EventActions::UPDATE, $item, $name, $oldValue, $value);
    }

    public function getItemByBasketCode($itemCode)
    {
        if (
            isset($this->shipmentItemIndexMap[$itemCode])
            && isset($this->collection[$this->shipmentItemIndexMap[$itemCode]])
        )
        {
            return $this->collection[$this->shipmentItemIndexMap[$itemCode]];
        }
 
        return null;
    }

    public function getItemByBasketId($itemId)
    {
        $itemId = (int)$itemId;
        foreach ($this->collection as $shippedItem)
        {
            $shippedItemId = (int)($shippedItem->getBasketId());
            if ($itemId === $shippedItemId)
                return $shippedItem;
        }
 
        return null;
    }

    public function getShippableItems()
    {
        $callback = function (ShipmentItem $shipmentItem)
        {
            return $shipmentItem->isShippable();
        };
 
        return new Internals\CollectionFilterIterator($this->getIterator(), $callback);
    }

    public function getSellableItems()
    {
        $callback = function (ShipmentItem $shipmentItem)
        {
            $basketItem = $shipmentItem->getBasketItem();
            if ($basketItem)
                return !$basketItem->isBundleChild();
 
            return true;
        };
 
        return new Internals\CollectionFilterIterator($this->getIterator(), $callback);
    }

    public function getPrice()
    {
        $price = 0;
 
        $sellableItems = $this->getSellableItems();
        foreach ($sellableItems as $shipmentItem)
        {
            if ($basketItem = $shipmentItem->getBasketItem())
            {
                $price += PriceMaths::roundPrecision($basketItem->getPriceWithVat() * $shipmentItem->getQuantity());
            }
        }
 
        return $price;
    }

    public function getWeight() : float
    {
        $weight = 0;

        foreach ($this->getShippableItems() as $shipmentItem)
        {
            $basketItem = $shipmentItem->getBasketItem();
 
            $weight += $basketItem->getWeight() * $shipmentItem->getQuantity();
        }
 
        return $weight;
    }

    public function getShipment()
    {
        return $this->shipment;
    }

    public function save()
    {
        $result = new Main\Entity\Result();

        if (!$shipment = $this->getShipment())
        {
            throw new Main\ObjectNotFoundException('Entity "Shipment" not found');
        }

        if (!$shipmentCollection = $shipment->getCollection())
        {
            throw new Main\ObjectNotFoundException('Entity "ShipmentCollection" not found');
        }

        if (!$order = $shipmentCollection->getOrder())
        {
            throw new Main\ObjectNotFoundException('Entity "Order" not found');
        }
 
        $itemsFromDb = array();
        if ($this->getShipment()->getId() > 0)
        {
            $itemsFromDbList = static::getList(
                array(
                    "filter" => array("ORDER_DELIVERY_ID" => $this->getShipment()->getId()),
                    "select" => array("ID", 'BASKET_ID')
                )
            );
            while ($itemsFromDbItem = $itemsFromDbList->fetch())
                $itemsFromDb[$itemsFromDbItem["ID"]] = $itemsFromDbItem;
        }
 

        foreach ($this->collection as $shipmentItem)
        {
            if (!$basketItem = $shipmentItem->getBasketItem())
            {
                continue;
            }
 
            if ($basketItem->isBundleParent())
            {
                $this->addBundleToCollection($basketItem);
            }
        }

        if (!$shipment = $this->getShipment())
        {
            throw new Main\ObjectNotFoundException('Entity "Shipment" not found');
        }
 
        $changeMeaningfulFields = array(
            "QUANTITY",
            "RESERVED_QUANTITY",
        );

        foreach ($this->collection as $shipmentItem)
        {
            if (!$basketItem = $shipmentItem->getBasketItem())
            {
                continue;
            }
 
            $isNew = (bool)($shipmentItem->getId() <= 0);
            $isChanged = $shipmentItem->isChanged();
 
            if ($order->getId() > 0 && $isChanged)
            {
                $logFields = array(
                    "BASKET_ID" => $basketItem->getId(),
                    "BASKET_ITEM_NAME" => $basketItem->getField("NAME"),
                    "BASKET_ITEM_PRODUCT_ID" => $basketItem->getField("PRODUCT_ID"),
                    "ORDER_DELIVERY_ID" => $shipmentItem->getField("ORDER_DELIVERY_ID"),
                );
 
                $fields = $shipmentItem->getFields();
                $originalValues = $fields->getOriginalValues();
 
                foreach($originalValues as $originalFieldName => $originalFieldValue)
                {
                    if (in_array($originalFieldName, $changeMeaningfulFields) && $shipmentItem->getField($originalFieldName) != $originalFieldValue)
                    {
                        $logFields[$originalFieldName] = $shipmentItem->getField($originalFieldName);
                        if (!$isNew)
                            $logFields['OLD_'.$originalFieldName] = $originalFieldValue;
                    }
                }
            }
 
            $r = $shipmentItem->save();
            if ($r->isSuccess())
            {
                if ($order->getId() > 0 && $isChanged)
                {
                    $registry = Registry::getInstance(static::getRegistryType());

                    $orderHistory = $registry->getOrderHistoryClassName();
                    $orderHistory::addLog(
                        'SHIPMENT_ITEM',
                        $order->getId(),
                        $isNew ? 'SHIPMENT_ITEM_ADD' : 'SHIPMENT_ITEM_UPDATE',
                        $shipmentItem->getId(),
                        $shipmentItem,
                        $logFields,
                        $orderHistory::SALE_ORDER_HISTORY_LOG_LEVEL_1
                    );
                }
            }
            else
            {
                $result->addErrors($r->getErrors());
            }
 
            if (isset($itemsFromDb[$shipmentItem->getId()]))
            {
                unset($itemsFromDb[$shipmentItem->getId()]);
            }
        }

        if (!$basket = $order->getBasket())
        {
            throw new Main\ObjectNotFoundException('Entity "Basket" not found');
        }
 
        foreach ($itemsFromDb as $k => $v)
        {
            $v['ENTITY_REGISTRY_TYPE'] = static::getRegistryType();

            $event = new Main\Event('sale', "OnBeforeSaleShipmentItemDeleted", array(
                    'VALUES' => $v,
            ));
            $event->send();
 
            static::deleteInternal($k);

            $event = new Main\Event('sale', "OnSaleShipmentItemDeleted", array(
                    'VALUES' => $v,
            ));
            $event->send();

            if ($basketItem = $basket->getItemById($k))
            {
                $registry = Registry::getInstance(static::getRegistryType());

                $orderHistory = $registry->getOrderHistoryClassName();
                $orderHistory::addAction(
                    'SHIPMENT',
                    $order->getId(),
                    'SHIPMENT_ITEM_BASKET_REMOVED',
                    $shipment->getId(),
                    null,
                    array(
                        'NAME' => $basketItem->getField('NAME'),
                        'QUANTITY' => $basketItem->getQuantity(),
                        'PRODUCT_ID' => $basketItem->getProductId(),
                    )
                );
            }
        }
 
        if ($order->getId() > 0)
        {
            $registry = Registry::getInstance(static::getRegistryType());

            $orderHistory = $registry->getOrderHistoryClassName();
            $orderHistory::collectEntityFields('SHIPMENT_ITEM', $order->getId());
        }
 
        return $result;
    }

    private static function createShipmentItemCollectionObject()
    {
        $registry = Registry::getInstance(static::getRegistryType());
        $shipmentItemCollectionClassName = $registry->getShipmentItemCollectionClassName();
 
        return new $shipmentItemCollectionClassName();
    }

    public static function getRegistryType()
    {
        return Registry::REGISTRY_TYPE_ORDER;
    }

    private static function getItemCollectionClassName()
    {
        $registry = Registry::getInstance(static::getRegistryType());
        return $registry->getShipmentItemClassName();
    }

    public static function load(Shipment $shipment)
    {
        $shipmentItemCollection = static::createShipmentItemCollectionObject();
        $shipmentItemCollection->shipment = $shipment;
 
        if ($shipment->getId() > 0)
        {
            if (!$shipmentCollection = $shipment->getCollection())
            {
                throw new Main\ObjectNotFoundException('Entity "ShipmentCollection" not found');
            }

            if (!$order = $shipmentCollection->getOrder())
            {
                throw new Main\ObjectNotFoundException('Entity "Order" not found');
            }

            $itemClassName = static::getItemCollectionClassName();
            $shipmentItemList = $itemClassName::loadForShipment($shipment->getId());

            foreach ($shipmentItemList as $shipmentItem)
            {
                $shipmentItem->setCollection($shipmentItemCollection);
                $shipmentItemCollection->bindItem($shipmentItem);
                
                if (!$basketItem = $shipmentItem->getBasketItem())
                {
                    $msg = Loc::getMessage("SALE_SHIPMENT_ITEM_COLLECTION_BASKET_ITEM_NOT_FOUND", array(
                        '#BASKET_ITEM_ID#' => $shipmentItem->getBasketId(),
                        '#SHIPMENT_ID#' => $shipment->getId(),
                        '#SHIPMENT_ITEM_ID#' => $shipmentItem->getId(),
                    ));
 
                    $r = new Result();
                    $r->addError( new ResultError($msg, 'SALE_SHIPMENT_ITEM_COLLECTION_BASKET_ITEM_NOT_FOUND'));
 
                    $registry = Registry::getInstance(static::getRegistryType());
                    $entityMarker = $registry->getEntityMarkerClassName();
                    $entityMarker::addMarker($order, $shipment, $r);
                    if (!$shipment->isSystem())
                    {
                        $shipment->setField('MARKED', 'Y');
                    }
                }
            }
        }
 
        return $shipmentItemCollection;
    }

    public static function getList(array $parameters = array())
    {
        return Internals\ShipmentItemTable::getList($parameters);
    }

    protected function deleteInternal($primary)
    {
        return Internals\ShipmentItemTable::deleteWithItems($primary);
    }

    public function onBeforeBasketItemDelete(BasketItem $basketItem)
    {
        $result = new Result();
 
        $r = $this->deleteByBasketItem($basketItem);
        if (!$r->isSuccess())
        {
            $result->addErrors($r->getErrors());
        }
 
        return $result;
    }

    public function onBasketModify($action, BasketItem $basketItem, $name = null, $oldValue = null, $value = null)
    {
        $result = new Result();
 
        if ($action === EventActions::ADD)
        {
            $shipmentItem = $this->createItem($basketItem);
            if ($shipmentItem)
            {
                $shipmentItem->onBasketModify($action, $basketItem, $name, $oldValue, $value);
            }
 
            return $result;
        }
        elseif ($action === EventActions::UPDATE)
        {
            $shipmentItem = $this->getItemByBasketCode($basketItem->getBasketCode());
 
            if (!$shipmentItem)
            {
                $shipmentItem = $this->createItem($basketItem);
            }
 
            $r = $shipmentItem->setField('QUANTITY', $value);
            if (!$r->isSuccess())
            {
                return $result->addErrors($r->getErrors());
            }
        }
 
        return $result;
    }

    protected function isExistsBasketItem(BasketItem $basketItem)
    {
        foreach ($this->collection as $shipmentItem)
        {
            if ($shipmentItem->getBasketCode() == $basketItem->getBasketCode())
                return true;
        }
 
        return false;
    }

    public function deleteByBasketItem(BasketItem $basketItem)
    {
        $result = new Result();
        $systemShipmentItem = null;

        if (!$shipment = $this->getShipment())
        {
            throw new Main\ObjectNotFoundException('Entity "Shipment" not found');
        }

        foreach ($this->collection as $shipmentItem)
        {
            if ($shipmentItem->getBasketCode() == $basketItem->getBasketCode())
            {
                if ($shipment->isSystem())
                {
                    $systemShipmentItem = $shipmentItem;
                    continue;
                }
 
                $r = $shipmentItem->delete();
                if (!$r->isSuccess())
                {
                    $result->addErrors($r->getErrors());
                }
            }
        }
 
        if ($systemShipmentItem !== null)
        {
            if ($systemShipmentItem->getReservedQuantity() > 0)
            {
                $r = $systemShipmentItem->tryUnreserve();
                if (!$r->isSuccess())
                {
                    $result->addErrors($r->getErrors());
                }
            }
 
            if ($result->isSuccess())
            {
                $systemShipmentItem->setFieldNoDemand('QUANTITY', 0);
                $r = $systemShipmentItem->delete();
                if (!$r->isSuccess())
                {
                    $result->addErrors($r->getErrors());
                }
            }
        }
 
        return $result;
    }

    public function isEmpty()
    {
        if (count($this->collection) == 0)
            return true;

        foreach ($this->collection as $item)
        {
            if ($item->getQuantity() > 0)
                return false;
        }
 
        return true;
    }

    public function getBasketItemQuantity(BasketItem $basketItem)
    {
        $quantity = 0;
 
        $shipmentItem = $this->getItemByBasketCode($basketItem->getBasketCode());
        if ($shipmentItem)
        {
            $quantity = $shipmentItem->getQuantity();
        }
 
        return $quantity;
    }

    public function isExistBasketItem(BasketItem $basketItem)
    {
        foreach ($this->collection as $shipmentItem)
        {
            if ($shipmentItem->getBasketCode() == $basketItem->getBasketCode())
            {
                return true;
            }
        }
 
        return false;
    }

    public function createClone(\SplObjectStorage $cloneEntity)
    {
        if ($this->isClone() && $cloneEntity->contains($this))
        {
            return $cloneEntity[$this];
        }

        $shipmentItemCollectionClone = parent::createClone($cloneEntity);

        if ($shipment = $this->shipment)
        {
            if (!$cloneEntity->contains($shipment))
            {
                $cloneEntity[$shipment] = $shipment->createClone($cloneEntity);
            }
 
            if ($cloneEntity->contains($shipment))
            {
                $shipmentItemCollectionClone->shipment = $cloneEntity[$shipment];
            }
        }
 
        return $shipmentItemCollectionClone;
    }

    public function getErrorEntity($value)
    {
        $className = null;

        foreach ($this->collection as $shipmentItem)
        {
            if ($className = $shipmentItem->getErrorEntity($value))
            {
                break;
            }
        }
 
        return $className;
    }

    public function canAutoFixError($value)
    {
        $autoFix = false;

        foreach ($this->collection as $shipmentItem)
        {
            if ($autoFix = $shipmentItem->canAutoFixError($value))
            {
                break;
            }
        }
        return $autoFix;
    }
 
}