shipment.php

<?php
 
namespace Bitrix\Sale;
 
use Bitrix\Catalog\VatTable;
use Bitrix\Main;
use Bitrix\Main\Entity;
use Bitrix\Main\Localization\Loc;
use Bitrix\Sale\Delivery;
use Bitrix\Sale\Internals;
use \Bitrix\Sale\Delivery\Requests;
use Bitrix\Sale\Reservation\Configuration\ReserveCondition;
 
Loc::loadMessages(__FILE__);
 
class Shipment extends Internals\CollectableEntity implements IBusinessValueProvider, \IEntityMarker
{
    protected $shipmentItemCollection;
 
    protected $service = null;
 
    protected $extraServices = null;
 
    protected $storeId = null;
 
    protected $internalId = 0;
 
    protected static $idShipment = 0;
 
    protected $propertyCollection;
 
    protected $isNew = true;
 
    public static function getRegistryEntity()
    {
        return Registry::ENTITY_SHIPMENT;
    }
 
    public function getShipmentCode()
    {
        if ($this->internalId === 0)
        {
            if ($this->getId() > 0)
            {
                $this->internalId = $this->getId();
            }
            else
            {
                static::$idShipment++;
                $this->internalId = static::$idShipment;
            }
        }
        return $this->internalId;
    }
 
    public static function getAvailableFields()
    {
        return [
            "STATUS_ID",
            "BASE_PRICE_DELIVERY",
            "PRICE_DELIVERY",
            "ALLOW_DELIVERY",
            "DATE_ALLOW_DELIVERY",
            "EMP_ALLOW_DELIVERY_ID",
            "DEDUCTED",
            "DATE_DEDUCTED",
            "EMP_DEDUCTED_ID",
            "REASON_UNDO_DEDUCTED",
            "DELIVERY_ID",
            "DELIVERY_DOC_NUM",
            "DELIVERY_DOC_DATE",
            "TRACKING_NUMBER",
            "XML_ID",
            "PARAMS",
            "DELIVERY_NAME",
            "COMPANY_ID",
            "MARKED",
            "WEIGHT",
            "DATE_MARKED",
            "EMP_MARKED_ID",
            "REASON_MARKED",
            "CANCELED",
            "DATE_CANCELED",
            "EMP_CANCELED_ID",
            "RESPONSIBLE_ID",
            "DATE_RESPONSIBLE_ID",
            "EMP_RESPONSIBLE_ID",
            "COMMENTS",
            "CURRENCY",
            "CUSTOM_PRICE_DELIVERY",
            "UPDATED_1C",
            "EXTERNAL_DELIVERY",
            "VERSION_1C","ID_1C",
            "TRACKING_STATUS",
            "TRACKING_LAST_CHECK",
            "TRACKING_DESCRIPTION",
            "ACCOUNT_NUMBER",
            'DISCOUNT_PRICE'
        ];
    }
 
    public static function getCustomizableFields() : array
    {
        return ['PRICE_DELIVERY' => 'PRICE_DELIVERY', 'WEIGHT' => 'WEIGHT'];
    }
 
    protected function onBeforeSetFields(array $values)
    {
        if (isset($values['DEDUCTED']))
        {
            if ($this->getField('DEDUCTED') === 'Y')
            {
                if ($values['DEDUCTED'] === 'N')
                {
                    $values = ['DEDUCTED' => $values['DEDUCTED']] + $values;
                }
            }
            else
            {
                if ($values['DEDUCTED'] === 'Y')
                {
                    // move to the end of array
                    unset($values['DEDUCTED']);
                    $values['DEDUCTED'] = 'Y';
                }
            }
        }
 
        return $values;
    }
 
    protected static function getMeaningfulFields()
    {
        return array('BASE_PRICE_DELIVERY', 'DELIVERY_ID');
    }
 
    public function setDeliveryService(Delivery\Services\Base $service)
    {
        $this->service = $service;
 
        $result = $this->setField("DELIVERY_ID", $service->getId());
        if ($result->isSuccess())
        {
            $this->setField("DELIVERY_NAME", $service->getName());
        }
    }
 
    public static function create(ShipmentCollection $collection, Delivery\Services\Base $service = null)
    {
        $emptyService = Delivery\Services\Manager::getById(Delivery\Services\EmptyDeliveryService::getEmptyDeliveryServiceId());
        $fields = [
            'DATE_INSERT' => new Main\Type\DateTime(),
            'DELIVERY_ID' => $emptyService['ID'],
            'DELIVERY_NAME' => $emptyService['NAME'],
            'ALLOW_DELIVERY' => 'N',
            'DEDUCTED' => 'N',
            'CUSTOM_PRICE_DELIVERY' => 'N',
            'MARKED' => 'N',
            'CANCELED' => 'N',
            'SYSTEM' => 'N',
            'XML_ID' => static::generateXmlId(),
            'RESERVED' => 'N'
        ];
 
        $registry = Registry::getInstance(static::getRegistryType());
 
        $deliveryStatusClassName = $registry->getDeliveryStatusClassName();
        $fields['STATUS_ID'] = $deliveryStatusClassName::getInitialStatus();
 
        $shipment = static::createShipmentObject();
        $shipment->setFieldsNoDemand($fields);
        $shipment->setCollection($collection);
 
        if ($service !== null)
        {
            $shipment->setDeliveryService($service);
        }
 
        return $shipment;
    }
 
    protected static function generateXmlId()
    {
        return uniqid('bx_');
    }
 
    private static function createShipmentObject(array $fields = array())
    {
        $registry = Registry::getInstance(static::getRegistryType());
        $shipmentClassName = $registry->getShipmentClassName();
 
        return new $shipmentClassName($fields);
    }
 
    public static function getRegistryType()
    {
        return Registry::REGISTRY_TYPE_ORDER;
    }
 
    public function needReservation()
    {
        $condition = Configuration::getProductReservationCondition();
 
        if ($condition === ReserveCondition::ON_CREATE)
        {
            return true;
        }
 
        if ($condition === ReserveCondition::ON_PAY
            || $condition === ReserveCondition::ON_FULL_PAY)
        {
            $order = $this->getOrder();
            if ($condition === ReserveCondition::ON_FULL_PAY)
            {
                return $order->isPaid();
            }
 
            return $order->getPaymentCollection()->hasPaidPayment();
        }
 
        if ($this->isSystem())
        {
            return false;
        }
 
        return
            (
                $condition === ReserveCondition::ON_ALLOW_DELIVERY
                && $this->isAllowDelivery()
            )
            || (
                $condition === ReserveCondition::ON_SHIP
                && $this->isShipped()
            )
        ;
    }
 
