shipmentitem.php

<?php
namespace Bitrix\Sale;
 
use Bitrix\Main;
use Bitrix\Sale\Internals;
use Bitrix\Main\Localization\Loc;
 
Loc::loadMessages(__FILE__);
 
class ShipmentItem
    extends Internals\CollectableEntity
    implements \IEntityMarker
{
    protected $basketItem;
 
    protected $shipmentItemStoreCollection;
 
    protected static $errors = [];
 
    public static function getAvailableFields()
    {
        return ['QUANTITY', 'RESERVED_QUANTITY', 'XML_ID'];
    }
 
    protected static function getMeaningfulFields()
    {
        return ['QUANTITY'];
    }
 
    public static function create(ShipmentItemCollection $collection, BasketItem $basketItem = null)
    {
        $fields = [
            'XML_ID' => static::generateXmlId(),
            'RESERVED_QUANTITY' => 0
        ];
 
        if ($basketItem !== null && $basketItem->getId() > 0)
        {
            $fields["BASKET_ID"] = $basketItem->getId();
        }
 
        $shipmentItem = static::createShipmentItemObject($fields);
        $shipmentItem->setCollection($collection);
 
        if ($basketItem !== null)
        {
            $shipmentItem->basketItem = $basketItem;
        }
 
        return $shipmentItem;
    }
 
    protected static function generateXmlId()
    {
        return uniqid('bx_');
    }
 
    public function delete()
    {
        $result = new Result();
 
        $shipment = $this->getCollection()->getShipment();
 
        $oldEntityValues = $this->fields->getOriginalValues();
 
        $event = new Main\Event('sale', "OnBeforeSaleShipmentItemEntityDeleted", [
                'ENTITY' => $this,
                'VALUES' => $oldEntityValues,
        ]);
        $event->send();
 
        foreach($event->getResults() as $eventResult)
        {
            if($eventResult->getType() == Main\EventResult::ERROR)
            {
                $errorMsg = new ResultError(
                    Loc::getMessage('SALE_EVENT_ON_BEFORE_SALESHIPMENTITEM_ENTITY_DELETED_ERROR'),
                    'SALE_EVENT_ON_BEFORE_SALESHIPMENTITEM_ENTITY_DELETED_ERROR'
                );
                if ($eventResultData = $eventResult->getParameters())
                {
                    if (isset($eventResultData) && $eventResultData instanceof ResultError)
                    {
                        $errorMsg = $eventResultData;
                    }
                }
 
                $result->addError($errorMsg);
            }
        }
 
        if (!$result->isSuccess())
        {
            return $result;
        }
 
 
        if (!$shipment->isSystem())
        {
            if ($shipment->isShipped())
            {
                if (!$basketItem = $this->getBasketItem())
                {
                    throw new Main\ObjectNotFoundException('Entity "BasketItem" not found');
                }
 
                $result->addError(
                    new ResultError(
                        Loc::getMessage('SALE_SHIPMENT_ITEM_SHIPMENT_ALREADY_SHIPPED_CANNOT_EDIT'),
                        'SALE_SHIPMENT_ITEM_SHIPMENT_ALREADY_SHIPPED_CANNOT_EDIT'
                    )
                );
 
                return $result;
            }
 
            $r = $this->setField("QUANTITY", 0);
 
            if (!$r->isSuccess())
            {
                return $result->addErrors($r->getErrors());
            }
        }
        elseif ($shipment->isSystem() && $this->getQuantity() > 1e-10)
        {
            throw new \ErrorException('System shipment not empty');
        }
 
        $r = parent::delete();
        if (!$r->isSuccess())
        {
            $result->addErrors($r->getErrors());
        }
 
 
        $event = new Main\Event('sale', "OnSaleShipmentItemEntityDeleted", [
                'ENTITY' => $this,
                'VALUES' => $oldEntityValues,
        ]);
        $event->send();
 
        foreach($event->getResults() as $eventResult)
        {
            if($eventResult->getType() == Main\EventResult::ERROR)
            {
                $errorMsg = new ResultError(
                    Loc::getMessage('SALE_EVENT_ON_SALESHIPMENTITEM_ENTITY_DELETED_ERROR'),
                    'SALE_EVENT_ON_SALESHIPMENTITEM_ENTITY_DELETED_ERROR'
                );
                $eventResultData = $eventResult->getParameters();
                if (isset($eventResultData) && $eventResultData instanceof ResultError)
                {
                    $errorMsg = $eventResultData;
                }
 
                $result->addError($errorMsg);
            }
        }
 
        return $result;
    }
 
    public function getQuantity()
    {
        return (float)$this->getField('QUANTITY');
    }
 
    protected function onFieldModify($name, $oldValue, $value)
    {
        $result = new Result();
 
        $shipment = $this->getCollection()->getShipment();
 
        $order = $shipment->getCollection()->getOrder();
 
        if ($shipment->isShipped())
        {
            return $result->addError(
                new ResultError(
                    Loc::getMessage('SALE_SHIPMENT_ITEM_SHIPMENT_ALREADY_SHIPPED_CANNOT_EDIT'),
                    'SALE_SHIPMENT_ITEM_SHIPMENT_ALREADY_SHIPPED_CANNOT_EDIT'
                )
            );
        }
 
        if ($name == "QUANTITY")
        {
            if (!$basketItem = $this->getBasketItem())
            {
                if ($value != 0)
                {
                    throw new Main\ObjectNotFoundException('Entity "BasketItem" not found');
                }
            }
 
            $deltaQuantity = $value - $oldValue;
 
            if ($basketItem && $deltaQuantity > 0)
            {
                $systemShipment = $shipment->getCollection()->getSystemShipment();
 
                $systemBasketItemQuantity = $systemShipment->getBasketItemQuantity($basketItem);
                if ($systemBasketItemQuantity < abs($deltaQuantity))
                {
                    $errorBasketCode = $basketItem->getBasketCode();
 
                    if ($basketItem->isBundleChild())
                    {
                        if (!($parentBasketItem = $basketItem->getParentBasketItem()))
                        {
                            throw new Main\ObjectNotFoundException('Entity "Parent Basket Item" not found');
                        }
 
                        $errorBasketCode = $parentBasketItem->getBasketCode();
                    }
 
                    if (isset(static::$errors[$errorBasketCode][$basketItem->getField('ORDER_DELIVERY_BASKET_ID')]['STORE_QUANTITY_LARGER_ALLOWED']))
                    {
                        static::$errors[$errorBasketCode][$basketItem->getField('ORDER_DELIVERY_BASKET_ID')]['STORE_QUANTITY_LARGER_ALLOWED'] += $basketItem->getQuantity();
                    }
                    else
                    {
                        $result->addError(
                            new ResultError(
                                Loc::getMessage(
                                    'SALE_SHIPMENT_ITEM_LESS_AVAILABLE_QUANTITY_2',
                                    [
                                        '#PRODUCT_NAME#' => $basketItem->getField('NAME'),
                                    ]
                                ), 'SALE_SHIPMENT_ITEM_LESS_AVAILABLE_QUANTITY'
                            )
                        );
 
                        static::$errors[$errorBasketCode][$basketItem->getField('ORDER_DELIVERY_BASKET_ID')]['STORE_QUANTITY_LARGER_ALLOWED'] = $basketItem->getQuantity();
                    }
 
                    return $result;
                }
            }
 
 
            if ($basketItem)
            {
                if (!$this->isMathActionOnly())
                {
                    $r = $this->calculateDelivery();
                    if (!$r->isSuccess())
                    {
                        $result->addErrors($r->getErrors());
                    }
                }
            }
 
            $shipmentItemStoreCollection = $this->getShipmentItemStoreCollection();
            if (
                !$shipmentItemStoreCollection
                && $basketItem->isReservableItem()
            )
            {
                throw new Main\ObjectNotFoundException('Entity "ShipmentItemStoreCollection" not found');
            }
 
            if ($shipmentItemStoreCollection)
            {
                if ((int)$value === 0)
                {
                    $basketItemName = Loc::getMessage("SALE_SHIPMENT_ITEM_BASKET_WRONG_BASKET_ITEM");
                    $basketItemProductId = '1';
 
                    if ($basketItem)
                    {
                        $basketItemName = $basketItem->getField('NAME');
                        $basketItemProductId = $basketItem->getProductId();
                    }
 
                    $registry = Registry::getInstance(static::getRegistryType());
 
                    $orderHistory = $registry->getOrderHistoryClassName();
                    $orderHistory::addAction(
                        'SHIPMENT',
                        $order->getId(),
                        'SHIPMENT_ITEM_BASKET_REMOVED',
                        $shipment->getId(),
                        null,
                        [
                            'NAME' => $basketItemName,
                            'PRODUCT_ID' => $basketItemProductId,
                        ]
                    );
 
                    foreach ($shipmentItemStoreCollection as $shipmentItemStore)
                    {
                        $shipmentItemStore->delete();
                    }
 
                }
                elseif ($basketItem->isReservableItem())
                {
                    // check barcodes
                    $r = $shipmentItemStoreCollection->onShipmentItemModify(EventActions::UPDATE, $this, $name, $oldValue, $value);
                    if (!$r->isSuccess())
                    {
                        $result->addErrors($r->getErrors());
                        return $result;
                    }
 
                    $barcodeQuantity = $shipmentItemStoreCollection->getQuantityByBasketCode($basketItem->getBasketCode());
                    if ($barcodeQuantity > $value)
                    {
                        $result->addError(
                            new ResultError(
                                Loc::getMessage('SALE_SHIPMENT_ITEM_BARCODE_MORE_ITEM_QUANTITY'),
                                'BARCODE_MORE_ITEM_QUANTITY'
                            )
                        );
 
                        return $result;
                    }
                }
            }
 
            if (!$basketItem)
            {
                return $result;
            }
        }
 
 
        return parent::onFieldModify($name, $oldValue, $value);
    }
 
    public function checkMarkingCodeOnDeducted()
    {
        $result = new Result();
 
        if (
            !$this->getBasketItem()->isReservableItem()
            || !$this->getBasketItem()->isSupportedMarkingCode()
        )
        {
            return $result;
        }
 
        $shipmentItemStoreCollection = $this->getShipmentItemStoreCollection();
        if ($shipmentItemStoreCollection && $shipmentItemStoreCollection->count() < $this->getQuantity())
        {
            return $result->addError(
                new Main\Error(
                    Loc::getMessage(
                        'SALE_SHIPMENT_ITEM_MARKING_CODE_LESS_ITEM_QUANTITY_LONG_2',
                        ['#PRODUCT_NAME#' => $this->getBasketItem()->getField('NAME')])
                )
            );
        }
 
        foreach ($shipmentItemStoreCollection as $itemStore)
        {
            if ($itemStore->getMarkingCode() === '')
            {
                return $result->addError(
                    new Main\Error(
                        Loc::getMessage(
                            'SALE_SHIPMENT_ITEM_MARKING_CODE_LESS_ITEM_QUANTITY_LONG_2',
                            ['#PRODUCT_NAME#' => $this->getBasketItem()->getField('NAME')])
                    )
                );
            }
        }
 
        return $result;
    }
 
    public function setQuantity($quantity)
    {
        return $this->setField('QUANTITY', (float)$quantity);
    }
 
    public function setField($name, $value)
    {
        if ($name === 'RESERVED_QUANTITY')
        {
            $oldValue = $this->getReservedQuantity();
 
            $result = parent::setField($name, $value);
            if ($result->isSuccess())
            {
                $this->setReserveQuantity($value, $oldValue);
            }
 
            return $result;
        }
 
        return parent::setField($name, $value);
    }
 
    public function setFieldNoDemand($name, $value)
    {
        if ($name === 'RESERVED_QUANTITY')
        {
            $oldValue = $this->getReservedQuantity();
 
            parent::setFieldNoDemand($name, $value);
 
            $this->setReserveQuantity($value, $oldValue);
 
            return;
        }
 
        parent::setFieldNoDemand($name, $value);
    }
 
    protected function setReserveQuantity($value, $oldValue)
    {
        $result = new Result();
 
        $basketItem = $this->getBasketItem();
 
        $reserveCollection = $basketItem->getReserveQuantityCollection();
        if (!$reserveCollection)
        {
            return $result;
        }
 
        if ($value - $oldValue > 0) // plus
        {
            $reserve = null;
            foreach ($reserveCollection as $reserve)
            {
                break;
            }
 
            if ($reserve === null)
            {
                $reserve = $reserveCollection->create();
            }
 
            $settableReserveQuantity = $reserve->getQuantity() + $value - $oldValue;
            $reserve->setFieldNoDemand('QUANTITY', $settableReserveQuantity);
        }
        else // minus
        {
            $delta = abs($value - $oldValue);
 
            foreach ($reserveCollection as $reserve)
            {
                if ($delta === 0)
                {
                    break;
                }
 
                if ($reserve->getQuantity() > $delta)
                {
                    $settableReserveQuantity = $reserve->getQuantity() - $delta;
                    $reserve->setFieldNoDemand('QUANTITY', $settableReserveQuantity);
 
                    break;
                }
 
                $delta -= $reserve->getQuantity();
                $reserve->deleteNoDemand();
            }
        }
 
        return $result;
    }
 
    public function getReservedQuantity(): float
    {
        return $this->getField('RESERVED_QUANTITY');
    }
 
    public function getBasketId()
    {
        return (int)$this->getField('BASKET_ID');
    }
 
    public function getBasketCode()
    {
        if ($basketItem = $this->getBasketItem())
        {
            return $basketItem->getBasketCode();
        }
 
        return null;
    }
 
    public function getProductId()
    {
        $basketItem = $this->getBasketItem();
        if ($basketItem)
        {
            return $basketItem->getProductId();
        }
 
        return null;
    }
 
    public function save()
    {
        $this->checkCallingContext();
 
        $result = new Result();
 
        $id = $this->getId();
        $fields = $this->fields->getValues();
 
        $shipment = $this->getCollection()->getShipment();
 
        $order = $shipment->getCollection()->getOrder();
 
        if ($this->isChanged())
        {
            $event = new Main\Event('sale', 'OnBeforeSaleShipmentItemEntitySaved', [
                    'ENTITY' => $this,
                    'VALUES' => $this->fields->getOriginalValues()
            ]);
            $event->send();
        }
 
        if ($id > 0)
        {
            $fields = $this->fields->getChangedValues();
 
            if (!empty($fields) && is_array($fields))
            {
                if (!$shipment->isSystem())
                {
                    if (isset($fields["QUANTITY"]) && (floatval($fields["QUANTITY"]) == 0))
                    {
                        return $result;
                    }
                }
 
                $r = $this->updateInternal($id, $fields);
                if (!$r->isSuccess())
                {
                    $registry = Registry::getInstance(static::getRegistryType());
 
                    $orderHistory = $registry->getOrderHistoryClassName();
                    $orderHistory::addAction(
                        'SHIPMENT',
                        $order->getId(),
                        'SHIPMENT_ITEM_UPDATE_ERROR',
                        $id,
                        $this,
                        ["ERROR" => $r->getErrorMessages()]
                    );
 
                    $result->addErrors($r->getErrors());
                    return $result;
                }
 
                if ($resultData = $r->getData())
                    $result->setData($resultData);
            }
 
            if ($order && $order->getId() > 0)
            {
                $registry = Registry::getInstance(static::getRegistryType());
 
                $orderHistory = $registry->getOrderHistoryClassName();
                $orderHistory::collectEntityFields('SHIPMENT_ITEM_STORE', $order->getId(), $id);
            }
        }
        else
        {
            $fields['ORDER_DELIVERY_ID'] = $this->getParentShipmentId();
            $this->setFieldNoDemand('ORDER_DELIVERY_ID', $fields['ORDER_DELIVERY_ID']);
 
            $fields['DATE_INSERT'] = new Main\Type\DateTime();
            $this->setFieldNoDemand('DATE_INSERT', $fields['DATE_INSERT']);
 
            $fields["BASKET_ID"] = $this->basketItem->getId();
            $this->setFieldNoDemand('BASKET_ID', $fields['BASKET_ID']);
 
            if ($fields['BASKET_ID'] <= 0)
            {
                return $result;
            }
 
            if (!isset($fields["QUANTITY"]) || (floatval($fields["QUANTITY"]) == 0))
            {
                return $result;
            }
 
            $r = $this->addInternal($fields);
            if (!$r->isSuccess())
            {
                $registry = Registry::getInstance(static::getRegistryType());
 
                $orderHistory = $registry->getOrderHistoryClassName();
                $orderHistory::addAction(
                    'SHIPMENT',
                    $order->getId(),
                    'SHIPMENT_ITEM_ADD_ERROR',
                    null,
                    $this,
                    ["ERROR" => $r->getErrorMessages()]
                );
 
                $result->addErrors($r->getErrors());
                return $result;
            }
 
            if ($resultData = $r->getData())
                $result->setData($resultData);
 
            $id = $r->getId();
            $this->setFieldNoDemand('ID', $id);
 
            if (!$shipment->isSystem())
            {
                $registry = Registry::getInstance(static::getRegistryType());
 
                $orderHistory = $registry->getOrderHistoryClassName();
                $orderHistory::addAction(
                    'SHIPMENT',
                    $order->getId(),
                    'SHIPMENT_ITEM_BASKET_ADDED',
                    $shipment->getId(),
                    $this->basketItem,
                    [
                        'QUANTITY' => $this->getQuantity(),
                    ]
                );
            }
        }
 
        if ($id > 0)
        {
            $result->setId($id);
        }
 
        if ($this->isChanged())
        {
            $event = new Main\Event('sale', 'OnSaleShipmentItemEntitySaved', [
                'ENTITY' => $this,
                'VALUES' => $this->fields->getOriginalValues(),
            ]);
            $event->send();
        }
 
        $shipmentItemStoreCollection = $this->getShipmentItemStoreCollection();
        if ($shipmentItemStoreCollection)
        {
            $r = $shipmentItemStoreCollection->save();
            if (!$r->isSuccess())
            {
                $result->addErrors($r->getErrors());
            }
        }
 
        if ($result->isSuccess())
        {
            $registry = Registry::getInstance(static::getRegistryType());
 
            $orderHistory = $registry->getOrderHistoryClassName();
            $orderHistory::collectEntityFields('SHIPMENT_ITEM', $order->getId(), $id);
        }
 
        return $result;
    }
 
 
 
    private function checkCallingContext()
    {
        if (!$shipmentItemCollection = $this->getCollection())
        {
            throw new Main\ObjectNotFoundException('Entity "ShipmentItemCollection" not found');
        }
 
        if (!$shipment = $shipmentItemCollection->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');
        }
 
        if (!$order->isSaveRunning())
        {
            trigger_error("Incorrect call to the save process. Use method save() on \Bitrix\Sale\Order entity", E_USER_WARNING);
        }
    }
 
    private function getParentShipmentId()
    {
        $collection = $this->getCollection();
        $shipment = $collection->getShipment();
        return $shipment->getId();
    }
 
    public static function loadForShipment($id)
    {
        if (intval($id) <= 0)
            throw new Main\ArgumentNullException("id");
 
        $items = [];
 
        $itemDataList = static::getList([
            'filter' => [
                '=ORDER_DELIVERY_ID' => $id,
                '!BASKET.ID' => null
            ],
            'order' => ['DATE_INSERT' => 'ASC', 'ID' => 'ASC']
        ]);
 
        while ($itemData = $itemDataList->fetch())
            $items[] = static::createShipmentItemObject($itemData);
 
        return $items;
    }
 
    private static function createShipmentItemObject(array $itemData = [])
    {
        $registry = Registry::getInstance(static::getRegistryType());
        $shipmentItemClassName = $registry->getShipmentItemClassName();
 
        return new $shipmentItemClassName($itemData);
    }
 
    public static function getRegistryType()
    {
        return Registry::REGISTRY_TYPE_ORDER;
    }
 
    public static function getRegistryEntity()
    {
        return Registry::ENTITY_SHIPMENT_ITEM;
    }
 
    protected function loadBasketItem()
    {
        $collection = $this->getCollection();
 
        if (!$shipment = $collection->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');
        }
 
        if (!$basket = $order->getBasket())
        {
            throw new Main\ObjectNotFoundException('Entity "Basket" not found');
        }
 
        // [performance]
        // new ShipmentItem binds BasketItem on initialization
        // here we find BasketItem for already saved ShipmentItem (his ID is equal to CODE)
        return $basket->getItemByBasketCode($this->getBasketId());
    }
 
    public function getBasketItem()
    {
        if ($this->basketItem == null)
        {
            $this->basketItem = $this->loadBasketItem();
        }
 
        return $this->basketItem;
    }
 
    public function getShipmentItemStoreCollection()
    {
        if (!$this->getBasketItem()->isReservableItem())
        {
            return null;
        }
 
        if (empty($this->shipmentItemStoreCollection))
        {
            $registry = Registry::getInstance(static::getRegistryType());
 
            $itemStoreCollectionClassName = $registry->getShipmentItemStoreCollectionClassName();
            $this->shipmentItemStoreCollection = $itemStoreCollectionClassName::load($this);
        }
 
        return $this->shipmentItemStoreCollection;
    }
 
    public function onBasketModify($action, BasketItem $basketItem, $name = null, $oldValue = null, $value = null)
    {
        $result = new Result();
 
        if ($action === EventActions::ADD)
        {
            $this->setFieldNoDemand('QUANTITY', $basketItem->getQuantity());
        }
 
        return $result;
    }
 
    protected function calculateDelivery()
    {
        $result = new Result();
 
        $collection = $this->getCollection();
        $shipment = $collection->getShipment();
 
        $shipmentCollection = $shipment->getCollection();
 
        $order = $shipmentCollection->getOrder();
 
        if ($order->getId() > 0)
        {
            return $result;
        }
 
        $deliveryCalculate = $shipment->calculateDelivery();
        if (!$deliveryCalculate->isSuccess())
        {
            $result->addErrors($deliveryCalculate->getErrors());
        }
 
        if ($deliveryCalculate->getPrice() > 0)
        {
            $shipment->setField('BASE_PRICE_DELIVERY', $deliveryCalculate->getPrice());
        }
 
        return $result;
    }
 
 
    protected function addChangesToHistory($name, $oldValue = null, $value = null)
    {
        if ($this->getId() > 0)
        {
            if (!$shipmentItemCollection = $this->getCollection())
            {
                throw new Main\ObjectNotFoundException('Entity "ShipmentItemCollection" not found');
            }
 
            if (!$shipment = $shipmentItemCollection->getShipment())
            {
                throw new Main\ObjectNotFoundException('Entity "Shipment" not found');
            }
 
            if ($shipment->isSystem())
                return;
 
            if (!$shipmentCollection = $shipment->getCollection())
            {
                throw new Main\ObjectNotFoundException('Entity "ShipmentCollection" not found');
            }
 
            $historyFields = [];
 
            if ($basketItem = $this->getBasketItem())
            {
                $historyFields = [
                    'NAME' => $basketItem->getField('NAME'),
                    'PRODUCT_ID' => $basketItem->getField('PRODUCT_ID'),
                ];
            }
 
            if (($order = $shipmentCollection->getOrder()) && $order->getId() > 0)
            {
                $registry = Registry::getInstance(static::getRegistryType());
 
                $orderHistory = $registry->getOrderHistoryClassName();
                $orderHistory::addField(
                    'SHIPMENT_ITEM',
                    $order->getId(),
                    $name,
                    $oldValue,
                    $value,
                    $this->getId(),
                    $this,
                    $historyFields
                );
            }
 
 
        }
    }
 
    public function isChanged()
    {
        if (parent::isChanged())
        {
            return true;
        }
 
        $shipmentItemStoreCollection = $this->getShipmentItemStoreCollection();
        return $shipmentItemStoreCollection && $shipmentItemStoreCollection->isChanged();
    }
 
    public function tryReserve()
    {
        return Internals\Catalog\Provider::tryReserveShipmentItem($this);
    }
 
    public function tryUnreserve()
    {
        return Internals\Catalog\Provider::tryUnreserveShipmentItem($this);
    }
 
 
    public function verify()
    {
        $result = new Result();
 
        if (!$shipmentItemCollection = $this->getCollection())
        {
            throw new Main\ObjectNotFoundException('Entity "ShipmentItemCollection" not found');
        }
 
        if (!$shipment = $shipmentItemCollection->getShipment())
        {
            throw new Main\ObjectNotFoundException('Entity "Shipment" not found');
        }
 
        if (!$this->getBasketItem())
        {
            $result->addError(
                new ResultError(
                    Loc::getMessage(
                        'SALE_SHIPMENT_ITEM_BASKET_ITEM_NOT_FOUND',
                        [
                            '#BASKET_ITEM_ID#' => $this->getBasketId(),
                            '#SHIPMENT_ID#' => $shipment->getId(),
                            '#SHIPMENT_ITEM_ID#' => $this->getId(),
                        ]
                    ), 'SALE_SHIPMENT_ITEM_BASKET_ITEM_NOT_FOUND'
                )
            );
 
            return $result;
        }
 
        if ($this->getQuantity() <= 0)
        {
            $result->addError(
                new ResultError(
                    Loc::getMessage(
                        'SALE_SHIPMENT_ITEM_ERR_QUANTITY_EMPTY',
                        [
                            '#BASKET_ITEM_NAME#' => $this->getBasketItem()->getField('NAME'),
                        ]
                    ), 'SALE_SHIPMENT_ITEM_ERR_QUANTITY_EMPTY'
                )
            );
 
            return $result;
        }
 
        if ($shipmentItemStoreCollection = $this->getShipmentItemStoreCollection())
        {
            foreach ($shipmentItemStoreCollection as $shipmentItemStore)
            {
                $r = $shipmentItemStore->verify();
                if (!$r->isSuccess())
                {
                    $result->addErrors($r->getErrors());
                }
            }
        }
 
        return $result;
    }
 
    public static function getList(array $parameters)
    {
        return Internals\ShipmentItemTable::getList($parameters);
    }
 
    public function createClone(\SplObjectStorage $cloneEntity)
    {
        if ($this->isClone() && $cloneEntity->contains($this))
        {
            return $cloneEntity[$this];
        }
 
        $shipmentItemClone = parent::createClone($cloneEntity);
 
        if ($basketItem = $this->getBasketItem())
        {
            if (!$cloneEntity->contains($basketItem))
            {
                $cloneEntity[$basketItem] = $basketItem->createClone($cloneEntity);
            }
 
            if ($cloneEntity->contains($basketItem))
            {
                $shipmentItemClone->basketItem = $cloneEntity[$basketItem];
            }
        }
 
        if ($shipmentItemStoreCollection = $this->getShipmentItemStoreCollection())
        {
            if (!$cloneEntity->contains($shipmentItemStoreCollection))
            {
                $cloneEntity[$shipmentItemStoreCollection] = $shipmentItemStoreCollection->createClone($cloneEntity);
            }
 
            if ($cloneEntity->contains($shipmentItemStoreCollection))
            {
                $shipmentItemClone->shipmentItemStoreCollection = $cloneEntity[$shipmentItemStoreCollection];
            }
        }
 
        return $shipmentItemClone;
    }
 
 
    public function getErrorEntity($value)
    {
        static $className = null;
        $errorsList = static::getAutoFixErrorsList();
        if (is_array($errorsList) && in_array($value, $errorsList))
        {
            if ($className === null)
                $className = static::getClassName();
        }
        else
        {
            if ($shipmentItemStoreCollection = $this->getShipmentItemStoreCollection())
            {
                $className = $shipmentItemStoreCollection->getErrorEntity($value);
            }
        }
 
        return $className;
    }
 
 
    public function canAutoFixError($value)
    {
        $autoFix = false;
        $errorsList = static::getAutoFixErrorsList();
        if (is_array($errorsList) && in_array($value, $errorsList))
        {
            $autoFix = true;
        }
        else
        {
            if ($shipmentItemStoreCollection = $this->getShipmentItemStoreCollection())
            {
                $autoFix = $shipmentItemStoreCollection->canAutoFixError($value);
            }
        }
 
        return $autoFix;
    }
 
    public function getAutoFixErrorsList()
    {
        return [];
    }
 
    public function tryFixError($code)
    {
        return new Result();
    }
 
    public function canMarked()
    {
        return false;
    }
 
    public function getMarkField()
    {
        return null;
    }
 
    public function clearChanged()
    {
        parent::clearChanged();
 
        if ($shipmentItemStoreCollection = $this->getShipmentItemStoreCollection())
        {
            foreach ($shipmentItemStoreCollection as $shipmentItemStore)
            {
                $shipmentItemStore->clearChanged();
            }
        }
    }
 
    public function needReserve()
    {
        return
            $this->fields->isChanged('RESERVED_QUANTITY')
            || $this->getCollection()->getShipment()->getField('RESERVED') == 'Y'
        ;
    }
 
    public function getNeedReserveQuantity()
    {
        if (!$this->needReserve())
        {
            return 0;
        }
 
        $changedFields = $this->fields->getChangedValues();
        $originalFields = $this->fields->getOriginalValues();
 
        return $changedFields['RESERVED_QUANTITY'] - $originalFields['RESERVED_QUANTITY'];
    }
 
    protected function addInternal(array $data)
    {
        return Internals\ShipmentItemTable::add($data);
    }
 
    protected function updateInternal($primary, array $data)
    {
        return Internals\ShipmentItemTable::update($primary, $data);
    }
 
    protected static function getFieldsMap()
    {
        return Internals\ShipmentItemTable::getMap();
    }
 
    public static function getEntityEventName()
    {
        return 'SaleShipmentItem';
    }
 
    public function toArray(): array
    {
        $result = parent::toArray();
 
        $shipmentItemStoreCollection = $this->getShipmentItemStoreCollection();
        $result['STORES'] = $shipmentItemStoreCollection ? $shipmentItemStoreCollection->toArray() : [];
 
        return $result;
    }
 
    public function isShippable(): bool
    {
        $basketItem = $this->getBasketItem();
        if ($basketItem)
        {
            return !$basketItem->isBundleParent() && !$basketItem->isService();
        }
 
        return true;
    }
}