shipmentitemstore.php

<?php
namespace Bitrix\Sale;
 
use Bitrix\Main\Localization\Loc;
use Bitrix\Main;
use Bitrix\Sale;
 
Loc::loadMessages(__FILE__);
 
class ShipmentItemStore
    extends Internals\CollectableEntity
    implements \IEntityMarker
{
    public static function getAvailableFields()
    {
        return [
            'ORDER_DELIVERY_BASKET_ID', 'STORE_ID', 'QUANTITY', 
            'BARCODE', 'BASKET_ID', 'MARKING_CODE',
        ];
    }
 
    protected static function getMeaningfulFields()
    {
        return [];
    }
 
    private static function createShipmentItemStoreObject(array $itemData = array())
    {
        $registry = Registry::getInstance(static::getRegistryType());
        $shipmentItemStoreClassName = $registry->getShipmentItemStoreClassName();
 
        return new $shipmentItemStoreClassName($itemData);
    }
 
    public static function getRegistryType()
    {
        return Registry::REGISTRY_TYPE_ORDER;
    }
 
    public static function getRegistryEntity()
    {
        return Registry::ENTITY_SHIPMENT_ITEM_STORE;
    }
 
    public static function create(ShipmentItemStoreCollection $collection, BasketItem $basketItem)
    {
        if (!$basketItem->isReservableItem())
        {
            throw new Main\SystemException('Basket item is not available for reservation');
        }
 
        $shipmentItemStore = static::createShipmentItemStoreObject();
        $shipmentItemStore->setCollection($collection);
 
        $shipmentItem = $collection->getShipmentItem();
        if ($shipmentItem)
        {
            $fields = array(
                'ORDER_DELIVERY_BASKET_ID' => $collection->getShipmentItem()->getId(),
                'BASKET_ID' => $shipmentItem->getBasketItem()->getId(),
            );
 
            $shipmentItemStore->setFieldsNoDemand($fields);
        }
 
        return $shipmentItemStore;
 
    }
 
    protected function onFieldModify($name, $oldValue, $value)
    {
        global $USER;
 
        if (is_object($USER) && $USER->isAuthorized())
        {
            $this->setFieldNoDemand('MODIFIED_BY', $USER->GetID());
        }
 
        $this->setFieldNoDemand('DATE_MODIFY', new Main\Type\DateTime());
 
        $result = parent::onFieldModify($name, $oldValue, $value);
        if (!$result->isSuccess())
        {
            return $result;
        }
 
        if (
            $name === 'STORE_ID'
            && $this->needMoveReserve()
        )
        {
            $shipmentItem = $this->getCollection()->getShipmentItem();
            $basketItem = $shipmentItem->getBasketItem();
 
            $reserveCollection = $basketItem->getReserveQuantityCollection();
 
            if (
                $reserveCollection
                && $shipmentItem->getReservedQuantity() > 0
                && $this->getQuantity() > 0
            )
            {
                $storeIdFrom = (int)$oldValue ?: Configuration::getDefaultStoreId();
                $storeIdTo = (int)$value;
 
                if (
                    $storeIdFrom === 0
                    || $storeIdTo === 0
                    || $storeIdFrom === $storeIdTo
                )
                {
                    return $result;
                }
 
                $reserveTo = $reserveFrom = null;
 
                foreach ($reserveCollection as $reserve)
                {
                    if ($reserve->getStoreId() === $storeIdFrom)
                    {
                        $reserveFrom = $reserve;
                    }
                    elseif ($reserve->getStoreId() === $storeIdTo)
                    {
                        $reserveTo = $reserve;
                    }
 
                    if ($reserveTo && $reserveFrom)
                    {
                        break;
                    }
                }
 
                if ($reserveFrom)
                {
                    $settableQuantity = $reserveFrom->getQuantity() - $this->getQuantity();
                    if ($settableQuantity > 0)
                    {
                        $reserveFrom->setField('QUANTITY', $settableQuantity);
                    }
                    else
                    {
                        $reserveFrom->delete();
                    }
                }
 
                if (!$reserveTo)
                {
                    $reserveTo = $reserveCollection->create();
                    $reserveTo->setStoreId($storeIdTo);
                }
 
                $reserveTo->setQuantity($reserveTo->getQuantity() + $this->getQuantity());
            }
        }
        elseif (
            $name === 'QUANTITY'
            && $this->needMoveReserve()
        )
        {
            $shipmentItem = $this->getCollection()->getShipmentItem();
            $basketItem = $shipmentItem->getBasketItem();
 
            $reserveCollection = $basketItem->getReserveQuantityCollection();
 
            if ($reserveCollection && $shipmentItem->getReservedQuantity() > 0)
            {
                if ($value > $oldValue)
                {
                    $storeIdFrom = Configuration::getDefaultStoreId();
                    $storeIdTo = $this->getStoreId();
                }
                else
                {
                    $storeIdTo = Configuration::getDefaultStoreId();
                    $storeIdFrom = $this->getStoreId();
                }
 
                if (
                    $storeIdFrom === 0
                    || $storeIdTo === 0
                    || $storeIdFrom === $storeIdTo
                )
                {
                    return $result;
                }
 
                $reserveTo = $reserveFrom = null;
 
                foreach ($reserveCollection as $reserve)
                {
                    if ($reserve->getStoreId() === $storeIdFrom)
                    {
                        $reserveFrom = $reserve;
                    }
                    elseif ($reserve->getStoreId() === $storeIdTo)
                    {
                        $reserveTo = $reserve;
                    }
 
                    if ($reserveTo && $reserveFrom)
                    {
                        break;
                    }
                }
 
                $delta = abs($oldValue - $value);
 
                if ($reserveFrom)
                {
                    $settableQuantity = $reserveFrom->getQuantity() - $delta;
                    if ($settableQuantity > 0)
                    {
                        $reserveFrom->setField('QUANTITY', $settableQuantity);
                    }
                    else
                    {
                        $reserveFrom->delete();
                    }
                }
 
                if (!$reserveTo)
                {
                    $reserveTo = $reserveCollection->create();
                    $reserveTo->setStoreId($storeIdTo);
                }
 
                $reserveTo->setQuantity($reserveTo->getQuantity() + $delta);
            }
        }
 
        return $result;
    }
 
    protected function needMoveReserve() : bool
    {
        return true;
    }
 
    public function delete()
    {
        $result = new Result();
 
        $oldEntityValues = $this->fields->getOriginalValues();
 
        $event = new Main\Event('sale', "OnBeforeSaleShipmentItemStoreEntityDeleted", [
            'ENTITY' => $this,
            'VALUES' => $oldEntityValues,
        ]);
        $event->send();
 
        foreach ($event->getResults() as $eventResult)
        {
            if ($eventResult->getType() == Main\EventResult::ERROR)
            {
                $eventResultData = $eventResult->getParameters();
                if ($eventResultData instanceof ResultError)
                {
                    return $result->addError($eventResultData);
                }
            }
        }
 
        $r = parent::delete();
        if (!$r->isSuccess())
        {
            return $result->addErrors($r->getErrors());
        }
 
        $shipmentItem = $this->getCollection()->getShipmentItem();
        $basketItem = $shipmentItem->getBasketItem();
 
        $reserveCollection = $basketItem->getReserveQuantityCollection();
 
        if ($reserveCollection && $shipmentItem->getReservedQuantity() > 0)
        {
            $storeIdTo = Configuration::getDefaultStoreId();
            $storeIdFrom = $this->getStoreId();
 
            if ($storeIdFrom === $storeIdTo)
            {
                return $result;
            }
 
            $reserveTo = $reserveFrom = null;
 
            foreach ($reserveCollection as $reserve)
            {
                if ($reserve->getStoreId() === $storeIdFrom)
                {
                    $reserveFrom = $reserve;
                }
                elseif ($reserve->getStoreId() === $storeIdTo)
                {
                    $reserveTo = $reserve;
                }
 
                if ($reserveTo && $reserveFrom)
                {
                    break;
                }
            }
 
            $delta = $this->getQuantity();
 
            if ($reserveFrom)
            {
                $settableQuantity = $reserveFrom->getQuantity() - $delta;
                if ($settableQuantity > 0)
                {
                    $reserveFrom->setField('QUANTITY', $settableQuantity);
                }
                else
                {
                    $reserveFrom->delete();
                }
            }
 
            if (!$reserveTo)
            {
                $reserveTo = $reserveCollection->create();
                $reserveTo->setStoreId($storeIdTo);
            }
 
            $reserveTo->setQuantity($reserveTo->getQuantity() + $delta);
        }
 
        $event = new Main\Event('sale', "OnSaleShipmentItemStoreEntityDeleted", array(
            'ENTITY' => $this,
            'VALUES' => $this->fields->getOriginalValues(),
        ));
        $event->send();
 
        foreach ($event->getResults() as $eventResult)
        {
            if ($eventResult->getType() == Main\EventResult::ERROR)
            {
                $eventResultData = $eventResult->getParameters();
                if ($eventResultData instanceof ResultError)
                {
                    $result->addError($eventResultData);
                }
            }
        }
 
        return $result;
    }
 
    public function getBasketId() : int
    {
        return (int)$this->getField('BASKET_ID');
    }
 
    public function getQuantity() : float
    {
        return (float)$this->getField('QUANTITY');
    }
 
    public function getStoreId() : int
    {
        return (int)$this->getField('STORE_ID');
    }
 
    public function getBarcode() : string
    {
        return (string)$this->getField('BARCODE');
    }
 
    public function getMarkingCode() : string
    {
        return (string)$this->getField('MARKING_CODE');
    }
 
    public static function loadForShipmentItem($id)
    {
        if ((int)$id <= 0)
        {
            throw new Main\ArgumentNullException("id");
        }
 
        $items = [];
 
        $itemDataList = static::getList([
            'filter' => ['=ORDER_DELIVERY_BASKET_ID' => $id],
            'order' => ['DATE_CREATE' => 'ASC', 'ID' => 'ASC']
        ]);
 
        while ($itemData = $itemDataList->fetch())
        {
            $items[] = static::createShipmentItemStoreObject($itemData);
        }
 
        return $items;
    }
 
    public function verify()
    {
        $result = new Result();
 
        if ($this->getBarcode() === "")
        {
            $itemStoreCollection = $this->getCollection();
 
            $basketItem = $itemStoreCollection->getShipmentItem()->getBasketItem();
 
            $shipment = $itemStoreCollection->getShipmentItem()->getCollection()->getShipment();
 
            if ($basketItem->isBarcodeMulti() && $shipment->isShipped())
            {
                $result->addError(
                    new ResultError(
                        Loc::getMessage(
                            'SHIPMENT_ITEM_STORE_BARCODE_MULTI_EMPTY',
                            [
                                '#PRODUCT_NAME#' => $basketItem->getField('NAME'),
                                '#STORE_ID#' => $this->getStoreId(),
                            ]
                        ),
                        'SHIPMENT_ITEM_STORE_BARCODE_MULTI_EMPTY'
                    )
                );
            }
        }
 
        return $result;
    }
 
    protected function checkCallingContext()
    {
        $itemStoreCollection = $this->getCollection();
 
        $itemCollection = $itemStoreCollection->getShipmentItem()->getCollection();
 
        $shipmentCollection = $itemCollection->getShipment()->getCollection();
 
        if (!$shipmentCollection->getOrder()->isSaveRunning())
        {
            trigger_error("Incorrect call to the save process. Use method save() on \Bitrix\Sale\Order entity", E_USER_WARNING);
        }
    }
 
    public function save()
    {
        $result = new Result();
 
        $this->checkCallingContext();
 
        if (!$this->isChanged() || $this->getQuantity() === 0)
        {
            return $result;
        }
 
        $this->callEventOnBeforeItemStoreEntitySaved();
 
        $id = $this->getId();
 
        if ($id > 0)
        {
            $r = $this->updateInternal($id, $this->getFields()->getChangedValues());
        }
        else
        {
            $itemStoreCollection = $this->getCollection();
 
            if (!$this->getField("ORDER_DELIVERY_BASKET_ID"))
            {
                $this->setFieldNoDemand('ORDER_DELIVERY_BASKET_ID', $itemStoreCollection->getShipmentItem()->getId());
            }
 
            if (!$this->getField("BASKET_ID"))
            {
                $this->setFieldNoDemand('BASKET_ID', $itemStoreCollection->getShipmentItem()->getBasketItem()->getId());
            }
 
            $this->setFieldNoDemand('DATE_CREATE', new Main\Type\DateTime());
 
            $r = $this->addInternal($this->getFields()->getValues());
            if ($r->isSuccess())
            {
                $id = $r->getId();
 
                $this->setFieldNoDemand('ID', $id);
            }
        }
 
        if (!$r->isSuccess())
        {
            $this->addErrorMessagesToHistory($r->getErrorMessages());
 
            $result->addErrors($r->getErrors());
 
            return $result;
        }
 
        if ($id > 0)
        {
            $result->setId($id);
        }
 
        $this->callEventOnItemStoreEntitySaved();
 
        return $result;
    }
 
    protected function callEventOnBeforeItemStoreEntitySaved()
    {
        $event = new Main\Event('sale', 'OnBeforeSaleShipmentItemStoreEntitySaved', [
            'ENTITY' => $this,
            'VALUES' => $this->fields->getOriginalValues()
        ]);
 
        $event->send();
    }
 
    protected function callEventOnItemStoreEntitySaved()
    {
        $event = new Main\Event('sale', 'OnSaleShipmentItemStoreEntitySaved', [
            'ENTITY' => $this,
            'VALUES' => $this->fields->getOriginalValues(),
        ]);
 
        $event->send();
    }
 
    protected function addErrorMessagesToHistory($errors)
    {
        $registry = Registry::getInstance(static::getRegistryType());
 
        $shipmentItemStoreCollection = $this->getCollection();
 
        $shipmentItemCollection = $shipmentItemStoreCollection->getShipmentItem()->getCollection();
 
        $order = $shipmentItemCollection->getShipment()->getOrder();
 
        $orderHistory = $registry->getOrderHistoryClassName();
        $orderHistory::addAction(
            'SHIPMENT',
            $order->getId(),
            ($this->getId() > 0) ? 'SHIPMENT_ITEM_STORE_UPDATE_ERROR' : 'SHIPMENT_ITEM_STORE_ADD_ERROR',
            ($this->getId() > 0) ? $this->getId() : null,
            $this,
            [
                "ERROR" => $errors
            ]
        );
    }
 
    protected function addChangesToHistory($name, $oldValue = null, $value = null)
    {
        if ($this->getId() <= 0)
        {
            return;
        }
 
        $shipmentItem = $this->getCollection()->getShipmentItem();
 
        $shipmentItemCollection = $shipmentItem->getCollection();
 
        $shipmentItemCollection->getShipment()->getOrder();
 
        $shipment = $shipmentItemCollection->getShipment();
        if ($shipment->isSystem())
        {
            return;
        }
 
        $basketItem = $shipmentItem->getBasketItem();
 
        $registry = Registry::getInstance(static::getRegistryType());
 
        $orderHistory = $registry->getOrderHistoryClassName();
        $orderHistory::addField(
            'SHIPMENT_ITEM_STORE',
            $shipment->getOrder()->getId(),
            $name,
            $oldValue,
            $value,
            $this->getId(),
            $this,
            [
                'NAME' => $basketItem->getField('NAME'),
                'PRODUCT_ID' => $basketItem->getField('PRODUCT_ID'),
            ]
        );
    }
 
    public static function getList(array $parameters = array())
    {
        return Sale\Internals\ShipmentItemStoreTable::getList($parameters);
    }
 
    public function getErrorEntity($value)
    {
        static $className = null;
        $errorsList = static::getAutoFixErrorsList();
        if (is_array($errorsList) && in_array($value, $errorsList))
        {
            if ($className === null)
            {
                $className = static::getClassName();
            }
        }
        return $className;
    }
 
    public function canAutoFixError($value)
    {
        $errorsList = static::getAutoFixErrorsList();
        return (is_array($errorsList) && in_array($value, $errorsList));
    }
 
    public function getAutoFixErrorsList()
    {
        return array();
    }
 
    public function tryFixError($code)
    {
        return new Result();
    }
 
    public function canMarked()
    {
        return false;
    }
 
    public function getMarkField()
    {
        return null;
    }
 
    protected function addInternal(array $data)
    {
        return Internals\ShipmentItemStoreTable::add($data);
    }
 
    protected function updateInternal($primary, array $data)
    {
        return Internals\ShipmentItemStoreTable::update($primary, $data);
    }
 
    protected static function getFieldsMap()
    {
        return Internals\ShipmentItemStoreTable::getMap();
    }
 
    public static function getEntityEventName()
    {
        return 'SaleShipmentItemStore';
    }
}