    private function transferItem2SystemShipment(ShipmentItem $sourceItem, $quantity)
    {
        $sourceItemCollection = $sourceItem->getCollection();
        if ($this !== $sourceItemCollection->getShipment())
        {
            throw new Main\ArgumentException("item");
        }
 
        $quantity = floatval($quantity);
 
        $systemShipment = $this->getCollection()->getSystemShipment();
 
        $basketItem = $sourceItem->getBasketItem();
 
        $order = $basketItem->getCollection()->getOrder();
 
        $shipmentItemCode = $sourceItem->getBasketCode();
 
        if ($quantity === 0)
        {
            return new Result();
        }
 
        $systemShipmentItemCollection = $systemShipment->getShipmentItemCollection();
 
        $systemShipmentItem = $systemShipmentItemCollection->getItemByBasketCode($shipmentItemCode);
        if (is_null($systemShipmentItem))
        {
            $systemShipmentItem = $systemShipmentItemCollection->createItem($basketItem);
        }
 
        $newSystemShipmentItemQuantity = $systemShipmentItem->getQuantity() + $quantity;
        if ($newSystemShipmentItemQuantity < 0)
        {
            $result = new Result();
            $result->addError(
                new ResultError(
                    str_replace(
                        ["#NAME#", "#QUANTITY#"],
                        [$sourceItem->getBasketItem()->getField("NAME"), abs($quantity)],
                        Loc::getMessage('SALE_SHIPMENT_QUANTITY_MISMATCH')
                    ),
                    'SALE_SHIPMENT_QUANTITY_MISMATCH'
                )
            );
            return $result;
        }
 
        $systemShipmentItem->setFieldNoDemand('QUANTITY', $newSystemShipmentItemQuantity);
        if ($newSystemShipmentItemQuantity <= 1e-10)
        {
            $systemShipmentItem->delete();
        }
 
        $affectedQuantity = 0;
 
        if ($quantity > 0)  // transfer to system shipment
        {
            if ($sourceItem->getReservedQuantity() > 0)
            {
                $affectedQuantity = $quantity;
                $originalQuantity = $sourceItem->getQuantity() + $quantity;
                if ($sourceItem->getReservedQuantity() < $originalQuantity)
                {
                    $affectedQuantity -= $originalQuantity - $sourceItem->getReservedQuantity();
                }
            }
        }
        elseif ($quantity < 0)  // transfer from system shipment
        {
            if ($systemShipmentItem->getReservedQuantity() > 0)
            {
                $affectedQuantity = $quantity;
                if ($systemShipmentItem->getReservedQuantity() < -$affectedQuantity)
                {
                    $affectedQuantity = -1 * $systemShipmentItem->getReservedQuantity();
                }
            }
        }
 
        if ($affectedQuantity != 0)  // if there are reserved items among transferred
        {
            $sourceItem->getFields()->set(
                'RESERVED_QUANTITY',
                $sourceItem->getField('RESERVED_QUANTITY') - $affectedQuantity
            );
 
            $systemShipmentItem->getFields()->set(
                'RESERVED_QUANTITY',
                $systemShipmentItem->getField('RESERVED_QUANTITY') + $affectedQuantity
            );
 
            $systemShipment->setFieldNoDemand(
                'RESERVED',
                ($systemShipmentItem->getField("RESERVED_QUANTITY") > 0) ? "Y" : "N"
            );
 
            $shipmentItemForPool = $sourceItem;
            $sourceShipmentItemForPool = $systemShipmentItem;
 
            if ($quantity > 0)
            {
                $shipmentItemForPool = $systemShipmentItem;
                $sourceShipmentItemForPool = $sourceItem;
            }
 
            $productId = $basketItem->getProductId();
 
            $foundItem = false;
            $poolItems = Internals\ItemsPool::get($order->getInternalId(), $productId);
            if (!empty($poolItems))
            {
                foreach ($poolItems as $poolIndex => $poolItem)
                {
                    if ($poolItem->getInternalIndex() === $shipmentItemForPool->getInternalIndex())
                    {
                        $foundItem = true;
                    }
 
                    if (
                        $sourceShipmentItemForPool
                        && $poolItem instanceof ShipmentItem
                        && $poolItem->getInternalIndex() === $sourceShipmentItemForPool->getInternalIndex()
                    )
                    {
                        $reserveQuantity = $sourceShipmentItemForPool->getReservedQuantity();
                        if (abs($reserveQuantity) <= 1e-6)
                        {
                            Internals\ItemsPool::delete($order->getInternalId(), $productId, $poolIndex);
                        }
                    }
                }
            }
 
            if (!$foundItem)
            {
                Internals\ItemsPool::add($order->getInternalId(), $productId, $shipmentItemForPool);
            }
        }
 
        $tryReserveResult = null;
 
        if ($quantity > 0)
        {
            if (Configuration::isEnableAutomaticReservation())
            {
                if ($systemShipment->needReservation())
                {
                    $tryReserveResult = Internals\Catalog\Provider::tryReserveShipmentItem($systemShipmentItem);
                }
                else
                {
                    $tryReserveResult = Internals\Catalog\Provider::tryUnreserveShipmentItem($systemShipmentItem);
                }
            }
        }
        elseif ($quantity < 0)  // transfer from system shipment
        {
            if (
                Configuration::isEnableAutomaticReservation()
                && $sourceItemCollection->getShipment()->needReservation()
            )
            {
                $tryReserveResult = Internals\Catalog\Provider::tryReserveShipmentItem($sourceItem);
            }
        }
 
        $canReserve = false;
 
        if ($tryReserveResult === null)
        {
            $canReserve = true;
        }
 
        if ($tryReserveResult !== null && ($tryReserveResult->isSuccess() && ($tryReserveResultData = $tryReserveResult->getData())))
        {
            if (array_key_exists('CAN_RESERVE', $tryReserveResultData))
            {
                $canReserve = $tryReserveResultData['CAN_RESERVE'];
            }
        }
 
        if (
            Configuration::isEnableAutomaticReservation()
            && $systemShipment->needReservation()
            && $canReserve
        )
        {
            $order = $this->getOrder();
            if ($order &&
                !Internals\ActionEntity::isTypeExists(
                    $order->getInternalId(),
                    Internals\ActionEntity::ACTION_ENTITY_SHIPMENT_COLLECTION_RESERVED_QUANTITY
                )
            )
            {
                Internals\ActionEntity::add(
                    $order->getInternalId(),
                    Internals\ActionEntity::ACTION_ENTITY_SHIPMENT_COLLECTION_RESERVED_QUANTITY,
                    [
                        'METHOD' => 'Bitrix\Sale\ShipmentCollection::updateReservedFlag',
                        'PARAMS' => [$systemShipment->getCollection()]
                    ]
                );
            }
        }
 
 
        return new Result();
    }
 
    public static function updateReservedFlag(Shipment $shipment)
    {
        $shipmentReserved = true;
 
        $shipmentItemList = $shipment->getShipmentItemCollection()->getShippableItems();
 
        if ($shipmentItemList->count() === 0)
        {
            $shipmentReserved = false;
        }
 
        foreach ($shipmentItemList as $shipmentItem)
        {
            if ($shipmentItem->getQuantity() - $shipmentItem->getReservedQuantity())
            {
                $shipmentReserved = false;
                break;
            }
        }
 
        $shipmentReservedValue = $shipmentReserved ? "Y" : "N";
        $currentValue = $shipment->getField('RESERVED');
        if ($shipment->getField('RESERVED') != $shipmentReservedValue)
        {
            $eventManager = Main\EventManager::getInstance();
            $eventsList = $eventManager->findEventHandlers('sale', EventActions::EVENT_ON_BEFORE_SHIPMENT_RESERVE);
            if (!empty($eventsList))
            {
                $event = new Main\Event('sale', EventActions::EVENT_ON_BEFORE_SHIPMENT_RESERVE, [
                    'ENTITY' => $shipment,
                    'VALUE' => $shipmentReservedValue,
                ]);
 
                $event->send();
 
                if ($event->getResults())
                {
                    $result = new Result();
                    foreach($event->getResults() as $eventResult)
                    {
                        if($eventResult->getType() === Main\EventResult::ERROR)
                        {
                            $errorMsg = new ResultError(Main\Localization\Loc::getMessage('SALE_EVENT_ON_BEFORE_SHIPMENT_RESERVE_ERROR'), 'SALE_EVENT_ON_BEFORE_SHIPMENT_RESERVE_ERROR');
 
                            $eventResultData = $eventResult->getParameters();
                            if ($eventResultData)
                            {
                                if (isset($eventResultData) && $eventResultData instanceof ResultError)
                                {
                                    $errorMsg = $eventResultData;
                                }
                            }
 
                            $result->addError($errorMsg);
 
                        }
                    }
 
                    if (!$result->isSuccess())
                    {
                        return $result;
                    }
                }
            }
 
            $shipment->setFieldNoDemand('RESERVED', $shipmentReserved ? "Y" : "N");
 
            Internals\EventsPool::addEvent('s'.$shipment->getInternalIndex(), EventActions::EVENT_ON_SHIPMENT_RESERVED, [
                'ENTITY' => $shipment,
                'VALUE' => $shipmentReservedValue,
                'OLD_VALUE' => $currentValue,
            ]);
        }
 
        return new Result();
    }
 
