shipmentcollection.php

<?php
 
namespace Bitrix\Sale;
 
use Bitrix\Main;
use Bitrix\Main\Entity;
use Bitrix\Main\Localization\Loc;
use Bitrix\Sale\Delivery;
use Bitrix\Sale\Internals;
use Bitrix\Sale\Reservation\Configuration\ReserveCondition;
 
Loc::loadMessages(__FILE__);
 
class ShipmentCollection
    extends Internals\EntityCollection
{
    protected $order;
 
    protected function getEntityParent()
    {
        return $this->getOrder();
    }
 
    public function resetCollection()
    {
        $result = new Result();
 
        $deliveryInfo = array();
 
        if (count($this->collection) > 0)
        {
            foreach ($this->collection as $shipment)
            {
                if (empty($deliveryInfo))
                {
                    if ($shipment->isSystem() && $shipment->getDeliveryId() > 0)
                    {
                        foreach (static::getClonedFields() as $field)
                        {
                            if (strval(trim($shipment->getField($field))) != '')
                                $deliveryInfo[$field] = trim($shipment->getField($field));
                        }
                    }
                }
                $shipment->delete();
            }
        }
 
        $systemShipment = $this->getSystemShipment();
 
        $systemShipmentItemCollection = $systemShipment->getShipmentItemCollection();
 
        $basket = $this->getOrder()->getBasket();
        $systemShipmentItemCollection->resetCollection($basket);
 
        if (!empty($deliveryInfo))
        {
            $systemShipment->setFieldsNoDemand($deliveryInfo);
        }
 
        if (
            Configuration::isEnableAutomaticReservation()
            && Configuration::getProductReservationCondition() == ReserveCondition::ON_CREATE
        )
        {
            $r = $this->tryReserve();
            if (!$r->isSuccess())
            {
                $result->addErrors($r->getErrors());
            }
        }
 
        return $result;
    }
 
    protected function getDeletableItems()
    {
        return $this->getNotSystemItems();
    }
 
    public function createItem(Delivery\Services\Base $delivery = null)
    {
        $shipmentClassName = static::getItemCollectionClassName();
        $shipment = $shipmentClassName::create($this, $delivery);
        $this->addItem($shipment);
 
        return $shipment;
    }
 
    protected function addItem(Internals\CollectableEntity $shipment)
    {
        $shipment = parent::addItem($shipment);
 
        if (!$order = $this->getOrder())
        {
            throw new Main\ObjectNotFoundException('Entity "Order" not found');
        }
 
        $order->onShipmentCollectionModify(EventActions::ADD, $shipment);
 
        return $shipment;
    }
 
    public function deleteItem($index)
    {
        $result = new Result();
        $oldItem = parent::deleteItem($index);
 
        if ($oldItem->getId() > 0 && !$oldItem->isSystem() && ($systemShipment = $this->getSystemShipment()) && $systemShipment->getId() == 0)
        {
            $r = $this->cloneShipment($oldItem, $systemShipment);
            if (!$r->isSuccess())
            {
                $result->addErrors($r->getErrors());
            }
        }
 
        $order = $this->getOrder();
        $order->onShipmentCollectionModify(EventActions::DELETE, $oldItem);
    }
 
    public function onItemModify(Internals\CollectableEntity $item, $name = null, $oldValue = null, $value = null)
    {
        $order = $this->getOrder();
 
        if ($item instanceof Shipment)
        {
            return $order->onShipmentCollectionModify(EventActions::UPDATE, $item, $name, $oldValue, $value);
        }
 
        return new Result();
    }
 
    public function getOrder()
    {
        return $this->order;
    }
 
    public static function load(Order $order)
    {
        $shipmentCollection = static::createShipmentCollectionObject();
        $shipmentCollection->setOrder($order);
 
        if ($order->getId() > 0)
        {
            $shipmentClassName = static::getItemCollectionClassName();
            $shipmentList = $shipmentClassName::loadForOrder($order->getId());
            foreach ($shipmentList as $shipment)
            {
                $shipment->setCollection($shipmentCollection);
                $shipmentCollection->addItem($shipment);
            }
 
            $controller = Internals\CustomFieldsController::getInstance();
            $controller->initializeCollection($shipmentCollection);
        }
 
        return $shipmentCollection;
    }
 
    private static function createShipmentCollectionObject()
    {
        $registry = Registry::getInstance(static::getRegistryType());
        $className = $registry->getShipmentCollectionClassName();
 
        return new $className();
    }
 
    public static function getRegistryType()
    {
        return Registry::REGISTRY_TYPE_ORDER;
    }
 
    public function getSystemShipment()
    {
        foreach ($this->collection as $shipment)
        {
            if ($shipment->isSystem())
            {
                return $shipment;
            }
        }
 
        $shipmentClassName = static::getItemCollectionClassName();
        $shipment = $shipmentClassName::createSystem($this);
        $this->addItem($shipment);
 
        return $shipment;
    }
 
    public function isExistsSystemShipment()
    {
        foreach ($this->collection as $shipment)
        {
            if ($shipment->isSystem())
                return true;
        }
 
        return false;
    }
 
    public function save()
    {
        $result = new Entity\Result();
 
        if (!$order = $this->getOrder())
        {
            throw new Main\ObjectNotFoundException('Entity "Order" not found');
        }
 
        $itemsFromDb = array();
        if ($order->getId() > 0)
        {
            $itemsFromDbList = static::getList(
                array(
                    "filter" => array("ORDER_ID" => $order->getId()),
                    "select" => array("ID" , "DELIVERY_NAME", "DELIVERY_ID")
                )
            );
            while ($itemsFromDbItem = $itemsFromDbList->fetch())
                $itemsFromDb[$itemsFromDbItem["ID"]] = $itemsFromDbItem;
        }
 
        foreach ($this->collection as $shipment)
        {
            if ($shipment->isSystem())
                continue;
 
            if (($systemShipment = $this->getSystemShipment()) && $systemShipment->getId() == 0)
            {
                $r = $this->cloneShipment($shipment, $systemShipment);
                if ($r->isSuccess())
                {
                    break;
                }
                else
                {
                    $result->addErrors($r->getErrors());
                }
            }
        }
 
        $changeMeaningfulFields = array(
            "DELIVERY_LOCATION",
            "PRICE_DELIVERY",
            "CUSTOM_PRICE_DELIVERY",
            "ALLOW_DELIVERY",
            "DEDUCTED",
            "RESERVED",
            "DELIVERY_NAME",
            "DELIVERY_ID",
            "CANCELED",
            "MARKED",
            "SYSTEM",
            "COMPANY_ID",
            "DISCOUNT_PRICE",
            "BASE_PRICE_DELIVERY",
            "EXTERNAL_DELIVERY",
        );
 
        foreach ($this->collection as $shipment)
        {
            $isNew = (bool)($shipment->getId() <= 0);
            $isChanged = $shipment->isChanged();
 
            if ($order->getId() > 0 && $isChanged)
            {
                $logFields = array();
 
 
                $fields = $shipment->getFields();
                $originalValues = $fields->getOriginalValues();
 
                foreach($originalValues as $originalFieldName => $originalFieldValue)
                {
                    if (in_array($originalFieldName, $changeMeaningfulFields) && $shipment->getField($originalFieldName) != $originalFieldValue)
                    {
                        $logFields[$originalFieldName] = $shipment->getField($originalFieldName);
                        if (!$isNew)
                            $logFields['OLD_'.$originalFieldName] = $originalFieldValue;
                    }
                }
 
            }
 
            $r = $shipment->save();
            if ($r->isSuccess())
            {
                if ($order->getId() > 0)
                {
                    if ($isChanged)
                    {
                        $registry = Registry::getInstance(static::getRegistryType());
 
                        $orderHistory = $registry->getOrderHistoryClassName();
                        $orderHistory::addLog(
                            'SHIPMENT',
                            $order->getId(),
                            $isNew ? 'SHIPMENT_ADD' : 'SHIPMENT_UPDATE',
                            $shipment->getId(),
                            $shipment,
                            $logFields,
                            $orderHistory::SALE_ORDER_HISTORY_LOG_LEVEL_1
                        );
 
                        $orderHistory::addAction(
                            'SHIPMENT',
                            $order->getId(),
                            "SHIPMENT_SAVED",
                            $shipment->getId(),
                            $shipment,
                            array(),
                            OrderHistory::SALE_ORDER_HISTORY_ACTION_LOG_LEVEL_1
                        );
                    }
                }
 
            }
            else
            {
                $result->addErrors($r->getErrors());
            }
 
            if (isset($itemsFromDb[$shipment->getId()]))
                unset($itemsFromDb[$shipment->getId()]);
        }
 
        foreach ($itemsFromDb as $k => $v)
        {
            $v['ENTITY_REGISTRY_TYPE'] = static::getRegistryType();
 
            $event = new Main\Event('sale', "OnBeforeSaleShipmentDeleted", array(
                    'VALUES' => $v,
            ));
            $event->send();
 
            $this->deleteInternal($k);
            $this->deleteExtraServiceInternal($k);
 
            $event = new Main\Event('sale', "OnSaleShipmentDeleted", array(
                    'VALUES' => $v,
            ));
            $event->send();
 
            if ($order->getId() > 0)
            {
                $registry = Registry::getInstance(static::getRegistryType());
 
                $orderHistory = $registry->getOrderHistoryClassName();
                $orderHistory::addAction(
                    'SHIPMENT',
                    $order->getId(),
                    'SHIPMENT_REMOVED',
                    $k,
                    null,
                    array(
                        'ID' => $k,
                        'DELIVERY_NAME' => $v['DELIVERY_NAME'],
                        'DELIVERY_ID' => $v['DELIVERY_ID'],
                    )
                );
 
                $registry = Registry::getInstance(static::getRegistryType());
 
                $entityMarker = $registry->getEntityMarkerClassName();
                $entityMarker::deleteByFilter(array(
                     '=ORDER_ID' => $order->getId(),
                     '=ENTITY_TYPE' => $entityMarker::ENTITY_TYPE_SHIPMENT,
                     '=ENTITY_ID' => $k,
                 ));
            }
 
        }
 
        if ($order->getId() > 0)
        {
            $registry = Registry::getInstance(static::getRegistryType());
 
            $orderHistory = $registry->getOrderHistoryClassName();
            $orderHistory::collectEntityFields('SHIPMENT', $order->getId());
        }
 
        return $result;
    }
 
    public function setOrder(Order $order)
    {
        $this->order = $order;
    }
 
    public function cloneShipment(Shipment $parentShipment, Shipment $childShipment)
    {
        foreach (static::getClonedFields() as $fieldName)
        {
            $childShipment->setFieldNoDemand($fieldName, $parentShipment->getField($fieldName));
        }
 
        $childShipment->setExtraServices($parentShipment->getExtraServices());
        $childShipment->setStoreId($parentShipment->getStoreId());
        return new Result();
    }
 
    protected static function getClonedFields()
    {
        return array(
            'DELIVERY_LOCATION',
            'PARAMS',
            'DELIVERY_ID',
            'DELIVERY_NAME',
        );
    }
 
    public function isShipped()
    {
        if (!empty($this->collection) && is_array($this->collection))
        {
            foreach ($this->collection as $shipment)
            {
                if ($shipment->isSystem())
                {
                    if (!$shipment->isEmpty())
                    {
                        return false;
                    }
 
                    continue;
                }
 
                if (!$shipment->isShipped() && !$shipment->isEmpty())
                {
                    return false;
                }
            }
 
            return true;
        }
 
        return false;
    }
 
    public function hasShipped()
    {
        if (!empty($this->collection) && is_array($this->collection))
        {
            foreach ($this->collection as $shipment)
            {
                if ($shipment->isSystem())
                {
                    continue;
                }
 
                if ($shipment->isShipped() && !$shipment->isEmpty())
                {
                    return true;
                }
            }
        }
 
        return false;
    }
 
    public function isMarked()
    {
        if (!empty($this->collection) && is_array($this->collection))
        {
            foreach ($this->collection as $shipment)
            {
                if ($shipment->isSystem())
                    continue;
 
                if ($shipment->isMarked())
                    return true;
            }
        }
 
        return false;
    }
 
    public function isReserved()
    {
        if (!empty($this->collection) && is_array($this->collection))
        {
            foreach ($this->collection as $shipment)
            {
                if ($shipment->isSystem())
                {
                    if (count($this->collection) == 1)
                        return $shipment->isReserved();
 
                    continue;
                }
 
                if (!$shipment->isReserved())
                    return false;
            }
 
            return true;
        }
 
        return false;
    }
 
    public function isAllowDelivery()
    {
        if (!empty($this->collection) && is_array($this->collection))
        {
            foreach ($this->collection as $shipment)
            {
                if ($shipment->isSystem())
                {
                    if (!$shipment->isEmpty())
                    {
                        return false;
                    }
 
                    continue;
                }
 
                if (!$shipment->isAllowDelivery() && !$shipment->isEmpty())
                {
                    return false;
                }
            }
 
            return true;
        }
 
        return false;
    }
 
    public function hasAllowDelivery()
    {
        $collection = $this->getNotSystemItems();
 
        foreach ($collection as $shipment)
        {
            if ($shipment->isAllowDelivery())
            {
                return true;
            }
        }
 
        return false;
    }
 
    public function isEmptySystemShipment()
    {
        return $this->getSystemShipment()->isEmpty();
    }
 
    public function allowDelivery()
    {
        $result = new Result();
 
        $collection = $this->getNotSystemItems();
 
        foreach ($collection as $shipment)
        {
            $r = $shipment->allowDelivery();
            if (!$r->isSuccess())
            {
                $result->addErrors($r->getErrors());
            }
        }
        return $result;
    }
 
    public function disallowDelivery()
    {
        $result = new Result();
 
        $collection = $this->getNotSystemItems();
 
        foreach ($collection as $shipment)
        {
            $r = $shipment->disallowDelivery();
            if (!$r->isSuccess())
            {
                $result->addErrors($r->getErrors());
            }
        }
 
        return $result;
    }
 
    public function tryReserve()
    {
        $result = new Result();
 
        foreach ($this->collection as $shipment)
        {
            if ($shipment->isReserved() || $shipment->isShipped())
                continue;
 
            $r = $shipment->tryReserve();
            if (!$r->isSuccess())
            {
                $result->addErrors($r->getErrors());
            }
            elseif ($r->hasWarnings())
            {
                $result->addWarnings($r->getWarnings());
 
                $registry = Registry::getInstance(static::getRegistryType());
                $entityMarker = $registry->getEntityMarkerClassName();
                $entityMarker::addMarker($this->getOrder(), $shipment, $r);
                if (!$shipment->isSystem())
                {
                    $shipment->setField('MARKED', 'Y');
                }
            }
        }
        return $result;
    }
 
    public function tryUnreserve()
    {
        $result = new Result();
 
        if (!$order = $this->getOrder())
        {
            throw new Main\ObjectNotFoundException('Entity "Order" not found');
        }
        foreach ($this->collection as $shipment)
        {
            if ($shipment->isShipped())
            {
                if ($order &&
                    !Internals\ActionEntity::isTypeExists(
                        $order->getInternalId(),
                        Internals\ActionEntity::ACTION_ENTITY_SHIPMENT_RESERVED_QUANTITY
                    )
                )
                {
                    Internals\ActionEntity::add(
                        $order->getInternalId(),
                        Internals\ActionEntity::ACTION_ENTITY_SHIPMENT_RESERVED_QUANTITY,
                        array(
                            'METHOD' => 'Bitrix\Sale\Shipment::updateReservedFlag',
                            'PARAMS' => array($shipment)
                        )
                    );
                }
 
                continue;
            }
 
            $r = $shipment->tryUnreserve();
            if (!$r->isSuccess())
            {
                if (!$shipment->isSystem())
                {
                    $registry = Registry::getInstance(static::getRegistryType());
 
                    $entityMarker = $registry->getEntityMarkerClassName();
                    $entityMarker::addMarker($order, $shipment, $r);
 
                    $shipment->setField('MARKED', 'Y');
                }
                $result->addErrors($r->getErrors());
            }
            elseif ($r->hasWarnings())
            {
                $result->addWarnings($r->getWarnings());
            }
        }
 
        return $result;
    }
 
    public function onBeforeBasketItemDelete(BasketItem $basketItem)
    {
        $result = new Result();
 
        foreach ($this->collection as $shipment)
        {
            $r = $shipment->onBeforeBasketItemDelete($basketItem);
            if (!$r->isSuccess())
            {
                $result->addErrors($r->getErrors());
            }
        }
 
        return $result;
    }
 
    public function onBasketModify($action, BasketItemBase $basketItem, $name = null, $oldValue = null, $value = null) : Result
    {
        $result = new Result();
 
        if (!($basketItem instanceof BasketItem))
        {
            return $result;
        }
 
        if ($action === EventActions::DELETE)
        {
            $order = $this->getOrder();
            if ($order->getId() == 0 && !$order->isMathActionOnly())
            {
                $this->refreshData();
            }
 
            return $result;
        }
        elseif ($action === EventActions::ADD)
        {
            return $this->getSystemShipment()->onBasketModify($action, $basketItem, $name, $oldValue, $value);
        }
        elseif ($action !== EventActions::UPDATE)
        {
            return $result;
        }
 
        if ($name == 'QUANTITY')
        {
            if (!$this->isAllowAutoEdit($basketItem))
            {
                $result = $this->checkDistributedQuantity($basketItem, $value);
                if (!$result->isSuccess())
                {
                    return $result;
                }
            }
 
            $shipment = $this->getItemForAutoEdit($basketItem);
 
            if ($value - $oldValue > 0)
            {
                $r = $this->getSystemShipment()->onBasketModify($action, $basketItem, $name, $oldValue, $value);
                if (!$r->isSuccess())
                {
                    return $result->addErrors($r->getErrors());
                }
            }
 
            if ($shipment)
            {
                $r = $shipment->onBasketModify($action, $basketItem, $name, $oldValue, $value);
                if (!$r->isSuccess())
                {
                    $result->addErrors($r->getErrors());
                    return $result;
                }
            }
 
            if ($value - $oldValue < 0)
            {
                $r = $this->getSystemShipment()->onBasketModify($action, $basketItem, $name, $oldValue, $value);
                if (!$r->isSuccess())
                {
                    return $result->addErrors($r->getErrors());
                }
            }
        }
        elseif (in_array($name, ['WEIGHT', 'PRICE']))
        {
            foreach ($this->getNotSystemItems() as $shipment)
            {
                $shipment->onBasketModify($action, $basketItem, $name, $value, $oldValue);
            }
        }
 
        return $result;
    }
 
    private function getItemForAutoEdit(BasketItem $basketItem)
    {
        if ($this->isAllowAutoEdit($basketItem))
        {
            foreach ($this->getNotSystemItems() as $shipment)
            {
                return $shipment;
            }
        }
 
        return null;
    }
 
    protected function isAllowAutoEdit(BasketItem $basketItem)
    {
        if ($this->count() === 1
            ||
            (
                $this->count() === 2
                &&
                $this->isExistsSystemShipment()
            )
        )
        {
            if (!$this->getSystemShipment()->isExistBasketItem($basketItem)
                || (int)$basketItem->getId() === 0
            )
            {
                foreach ($this->getNotSystemItems() as $shipment)
                {
                    if (!$shipment->isAllowDelivery()
                        && !$shipment->isCanceled()
                        && !$shipment->isShipped()
                    )
                    {
                        if ($deliveryService = $shipment->getDelivery())
                        {
                            return $deliveryService->isAllowEditShipment();
                        }
                    }
                }
            }
        }
 
        return false;
    }
 
    private function checkDistributedQuantity(BasketItem $basketItem, $value)
    {
        $result = new Result();
 
        $basketItemQuantity = $this->getBasketItemDistributedQuantity($basketItem);
        if ($basketItemQuantity > $value)
        {
            $result->addError(new ResultError(
                Loc::getMessage('SALE_ORDER_SYSTEM_SHIPMENT_LESS_QUANTITY',
                    array(
                        '#PRODUCT_NAME#' => $basketItem->getField("NAME"),
                        '#BASKET_ITEM_QUANTITY#' => $basketItemQuantity,
                        '#BASKET_ITEM_MEASURE#' => $basketItem->getField("MEASURE_NAME"),
                        '#QUANTITY#' => $basketItemQuantity - $value
                    )
                ),
                'SALE_ORDER_SYSTEM_SHIPMENT_LESS_QUANTITY')
            );
        }
 
        return $result;
    }
 
    public function onOrderModify($name, $oldValue, $value)
    {
        $result = new Result();
 
        switch($name)
        {
            case "CANCELED":
                if ($value == "Y")
                {
                    $isShipped = false;
                    foreach ($this->collection as $shipment)
                    {
                        if ($shipment->isShipped())
                        {
                            $isShipped = true;
                            break;
                        }
                    }
 
                    if ($isShipped)
                    {
                        $result->addError(
                            new ResultError(
                                Loc::getMessage('SALE_ORDER_CANCEL_SHIPMENT_EXIST_SHIPPED'),
                                'SALE_ORDER_CANCEL_SHIPMENT_EXIST_SHIPPED'
                            )
                        );
 
                        return $result;
                    }
 
                    $this->tryUnreserve();
                }
                else if (Configuration::isEnableAutomaticReservation())
                {
                    foreach ($this->collection as $shipment)
                    {
                        if ($shipment->needReservation())
                        {
                            $r = $shipment->tryReserve();
                            if (!$r->isSuccess())
                            {
                                $registry = Registry::getInstance(static::getRegistryType());
 
                                $entityMarker = $registry->getEntityMarkerClassName();
                                $entityMarker::addMarker($this->getOrder(), $shipment, $r);
                                if (!$shipment->isSystem())
                                {
                                    $shipment->setField('MARKED', 'Y');
                                }
 
                                $result->addErrors($r->getErrors());
                            }
                        }
                    }
 
                }
            break;
 
            case "MARKED":
                if ($value == "N")
                {
                    foreach ($this->collection as $shipment)
                    {
                        if ($shipment->isSystem())
                            continue;
 
                        $shipment->setField('MARKED', $value);
                    }
                }
            break;
        }
 
        return $result;
    }
 
    public function refreshData()
    {
        $result = new Result();
 
        $this->resetData();
 
        $r = $this->calculateDelivery();
        if (!$r->isSuccess())
        {
            $result->addErrors($r->getErrors());
        }
 
        return $result;
    }
 
    public function calculateDelivery()
    {
        $result = new Result();
 
        $calculatedDeliveries = [];
 
        $collection = $this->getNotSystemItems();
 
        foreach ($collection as $shipment)
        {
            if ($shipment->getDeliveryId() == 0)
                continue;
 
            if ($shipment->isCustomPrice())
            {
                $priceDelivery = $shipment->getPrice();
 
                $calcResult = new Delivery\CalculationResult();
                $calcResult->setDeliveryPrice($priceDelivery);
            }
            else
            {
                $calcResult = $shipment->calculateDelivery();
                if (!$calcResult->isSuccess())
                {
                    $result->addErrors($calcResult->getErrors());
                    continue;
                }
 
                $priceDelivery = $calcResult->getPrice();
                if ($priceDelivery < 0)
                {
                    $result->addError(new ResultError(Loc::getMessage('SALE_ORDER_SHIPMENT_WRONG_DELIVERY_PRICE'), 'WRONG_DELIVERY_PRICE'));
                    continue;
                }
            }
 
            $priceDelivery = PriceMaths::roundPrecision($priceDelivery);
            $shipment->setField('BASE_PRICE_DELIVERY', $priceDelivery);
 
            $calculatedDeliveries[] = $calcResult;
        }
 
        $result->setData(['CALCULATED_DELIVERIES' => $calculatedDeliveries]);
 
        return $result;
    }
 
    public function resetData()
    {
        $collection = $this->getNotSystemItems();
 
        foreach ($collection as $shipment)
        {
            $shipment->resetData();
        }
    }
 
    public function getBasketItemDistributedQuantity(BasketItem $basketItem)
    {
        $collection = $this->getNotSystemItems();
 
        $allQuantity = 0;
 
        foreach ($collection as $shipment)
        {
            $allQuantity += $shipment->getBasketItemQuantity($basketItem);
        }
 
        return $allQuantity;
    }
 
    public function getBasketItemShippedQuantity(BasketItem $basketItem)
    {
        $quantity = 0;
 
        foreach ($this->collection as $shipment)
        {
            if ($shipment->isShipped())
            {
                $quantity += $shipment->getShipmentItemCollection()->getBasketItemQuantity($basketItem);
            }
        }
 
        return $quantity;
    }
 
    public function isExistBasketItem(BasketItem $basketItem, $includeSystemShipment = false)
    {
        foreach ($this->collection as $shipment)
        {
            if (!$includeSystemShipment && $shipment->isSystem())
            {
                continue;
            }
 
            return $shipment->isExistBasketItem($basketItem);
        }
 
        return false;
    }
    public function getBasePriceDelivery()
    {
        $collection = $this->getNotSystemItems();
 
        $sum = 0;
        foreach ($collection as $shipment)
        {
            $sum += $shipment->getField('BASE_PRICE_DELIVERY');
        }
 
        return $sum;
    }
 
    public function getPriceDelivery()
    {
        $collection = $this->getNotSystemItems();
 
        $sum = 0;
        foreach ($collection as $shipment)
        {
            $sum += $shipment->getPrice();
        }
 
 
        return $sum;
    }
 
    public function getItemByShipmentCode($itemCode)
    {
        foreach ($this->collection as $shipment)
        {
            $shipmentCode = $shipment->getShipmentCode();
            if ($itemCode == $shipmentCode)
                return $shipment;
 
        }
 
        return null;
    }
 
    public function verify()
    {
        $result = new Result();
 
        foreach ($this->collection as $shipment)
        {
            if ($shipment->isSystem())
            {
                continue;
            }
 
            $r = $shipment->verify();
            if (!$r->isSuccess())
            {
                $result->addErrors($r->getErrors());
 
                $registry = Registry::getInstance(static::getRegistryType());
 
                $entityMarker = $registry->getEntityMarkerClassName();
                $entityMarker::addMarker($this->getOrder(), $shipment, $r);
 
                $shipment->setField('MARKED', 'Y');
            }
        }
 
        return $result;
    }
 
    public function createClone(\SplObjectStorage $cloneEntity)
    {
        if ($this->isClone() && $cloneEntity->contains($this))
        {
            return $cloneEntity[$this];
        }
 
        $shipmentCollectionClone = parent::createClone($cloneEntity);
 
        if ($this->order)
        {
            if ($cloneEntity->contains($this->order))
            {
                $shipmentCollectionClone->order = $cloneEntity[$this->order];
            }
        }
 
        return $shipmentCollectionClone;
    }
 
    public function getErrorEntity($value)
    {
        $className = null;
        foreach ($this->collection as $shipment)
        {
            if ($className = $shipment->getErrorEntity($value))
            {
                break;
            }
        }
 
        return $className;
    }
 
    public function canAutoFixError($value)
    {
        $autoFix = false;
 
        foreach ($this->collection as $shipment)
        {
            if ($autoFix = $shipment->canAutoFixError($value))
            {
                break;
            }
        }
        return $autoFix;
    }
 
    public static function updateReservedFlag(ShipmentCollection $collection)
    {
        $result = new Result();
        foreach ($collection as $shipment)
        {
            $shipmentClassName = static::getItemCollectionClassName();
            $r = $shipmentClassName::updateReservedFlag($shipment);
            if (!$r->isSuccess())
            {
                $result->addErrors($r->getErrors());
            }
 
            if ($r->hasWarnings())
            {
                $result->addWarnings($r->getWarnings());
            }
        }
 
        return $result;
    }
 
    private static function getItemCollectionClassName()
    {
        $registry = Registry::getInstance(static::getRegistryType());
        return $registry->getShipmentClassName();
    }
 
    public static function getList(array $parameters = array())
    {
        return Internals\ShipmentTable::getList($parameters);
    }
 
    protected function deleteInternal($primary)
    {
        return Internals\ShipmentTable::deleteWithItems($primary);
    }
 
    protected function deleteExtraServiceInternal($shipmentId)
    {
        Internals\ShipmentExtraServiceTable::deleteByShipmentId($shipmentId);
    }
 
 
    public function getNotSystemItems()
    {
        $callback = function (Shipment $shipment)
        {
            return !$shipment->isSystem();
        };
 
        return new Internals\CollectionFilterIterator($this->getIterator(), $callback);
    }
 
}