    public function onShipmentItemCollectionModify($action, ShipmentItem $shipmentItem, $name = null, $oldValue = null, $value = null)
    {
        if ($action != EventActions::UPDATE)
        {
            return new Result();
        }
 
        if ($this->isSystem()
            && $name != 'RESERVED_QUANTITY'
        )
        {
            throw new Main\NotSupportedException(Loc::getMessage('SALE_SHIPMENT_SYSTEM_SHIPMENT_CHANGE'));
        }
 
        if ($name === "QUANTITY")
        {
            $result = $this->transferItem2SystemShipment($shipmentItem, $oldValue - $value);
 
            if (!$this->isMarkedFieldCustom('WEIGHT'))
            {
                $this->setField(
                    'WEIGHT',
                    $this->getShipmentItemCollection()->getWeight()
                );
            }
 
            return $result;
        }
        elseif ($name === 'RESERVED_QUANTITY')
        {
            $order = $this->getParentOrder();
            if ($order &&
                !Internals\ActionEntity::isTypeExists(
                    $order->getInternalId(),
                    Internals\ActionEntity::ACTION_ENTITY_SHIPMENT_COLLECTION_RESERVED_QUANTITY
                )
            )
            {
                Internals\ActionEntity::add(
                    $order->getInternalId(),
                    Internals\ActionEntity::ACTION_ENTITY_SHIPMENT_COLLECTION_RESERVED_QUANTITY,
                    [
                        'METHOD' => 'Bitrix\Sale\ShipmentCollection::updateReservedFlag',
                        'PARAMS' => [$this->getCollection()]
                    ]
                );
            }
        }
 
        return new Result();
    }
 
    public static function deleteNoDemand($orderId)
    {
        $result = new Result();
 
        $shipmentDataList = static::getList(
            [
                "filter" => ["=ORDER_ID" => $orderId],
                "select" => ["ID"]
            ]
        );
 
        while ($shipment = $shipmentDataList->fetch())
        {
            $res = static::deleteInternal($shipment['ID']);
 
            if ($res -> isSuccess())
            {
                Internals\ShipmentExtraServiceTable::deleteByShipmentId($shipment['ID']);
            }
            else
            {
                $result->addErrors($res->getErrors());
            }
        }
 
        return $result;
    }
 
    public function delete()
    {
        if ($this->isShipped())
        {
            $result = new Result();
            return $result->addError(
                new ResultError(
                    Loc::getMessage('SALE_SHIPMENT_EXIST_SHIPPED'),
                    'SALE_SHIPMENT_EXIST_SHIPPED'
                )
            );
        }
 
        if (!$this->isSystem())
        {
            $this->setField('BASE_PRICE_DELIVERY', 0);
 
            if ($this->getFields()->isMarkedCustom('PRICE_DELIVERY'))
            {
                $this->setField('PRICE_DELIVERY', 0);
            }
 
            $this->disallowDelivery();
        }
 
        $this->getPropertyCollection()->deleteNoDemand($this->getId());
        $this->deleteDeliveryRequest();
 
        $this->getShipmentItemCollection()->clearCollection();
 
        return parent::delete();
    }
 
    protected function deleteDeliveryRequest()
    {
        Requests\Manager::onBeforeShipmentDelete($this);
    }
 
    protected function normalizeValue($name, $value)
    {
        if ($this->isPriceField($name))
        {
            $value = PriceMaths::roundPrecision($value);
        }
        elseif ($name === 'REASON_MARKED')
        {
            $value = (string)$value;
            if (mb_strlen($value) > 255)
            {
                $value = mb_substr($value, 0, 255);
            }
        }
 
        return parent::normalizeValue($name, $value);
    }
 
    public function setField($name, $value)
    {
        if ($this->isSystem())
        {
            throw new Main\NotSupportedException();
        }
 
        if ($name === 'CUSTOM_PRICE_DELIVERY')
        {
            if ($value === 'Y')
            {
                $this->markFieldCustom('PRICE_DELIVERY');
            }
            else
            {
                $this->unmarkFieldCustom('PRICE_DELIVERY');
            }
        }
 
        return parent::setField($name, $value);
    }
 
    protected function checkValueBeforeSet($name, $value)
    {
        $result = parent::checkValueBeforeSet($name, $value);
 
        if ($name === "DELIVERY_ID")
        {
            if (intval($value) > 0 && !Delivery\Services\Manager::isServiceExist($value))
            {
                $result->addError(
                    new ResultError(
                        Loc::getMessage('SALE_SHIPMENT_WRONG_DELIVERY_SERVICE'),
                        'SALE_SHIPMENT_WRONG_DELIVERY_SERVICE'
                    )
                );
            }
        }
        elseif ($name === 'ACCOUNT_NUMBER')
        {
            $dbRes = static::getList([
                'select' => ['ID'],
                'filter' => ['=ACCOUNT_NUMBER' => $value]
            ]);
 
            if ($dbRes->fetch())
            {
                $result->addError(
                    new ResultError(
                        Loc::getMessage('SALE_SHIPMENT_ACCOUNT_NUMBER_EXISTS')
                    )
                );
            }
        }
 
        return $result;
    }
 
    public function setFieldNoDemand($name, $value)
    {
        if ($name === 'CUSTOM_PRICE_DELIVERY')
        {
            if ($value === 'Y')
            {
                $this->markFieldCustom('PRICE_DELIVERY');
            }
            else
            {
                $this->unmarkFieldCustom('PRICE_DELIVERY');
            }
        }
 
        parent::setFieldNoDemand($name, $value);
    }
 
    public static function loadForOrder($id)
    {
        if (intval($id) <= 0)
        {
            throw new Main\ArgumentNullException("id");
        }
 
        $shipments = [];
 
        $shipmentDataList = static::getList(static::getParametersForLoad($id));
        while ($shipmentData = $shipmentDataList->fetch())
        {
            $shipments[] = static::createShipmentObject($shipmentData);
        }
 
 
        return $shipments;
    }
 
    protected static function getParametersForLoad($id) : array
    {
        return [
            'filter' => [
                'ORDER_ID' => $id
            ],
            'order' => [
                'SYSTEM' => 'ASC',
                'DATE_INSERT' => 'ASC',
                'ID' => 'ASC'
            ]
        ];
    }
 
    public function save()
    {
        $this->checkCallingContext();
 
        $result = new Result();
 
        $id = $this->getId();
        $this->isNew = ($this->getId() === 0);
 
        $this->callEventOnBeforeEntitySaved();
 
        if ($id > 0)
        {
            $r = $this->update();
        }
        else
        {
            $r = $this->add();
 
            if ($r->getId() > 0)
            {
                $id = $r->getId();
            }
        }
 
        if (!$r->isSuccess())
        {
            $result->addErrors($r->getErrors());
            return $result;
        }
 
        if ($id > 0)
        {
            $result->setId($id);
 
            $controller = Internals\CustomFieldsController::getInstance();
            $controller->save($this);
        }
 
        if (!$this->isSystem())
        {
            $this->saveExtraServices();
            $this->saveStoreId();
        }
 
        $this->callEventOnEntitySaved();
 
        $this->callDelayedEvents();
 
        $shipmentItemCollection = $this->getShipmentItemCollection();
        $r = $shipmentItemCollection->save();
        if (!$r->isSuccess())
        {
            $result->addErrors($r->getErrors());
            return $result;
        }
 
        if (!$this->isSystem())
        {
            $registry = Registry::getInstance(static::getRegistryType());
 
            $orderHistory = $registry->getOrderHistoryClassName();
            $orderHistory::collectEntityFields('SHIPMENT', $this->getParentOrderId(), $id);
        }
 
        $propertyCollection = $this->getPropertyCollection();
 
        $res = $propertyCollection->save();
        if (!$res->isSuccess())
        {
            $result->addWarnings($res->getErrors());
        }
 
        $this->onAfterSave($this->isNew);
 
        $this->isNew = false;
 
        return $result;
    }
 
    private function checkCallingContext()
    {
        $order = $this->getOrder();
 
        if (!$order->isSaveRunning())
        {
            trigger_error("Incorrect call to the save process. Use method save() on \Bitrix\Sale\Order entity", E_USER_WARNING);
        }
    }
 
    private function add()
    {
        $result = new Result();
 
        $registry = Registry::getInstance(static::getRegistryType());
 
        $this->setFieldNoDemand('ORDER_ID', $this->getParentOrderId());
 
        $r = static::addInternal($this->getFields()->getValues());
        if (!$r->isSuccess())
        {
            $orderHistory = $registry->getOrderHistoryClassName();
 
            $orderHistory::addAction(
                'SHIPMENT',
                $this->getParentOrderId(),
                'SHIPMENT_ADD_ERROR',
                null,
                $this,
                ["ERROR" => $r->getErrorMessages()]
            );
 
            $result->addErrors($r->getErrors());
            return $result;
        }
 
        $id = $r->getId();
        $this->setFieldNoDemand('ID', $id);
        $result->setId($id);
 
        $this->setAccountNumber($id);
 
        if (!$this->isSystem())
        {
            $orderHistory = $registry->getOrderHistoryClassName();
 
            $orderHistory::addAction(
                'SHIPMENT',
                $this->getParentOrderId(),
                'SHIPMENT_ADDED',
                $id,
                $this
            );
        }
 
        return $result;
    }
 
    private function update()
    {
        $result = new Result();
 
        $registry = Registry::getInstance(static::getRegistryType());
 
        $this->setDeliveryRequestMarker();
 
        $r = static::updateInternal($this->getId(), $this->getFields()->getChangedValues());
        if (!$r->isSuccess())
        {
            $orderHistory = $registry->getOrderHistoryClassName();
 
            $orderHistory::addAction(
                'SHIPMENT',
                $this->getParentOrderId(),
                'SHIPMENT_UPDATE_ERROR',
                $this->getId(),
                $this,
                ["ERROR" => $r->getErrorMessages()]
            );
 
            $result->addErrors($r->getErrors());
        }
 
        return $result;
    }
 
    protected function setDeliveryRequestMarker()
    {
        $order = $this->getParentOrder();
 
        Requests\Manager::onBeforeShipmentSave($order, $this);
    }
 
    private function callDelayedEvents()
    {
        $eventList = Internals\EventsPool::getEvents('s'.$this->getInternalIndex());
 
        if ($eventList)
        {
            foreach ($eventList as $eventName => $eventData)
            {
                $event = new Main\Event('sale', $eventName, $eventData);
                $event->send();
 
                $registry = Registry::getInstance(static::getRegistryType());
 
                $notifyClassName = $registry->getNotifyClassName();
                $notifyClassName::callNotify($this, $eventName);
            }
 
            Internals\EventsPool::resetEvents('s'.$this->getInternalIndex());
        }
    }
 
    private function callEventOnBeforeEntitySaved()
    {
        $event = new Main\Event('sale', 'OnBeforeSaleShipmentEntitySaved', [
                'ENTITY' => $this,
                'VALUES' => $this->fields->getOriginalValues()
        ]);
 
        $event->send();
    }
 
    private function callEventOnEntitySaved()
    {
        $event = new Main\Event('sale', 'OnSaleShipmentEntitySaved', [
            'ENTITY' => $this,
            'VALUES' => $this->fields->getOriginalValues(),
            'IS_NEW' => $this->isNew,
        ]);
 
        $event->send();
    }
 
    protected function onAfterSave($isNew)
    {
        return;
    }
 
    public function getParentOrderId()
    {
        $order = $this->getParentOrder();
        if (!$order)
        {
            return false;
        }
 
        return $order->getId();
    }
 
    public function getOrder()
    {
        return $this->getCollection()->getOrder();
    }
 
    public function getShipmentItemCollection()
    {
        if (empty($this->shipmentItemCollection))
        {
            $registry = Registry::getInstance(static::getRegistryType());
 
            $itemCollectionClassName = $registry->getShipmentItemCollectionClassName();
            $this->shipmentItemCollection = $itemCollectionClassName::load($this);
        }
 
        return $this->shipmentItemCollection;
    }
 
    protected function markSystem()
    {
        $this->setFieldNoDemand("SYSTEM", 'Y');
    }
 
    public static function createSystem(ShipmentCollection $collection, Delivery\Services\Base $deliveryService = null)
    {
        $shipment = static::create($collection, $deliveryService);
        $shipment->markSystem();
 
        if ($deliveryService === null)
        {
            $shipment->setFieldNoDemand('DELIVERY_ID', Delivery\Services\Manager::getEmptyDeliveryServiceId());
        }
 
        return $shipment;
    }
 
    public function getPrice()
    {
        return (float)$this->getField('PRICE_DELIVERY');
    }
 
    public function isCustomPrice()
    {
        return $this->isMarkedFieldCustom('PRICE_DELIVERY');
    }
 
    protected function isPriceField(string $name) : bool
    {
        return
            $name === 'BASE_PRICE_DELIVERY'
            || $name === 'PRICE_DELIVERY'
            || $name === 'DISCOUNT_PRICE'
        ;
    }
 
    public function getCurrency()
    {
        return (string)$this->getField('CURRENCY');
    }
 
    public function getDeliveryId()
    {
        return (int)$this->getField('DELIVERY_ID');
    }
 
    public function getDeliveryName()
    {
        return (string)$this->getField('DELIVERY_NAME');
    }
 
    public function setOrderId($orderId)
    {
        $this->setField('ORDER_ID', $orderId);
    }
 
    public function getDelivery()
    {
        if ($this->service === null)
        {
            $this->service = $this->loadDeliveryService();
        }
 
        return $this->service;
    }
 
    protected function loadDeliveryService()
    {
        if ($deliveryId = $this->getDeliveryId())
        {
            return Delivery\Services\Manager::getObjectById($deliveryId);
        }
 
        return null;
    }
 
 
    public function isSystem()
    {
        return $this->getField('SYSTEM') === 'Y';
    }
 
    public function isCanceled()
    {
        return $this->getField('CANCELED') === 'Y';
    }
 
    public function isShipped()
    {
        return $this->getField('DEDUCTED') === 'Y';
    }
 
    public function getShippedDate()
    {
        return $this->getField('DATE_DEDUCTED');
    }
 
    public function getShippedUserId()
    {
        return $this->getField('EMP_DEDUCTED_ID');
    }
 
    public function getUnshipReason()
    {
        return (string)$this->getField('REASON_UNDO_DEDUCTED');
    }
 
    public function isMarked()
    {
        return $this->getField('MARKED') === "Y";
    }
 
    public function isReserved()
    {
        foreach ($this->getShipmentItemCollection() as $shipmentItem)
        {
            if ($shipmentItem->getReservedQuantity() !== $shipmentItem->getQuantity())
            {
                return false;
            }
        }
 
        return true;
    }
 
    public function isAllowDelivery()
    {
        return $this->getField('ALLOW_DELIVERY') === "Y";
    }
 
    public function isEmpty()
    {
        return $this->getShipmentItemCollection()->isEmpty();
    }
 
    public function getAllowDeliveryDate()
    {
        return $this->getField('DATE_ALLOW_DELIVERY');
    }
 
    public function getAllowDeliveryUserId()
    {
        return (int)$this->getField('EMP_ALLOW_DELIVERY_ID');
    }
 
    public function getCompanyId()
    {
        return (int)$this->getField('COMPANY_ID');
    }
 
    public function tryReserve()
    {
        return Internals\Catalog\Provider::tryReserveShipment($this);
    }
 
    public function tryUnreserve()
    {
        return Internals\Catalog\Provider::tryUnreserveShipment($this);
    }
 
    public function tryShip()
    {
        $result = new Result();
 
        $r = Internals\Catalog\Provider::tryShipShipment($this);
        if ($r->isSuccess())
        {
            $resultList = $r->getData();
 
            if (!empty($resultList) && is_array($resultList))
            {
                foreach ($resultList as $resultDat)
                {
                    if (!$resultDat->isSuccess())
                    {
                        $result->addErrors( $resultDat->getErrors() );
                    }
                }
            }
        }
        else
        {
            $result->addErrors( $r->getErrors() );
        }
 
        if ($r->hasWarnings())
        {
            $result->addWarnings( $r->getWarnings() );
        }
        return $result;
    }
 
    public function tryUnship()
    {
        return $this->tryShip();
    }
 
    public function needShip()
    {
        if ($this->fields->isChanged('DEDUCTED'))
        {
            if ($this->getField('DEDUCTED') === "Y")
            {
                return true;
            }
            elseif ($this->getField('DEDUCTED') === "N" && $this->getId() != 0)
            {
                return false;
            }
        }
 
        return null;
    }
 
    public function deliver()
    {
        $result = Internals\Catalog\Provider::deliver($this);
        if ($result->isSuccess())
        {
            Recurring::repeat($this->getOrder(), $result->getData());
        }
 
        return $result;
    }
 
    public function allowDelivery()
    {
        return $this->setField('ALLOW_DELIVERY', "Y");
    }
 
    public function disallowDelivery()
    {
        return $this->setField('ALLOW_DELIVERY', "N");
    }
 
    public function onBeforeBasketItemDelete(BasketItem $basketItem)
    {
        $result = new Result();
 
        $shipmentItemCollection = $this->getShipmentItemCollection();
        $r = $shipmentItemCollection->onBeforeBasketItemDelete($basketItem);
        if (!$r->isSuccess())
        {
            return $result->addErrors($r->getErrors());
        }
 
        if ($this->isSystem())
        {
            return $this->syncQuantityAfterModify($basketItem);
        }
 
        return $result;
    }
 
    public function onBasketModify($action, BasketItem $basketItem, $name = null, $oldValue = null, $value = null)
    {
        $result = new Result();
 
        if ($action === EventActions::ADD)
        {
            if (!$this->isSystem())
            {
                return $result;
            }
 
            return $this->getShipmentItemCollection()->onBasketModify($action, $basketItem, $name, $oldValue, $value);
        }
        elseif ($action === EventActions::UPDATE)
        {
            if ($name === "QUANTITY")
            {
                if ($this->isSystem())
                {
                    return $this->syncQuantityAfterModify($basketItem, $value, $oldValue);
                }
 
                $shipmentItemCollection = $this->getShipmentItemCollection();
 
                $r = $shipmentItemCollection->onBasketModify($action, $basketItem, $name, $oldValue, $value);
                if ($r->isSuccess())
                {
                    if (!$this->isCustomPrice())
                    {
                        $deliveryCalculate = $this->calculateDelivery();
                        if ($deliveryCalculate->isSuccess())
                        {
                            $this->setField('BASE_PRICE_DELIVERY', $deliveryCalculate->getPrice());
                        }
                        else
                        {
                            $result->addWarnings($deliveryCalculate->getErrors());
                        }
                    }
                }
                else
                {
                    $result->addErrors($r->getErrors());
                }
            }
            elseif ($name === 'WEIGHT')
            {
                if (!$this->isMarkedFieldCustom('WEIGHT'))
                {
                    if ($this->getShipmentItemCollection()->isExistBasketItem($basketItem))
                    {
                        $this->setField('WEIGHT', $this->getShipmentItemCollection()->getWeight());
                    }
                }
            }
            elseif ($name === 'PRICE')
            {
                if (!$this->isCustomPrice())
                {
                    if ($this->getShipmentItemCollection()->isExistBasketItem($basketItem))
                    {
                        $r = $this->calculateDelivery();
                        if ($r->isSuccess())
                        {
                            $this->setField('BASE_PRICE_DELIVERY', $r->getPrice());
                        }
                        else
                        {
                            $result->addErrors($r->getErrors());
                        }
                    }
                }
            }
        }
 
        return $result;
    }
 
    protected function onFieldModify($name, $oldValue, $value)
    {
        global $USER;
 
        $result = new Result();
 
        if ($name === 'DELIVERY_ID')
        {
            if (
                $value > 0
                && (
                    $this->service === null
                    || $this->service->getId() !== (int)$value
                )
            )
            {
                $service = Delivery\Services\Manager::getObjectById($value);
                if ($service)
                {
                    $this->service = $service;
 
                    $this->setField('DELIVERY_NAME', $this->service->getName());
                }
            }
 
            $this->getPropertyCollection()->refreshRelated();
        }
        elseif ($name === "MARKED")
        {
            if ($oldValue != "Y")
            {
                $this->setField('DATE_MARKED', new Main\Type\DateTime());
 
                if (is_object($USER))
                {
                    $this->setField('EMP_MARKED_ID', $USER->GetID());
                }
            }
            elseif ($value === "N")
            {
                $this->setField('REASON_MARKED', '');
            }
        }
        elseif ($name === "ALLOW_DELIVERY")
        {
            $this->setField('DATE_ALLOW_DELIVERY', new Main\Type\DateTime());
 
            if (is_object($USER))
            {
                $this->setField('EMP_ALLOW_DELIVERY_ID', $USER->GetID());
            }
 
            if ($oldValue === 'N')
            {
                $shipmentStatus = Main\Config\Option::get('sale', 'shipment_status_on_allow_delivery', '');
 
                $registry = Registry::getInstance(static::getRegistryType());
                $deliveryStatusClassName = $registry->getDeliveryStatusClassName();
 
                if (
                    $shipmentStatus !== ''
                    && $this->getField('STATUS_ID') != $deliveryStatusClassName::getFinalStatus()
                )
                {
                    $r = $this->setStatus($shipmentStatus);
                    if (!$r->isSuccess())
                    {
                        $result->addErrors($r->getErrors());
                    }
                }
            }
 
            Internals\EventsPool::addEvent(
                's'.$this->getInternalIndex(),
                EventActions::EVENT_ON_SHIPMENT_ALLOW_DELIVERY,
                [
                    'ENTITY' => $this,
                    'VALUES' => $this->fields->getOriginalValues()
                ]
            );
        }
        elseif ($name === "DEDUCTED")
        {
            $this->setField('DATE_DEDUCTED', new Main\Type\DateTime());
 
            if (is_object($USER))
            {
                $this->setField('EMP_DEDUCTED_ID', $USER->GetID());
            }
 
            if ($oldValue === 'N')
            {
                $shipmentStatus = Main\Config\Option::get('sale', 'shipment_status_on_shipped', '');
 
                $registry = Registry::getInstance(static::getRegistryType());
                $deliveryStatusClassName = $registry->getDeliveryStatusClassName();
 
                if (strval($shipmentStatus) != '' && $this->getField('STATUS_ID') != $deliveryStatusClassName::getFinalStatus())
                {
                    $r = $this->setStatus($shipmentStatus);
                    if (!$r->isSuccess())
                    {
                        $result->addErrors($r->getErrors());
                    }
                }
            }
 
            if ($value === 'Y')
            {
                foreach ($this->getShipmentItemCollection() as $shipmentItem)
                {
                    $r = $shipmentItem->checkMarkingCodeOnDeducted();
                    if (!$r->isSuccess())
                    {
                        $result->addErrors($r->getErrors());
                    }
                }
            }
 
            Internals\EventsPool::addEvent(
                's'.$this->getInternalIndex(),
                EventActions::EVENT_ON_SHIPMENT_DEDUCTED,
                [
                    'ENTITY' => $this,
                    'VALUES' => $this->fields->getOriginalValues()
                ]
            );
 
            Cashbox\Internals\Pool::addDoc($this->getOrder()->getInternalId(), $this);
        }
        elseif ($name === "STATUS_ID")
        {
            $event = new Main\Event(
                'sale',
                EventActions::EVENT_ON_BEFORE_SHIPMENT_STATUS_CHANGE,
                [
                    'ENTITY' => $this,
                    'VALUE' => $value,
                    'OLD_VALUE' => $oldValue,
                ]
            );
            $event->send();
 
            Internals\EventsPool::addEvent(
                's'.$this->getInternalIndex(),
                EventActions::EVENT_ON_SHIPMENT_STATUS_CHANGE,
                [
                    'ENTITY' => $this,
                    'VALUE' => $value,
                    'OLD_VALUE' => $oldValue,
                ]
            );
 
            Internals\EventsPool::addEvent(
                's'.$this->getInternalIndex(),
                EventActions::EVENT_ON_SHIPMENT_STATUS_CHANGE_SEND_MAIL,
                [
                    'ENTITY' => $this,
                    'VALUE' => $value,
                    'OLD_VALUE' => $oldValue,
                ]
            );
        }
        elseif ($name === 'RESPONSIBLE_ID')
        {
            $this->setField('DATE_RESPONSIBLE_ID', new Main\Type\DateTime());
        }
        elseif ($name === 'TRACKING_NUMBER')
        {
            if ($value)
            {
                Internals\EventsPool::addEvent(
                    's'.$this->getInternalIndex(),
                    EventActions::EVENT_ON_SHIPMENT_TRACKING_NUMBER_CHANGE,
                    [
                        'ENTITY' => $this,
                        'VALUES' => $this->getFields()->getOriginalValues(),
                    ]
                );
            }
        }
 
        $r = parent::onFieldModify($name, $oldValue, $value);
        if (!$r->isSuccess())
        {
            return $result->addErrors($r->getErrors());
        }
 
        if (
            $name === 'BASE_PRICE_DELIVERY'
            && !$this->isMarkedFieldCustom('PRICE_DELIVERY')
        )
        {
            $value -= $this->getField('DISCOUNT_PRICE');
 
            $r = $this->setField('PRICE_DELIVERY', $value);
            if (!$r->isSuccess())
            {
                $result->addErrors($r->getErrors());
            }
        }
 
        if ($r->hasWarnings())
        {
            $result->addWarnings($r->getWarnings());
        }
 
        $result->addData($r->getData());
 
        if ($result->isSuccess())
        {
            $this->setFieldNoDemand('DATE_UPDATE', new Main\Type\DateTime());
        }
 
        return $result;
    }
 
    protected function syncQuantityAfterModify(BasketItem $basketItem, $value = null, $oldValue = null)
    {
        $result = new Result();
 
        $shipmentItemCollection = $this->getShipmentItemCollection();
 
        $shipmentItem = $shipmentItemCollection->getItemByBasketCode($basketItem->getBasketCode());
 
        if ($value === 0)
        {
            if ($shipmentItem !== null)
            {
                $shipmentItem->setFieldNoDemand('QUANTITY', 0);
            }
 
            return $result;
        }
 
        if ($shipmentItem === null)
        {
            $shipmentItem = $shipmentItemCollection->createItem($basketItem);
        }
 
        $deltaQuantity = $value - $oldValue;
 
        if ($deltaQuantity > 0)     // plus
        {
            $shipmentItem->setFieldNoDemand(
                "QUANTITY",
                $shipmentItem->getField("QUANTITY") + $deltaQuantity
            );
 
            if (
                Configuration::isEnableAutomaticReservation()
                && $this->needReservation()
            )
            {
                Internals\Catalog\Provider::tryReserveShipmentItem($shipmentItem);
            }
        }
        else        // minus
        {
            if (floatval($shipmentItem->getField("QUANTITY")) <= 0)
            {
                return new Result();
            }
 
            if ($value != 0 && roundEx($shipmentItem->getField("QUANTITY"), SALE_VALUE_PRECISION) < roundEx(-$deltaQuantity, SALE_VALUE_PRECISION))
            {
                $result->addError(
                    new ResultError(
                        str_replace(
                            array("#NAME#", "#QUANTITY#", "#DELTA_QUANTITY#"),
                            array($basketItem->getField("NAME"), $shipmentItem->getField("QUANTITY"), abs($deltaQuantity)),
                            Loc::getMessage('SALE_SHIPMENT_SYSTEM_QUANTITY_ERROR')
                        ),
                        'SALE_SHIPMENT_SYSTEM_QUANTITY_ERROR'
                    )
                );
                return $result;
            }
 
            if ($value > 0)
            {
                $shipmentItem->setFieldNoDemand(
                    "QUANTITY",
                    $shipmentItem->getField("QUANTITY") + $deltaQuantity
                );
 
                if (
                    Configuration::isEnableAutomaticReservation()
                    && $this->needReservation()
                )
                {
                    Internals\Catalog\Provider::tryReserveShipmentItem($shipmentItem);
                }
            }
 
        }
 
        return $result;
    }
 
    public function getServiceParams()
    {
        $params = $this->getField('PARAMS');
        return isset($params["SERVICE_PARAMS"]) ? $params["SERVICE_PARAMS"] : array();
    }
 
    public function setServiceParams(array $serviceParams)
    {
        $params = $this->getField('PARAMS');
        $params["SERVICE_PARAMS"] = $serviceParams;
        $this->setField("PARAMS", $params);
    }
 
    public function getExtraServices()
    {
        if($this->extraServices === null)
        {
            $this->setExtraServices(
                Delivery\ExtraServices\Manager::getValuesForShipment(
                    $this->getId(),
                    $this->getDeliveryId()
                )
            );
        }
 
        return $this->extraServices;
    }
 
    public function setExtraServices(array $extraServices)
    {
        $this->extraServices = $extraServices;
    }
 
    public function getExtraServicesObjects()
    {
        return Delivery\ExtraServices\Manager::getObjectsForShipment(
            $this->getId(),
            $this->getDeliveryId(),
            $this->getCurrency()
        );
    }
 
    protected function saveExtraServices()
    {
        return Delivery\ExtraServices\Manager::saveValuesForShipment($this->getId(), $this->getExtraServices());
    }
 
    public function getStoreId()
    {
        if($this->storeId === null)
        {
            $this->setStoreId(
                Delivery\ExtraServices\Manager::getStoreIdForShipment(
                    $this->getId(),
                    $this->getDeliveryId()
            ));
        }
 
        return $this->storeId;
    }
 
    public function setStoreId($storeId)
    {
        $this->storeId = (int)$storeId;
    }
 
    protected function saveStoreId()
    {
        return Delivery\ExtraServices\Manager::saveStoreIdForShipment($this->getId(), $this->getDeliveryId(), $this->getStoreId());
    }
 
    public function getWeight() : float
    {
        return (float)$this->getField('WEIGHT');
    }
 
    public function setWeight(float $weight)
    {
        return $this->setField('WEIGHT', $weight);
    }
 
    public function calculateDelivery()
    {
        if ($this->isSystem())
        {
            throw new Main\NotSupportedException();
        }
 
        if ($this->getDeliveryId() === 0)
        {
            return new Delivery\CalculationResult();
        }
 
        return Delivery\Services\Manager::calculateDeliveryPrice($this);
    }
 
    public function resetData()
    {
        if (!$this->isCustomPrice())
        {
            $this->setField('BASE_PRICE_DELIVERY', 0);
        }
    }
 
    public function getBasketItemQuantity(BasketItem $basketItem)
    {
        $shipmentItemCollection = $this->getShipmentItemCollection();
 
        return $shipmentItemCollection->getBasketItemQuantity($basketItem);
    }
 
    protected function addChangesToHistory($name, $oldValue = null, $value = null)
    {
        if ($this->getId() > 0 && !$this->isSystem())
        {
            $order = $this->getOrder();
 
            if ($order && $order->getId() > 0)
            {
                $registry = Registry::getInstance(static::getRegistryType());
 
                $orderHistory = $registry->getOrderHistoryClassName();
                $orderHistory::addField(
                    'SHIPMENT',
                    $order->getId(),
                    $name,
                    $oldValue,
                    $value,
                    $this->getId(),
                    $this
                );
            }
        }
    }
 
    public function isExistBasketItem(BasketItem $basketItem)
    {
        if (!$shipmentItemCollection = $this->getShipmentItemCollection())
        {
            throw new Main\ObjectNotFoundException('Entity "ShipmentItemCollection" not found');
        }
 
        return $shipmentItemCollection->isExistBasketItem($basketItem);
    }
 
    public function verify()
    {
        $result = new Result();
 
        if ($this->getDeliveryId() <= 0)
        {
            $result->addError(
                new ResultError(
                    Loc::getMessage("SALE_SHIPMENT_DELIVERY_SERVICE_EMPTY"),
                    'SALE_SHIPMENT_DELIVERY_SERVICE_EMPTY'
                )
            );
        }
 
        if ($shipmentItemCollection = $this->getShipmentItemCollection())
        {
            foreach ($shipmentItemCollection as $shipmentItem)
            {
                $r = $shipmentItem->verify();
                if (!$r->isSuccess())
                {
                    $result->addErrors($r->getErrors());
                }
            }
        }
 
        return $result;
    }
 
    public function setAccountNumber($id)
    {
        $result = new Result();
 
        $id = intval($id);
        if ($id <= 0)
        {
            $result->addError(new ResultError(Loc::getMessage('SALE_PAYMENT_GENERATE_ACCOUNT_NUMBER_ORDER_NUMBER_WRONG_ID'), 'SALE_PAYMENT_GENERATE_ACCOUNT_NUMBER_ORDER_NUMBER_WRONG_ID'));
            return $result;
        }
 
        $value = Internals\AccountNumberGenerator::generateForShipment($this);
 
        try
        {
            $r = static::updateInternal($id, array("ACCOUNT_NUMBER" => $value));
            $res = $r->isSuccess(true);
        }
        catch (Main\DB\SqlQueryException $exception)
        {
            $res = false;
        }
 
        if ($res)
        {
            $this->setFieldNoDemand('ACCOUNT_NUMBER', $value);
        }
 
        return $result;
    }
 
    public function getBusinessValueProviderInstance($mapping)
    {
        $providerInstance = null;
 
        if (is_array($mapping) && isset($mapping['PROVIDER_KEY']))
        {
            switch ($mapping['PROVIDER_KEY'])
            {
                case 'SHIPMENT': $providerInstance = $this; break;
                case 'COMPANY' : $providerInstance = $this->getField('COMPANY_ID'); break;
                default:
                    $order = $this->getOrder();
                    if ($order)
                    {
                        $providerInstance = $order->getBusinessValueProviderInstance($mapping);
                    }
            }
        }
 
        return $providerInstance;
    }
 
    public function getPersonTypeId()
    {
        $order = $this->getOrder();
        if ($order)
        {
            return $order->getPersonTypeId();
        }
 
        return null;
    }
 
    public static function getList(array $parameters)
    {
        return Internals\ShipmentTable::getList($parameters);
    }
 
    public function createClone(\SplObjectStorage $cloneEntity)
    {
        if ($this->isClone() && $cloneEntity->contains($this))
        {
            return $cloneEntity[$this];
        }
 
        $shipmentClone = parent::createClone($cloneEntity);
 
        if ($shipmentItemCollection = $this->getShipmentItemCollection())
        {
            if (!$cloneEntity->contains($shipmentItemCollection))
            {
                $cloneEntity[$shipmentItemCollection] = $shipmentItemCollection->createClone($cloneEntity);
            }
 
            if ($cloneEntity->contains($shipmentItemCollection))
            {
                $shipmentClone->shipmentItemCollection = $cloneEntity[$shipmentItemCollection];
            }
        }
 
        if ($service = $this->getDelivery())
        {
            if (!$cloneEntity->contains($service))
            {
                $cloneEntity[$service] = $service->createClone($cloneEntity);
            }
 
            if ($cloneEntity->contains($service))
            {
                $shipmentClone->service = $cloneEntity[$service];
            }
        }
 
        return $shipmentClone;
    }
 
    protected function setStatus($status)
    {
        global $USER;
 
        $result = new Result();
 
        $registry = Registry::getInstance(static::getRegistryType());
        $deliveryStatusClassName = $registry->getDeliveryStatusClassName();
 
        if (is_object($USER)  && $USER->isAuthorized())
        {
            $statusesList = $deliveryStatusClassName::getAllowedUserStatuses($USER->getID(), $this->getField('STATUS_ID'));
        }
        else
        {
            $statusesList = $deliveryStatusClassName::getAllStatuses();
        }
 
        if($this->getField('STATUS_ID') != $status && array_key_exists($status, $statusesList))
        {
            $r = $this->setField('STATUS_ID', $status);
            if (!$r->isSuccess())
            {
                $result->addErrors($r->getErrors());
                return $result;
            }
        }
 
        return $result;
    }
 
    public function getErrorEntity($value)
    {
        $className = null;
        $errorsList = static::getAutoFixErrorsList();
        if (is_array($errorsList) && in_array($value, $errorsList))
        {
            $className = static::getClassName();
        }
        else
        {
            if ($shipmentItemCollection = $this->getShipmentItemCollection())
            {
                $className = $shipmentItemCollection->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 ($shipmentItemCollection = $this->getShipmentItemCollection())
            {
                $autoFix = $shipmentItemCollection->canAutoFixError($value);
            }
        }
 
        return $autoFix;
    }
 
    public function getAutoFixErrorsList()
    {
        return array_keys(static::getAutoFixRules());
    }
 
    public function tryFixError($code)
    {
        $result = new Result();
 
        $method = static::getFixMethod($code);
        $r = call_user_func_array($method, array($this));
        if (!$r->isSuccess())
        {
            $result->addErrors($r->getErrors());
        }
        elseif ($r->hasWarnings())
        {
            $result->addWarnings($r->getWarnings());
        }
 
        return $result;
    }
 
    protected static function getFixMethod($code)
    {
        $codeList = static::getAutoFixRules();
 
        if (!empty($codeList[$code]))
        {
            return $codeList[$code];
        }
        return null;
    }
 
    public static function fixReserveErrors(Shipment $entity)
    {
        $result = new Result();
 
        $r = $entity->tryReserve();
        if (!$r->isSuccess())
        {
            $result->addErrors($r->getErrors());
        }
        elseif ($r->hasWarnings())
        {
            $result->addWarnings($r->getWarnings());
        }
 
        return $result;
    }
 
    public static function fixShipErrors(Shipment $entity)
    {
        $result = new Result();
 
        $r = $entity->setField('DEDUCTED', 'Y');
        if (!$r->isSuccess())
        {
            if (!$r->isSuccess())
            {
                $result->addErrors($r->getErrors());
            }
        }
 
        $r = $entity->tryShip();
        if (!$r->isSuccess())
        {
            if (!$r->isSuccess())
            {
                $result->addErrors($r->getErrors());
            }
        }
 
        return $result;
    }
 
    protected static function getAutoFixRules()
    {
        return [
            'PROVIDER_BASKET_ITEM_WRONG_AVAILABLE_QUANTITY' => ['\Bitrix\Sale\Shipment', "fixReserveErrors"],
            'SALE_PROVIDER_RESERVE_SHIPMENT_ITEM_WRONG_AVAILABLE_QUANTITY' => ['\Bitrix\Sale\Shipment', "fixReserveErrors"],
            'PROVIDER_UNRESERVE_SHIPMENT_ITEM_WRONG_AVAILABLE_QUANTITY' => ['\Bitrix\Sale\Shipment', "fixReserveErrors"],
            'SALE_PROVIDER_RESERVE_SHIPMENT_ITEM_QUANTITY_NOT_ENOUGH' => ['\Bitrix\Sale\Shipment', "fixReserveErrors"],
 
            'SALE_PROVIDER_SHIPMENT_SHIPPED_LESS_QUANTITY' => ['\Bitrix\Sale\Shipment', "fixShipErrors"],
            'SALE_PROVIDER_SHIPMENT_SHIPPED_MORE_QUANTITY' => ['\Bitrix\Sale\Shipment', "fixShipErrors"],
            'DDCT_DEDUCTION_QUANTITY_STORE_ERROR' => ['\Bitrix\Sale\Shipment', "fixShipErrors"],
            'SALE_PROVIDER_SHIPMENT_QUANTITY_NOT_ENOUGH' => ['\Bitrix\Sale\Shipment', "fixShipErrors"],
            'DDCT_DEDUCTION_QUANTITY_ERROR' => ['\Bitrix\Sale\Shipment', "fixShipErrors"],
        ];
    }
 
    public function canMarked()
    {
        return true;
    }
 
    public function getMarkField()
    {
        return 'MARKED';
    }
 
    public function isChanged()
    {
        if (parent::isChanged())
        {
            return true;
        }
 
        return $this->getShipmentItemCollection()->isChanged();
    }
 
    public function clearChanged()
    {
        parent::clearChanged();
 
        if ($shipmentItemCollection = $this->getShipmentItemCollection())
        {
            foreach ($shipmentItemCollection as $shipmentItem)
            {
                $shipmentItem->clearChanged();
            }
        }
    }
 
    public function getVatRate()
    {
        $vatRate = 0;
 
        $service = $this->getDelivery();
        if ($service)
        {
            if (!Main\Loader::includeModule('catalog'))
            {
                return $vatRate;
            }
 
            $vatId = $service->getVatId();
            if ($vatId <= 0)
            {
                return $vatRate;
            }
 
            $dbRes = VatTable::getById($vatId);
            $vatInfo = $dbRes->fetch();
            if ($vatInfo)
            {
                $vatRate = $vatInfo['RATE'] / 100;
            }
        }
 
        return $vatRate;
    }
 
    public function getVatSum()
    {
        $vatRate = $this->getVatRate();
        $price = $this->getPrice() * $vatRate / (1 + $vatRate);
 
        return PriceMaths::roundPrecision($price);
    }
 
    protected function addInternal(array $data)
    {
        return Internals\ShipmentTable::add($data);
    }
 
    protected function updateInternal($primary, array $data)
    {
        return Internals\ShipmentTable::update($primary, $data);
    }
 
    protected static function deleteInternal($primary)
    {
        return Internals\ShipmentTable::deleteWithItems($primary);
    }
 
    protected static function getFieldsMap()
    {
        return Internals\ShipmentTable::getMap();
    }
 
    public static function getUfId()
    {
        return Internals\ShipmentTable::getUfId();
    }
 
    public function setBasePriceDelivery($value, $custom = false)
    {
        $result = new Result();
 
        if ($custom === true)
        {
            $this->markFieldCustom('PRICE_DELIVERY');
        }
 
        $r = $this->setField('BASE_PRICE_DELIVERY', $value);
        if (!$r->isSuccess())
        {
            $result->addErrors($r->getErrors());
        }
 
        return $result;
    }
 
    public static function getEntityEventName()
    {
        return 'SaleShipment';
    }
 
    public function toArray() : array
    {
        $result = parent::toArray();
 
        $result['ITEMS'] = $this->getShipmentItemCollection()->toArray();
 
        return $result;
    }
 
    public function getPropertyCollection(): ShipmentPropertyValueCollection
    {
        if(empty($this->propertyCollection))
        {
            $this->propertyCollection = $this->loadPropertyCollection();
        }
 
        return $this->propertyCollection;
    }
 
    public function loadPropertyCollection(): ShipmentPropertyValueCollection
    {
        $registry = Registry::getInstance(static::getRegistryType());
        $propertyCollectionClassName = $registry->getShipmentPropertyValueCollectionClassName();
 
        return $propertyCollectionClassName::load($this);
    }
 
    public function getParentOrder()
    {
        return $this->getOrder();
    }
}