provider.php

<?php
 
 
namespace Bitrix\Sale\Internals\Catalog;
 
 
use Bitrix\Main;
use Bitrix\Sale;
use Bitrix\Sale\Internals\PoolQuantity;
 
final class Provider
{
    const SALE_TRANSFER_PROVIDER_SHIPMENT_NEED_SHIP = true;
    const SALE_TRANSFER_PROVIDER_SHIPMENT_NEED_NOT_SHIP = false;
    const SALE_TRANSFER_PROVIDER_SHIPMENT_NEED_EMPTY = null;
 
    private static $ignoreErrors = false;
 
    public static function getProductData($basketList, array $context)
    {
        $result = new Sale\Result();
 
        if (empty($context))
        {
            throw new Main\ArgumentNullException('context');
        }
 
        if (!is_array($basketList) && !($basketList instanceof Sale\BasketBase))
        {
            throw new Main\ArgumentTypeException('basketList');
        }
 
        $creator = Sale\Internals\ProviderCreator::create($context);
        foreach ($basketList as $basketItem)
        {
            $creator->addBasketItem($basketItem);
        }
 
        $r = $creator->getProductData();
        if ($r->isSuccess())
        {
            $data = $r->getData();
            if (array_key_exists('PRODUCT_DATA_LIST', $data))
            {
                $result->setData($data);
            }
        }
        else
        {
            $result->addErrors($r->getErrors());
        }
 
        return $result;
    }
 
    public static function getBundleItems(Sale\BasketItemBase $basketItem, array $context)
    {
        if (empty($context))
        {
            throw new Main\ArgumentNullException('context');
        }
 
        $result = new Sale\Result();
 
        $creator = Sale\Internals\ProviderCreator::create($context);
        $creator->addBasketItem($basketItem);
 
        $r = $creator->getBundleItems();
        if ($r->isSuccess())
        {
            return $r;
        }
        else
        {
            $result->addErrors($r->getErrors());
        }
 
        return $result;
    }
 
    public static function getAvailableQuantityAndPriceByBasketItem(Sale\BasketItemBase $basketItem, array $context = array())
    {
        $result = new Sale\Result();
 
        $basket = $basketItem->getCollection();
 
        $order = $basket->getOrder();
 
        if (empty($context) && !$order)
        {
            $context = $basket->getContext();
        }
 
        if (empty($context) && $order)
        {
            $context = self::prepareContext($order, $context);
        }
 
        $r = self::checkContext($context);
        if (!$r->isSuccess())
        {
            return $r;
        }
 
        $resultData = array();
 
        $creator = Sale\Internals\ProviderCreator::create($context);
 
        $creator->addBasketItem($basketItem);
 
        $r = $creator->getAvailableQuantityAndPrice();
        if ($r->isSuccess())
        {
            $providerName = $basketItem->getProviderName();
 
            if (strval($providerName) == '')
            {
                $providerName = $basketItem->getCallbackFunction();
            }
 
            $providerName = self::clearProviderName($providerName);
 
            $checkProviderName = $providerName;
            $data = $r->getData();
            if (array_key_exists('PRODUCT_DATA_LIST', $data) && isset($data['PRODUCT_DATA_LIST'][$checkProviderName]))
            {
                $productData = $data['PRODUCT_DATA_LIST'][$checkProviderName];
 
                if (isset($productData['PRICE_LIST'][$basketItem->getProductId()][$basketItem->getBasketCode()]))
                {
                    $resultData['PRICE_DATA'] = $productData['PRICE_LIST'][$basketItem->getProductId()][$basketItem->getBasketCode()];
                }
 
                if (isset($productData['AVAILABLE_QUANTITY_LIST'][$basketItem->getProductId()]))
                {
                    $resultData['AVAILABLE_QUANTITY'] = $productData['AVAILABLE_QUANTITY_LIST'][$basketItem->getProductId()];
                }
            }
        }
        else
        {
            $result->addErrors($r->getErrors());
        }
 
        if (isset($resultData))
        {
            $result->setData(
                $resultData
            );
        }
 
        return $result;
    }
 
    public static function tryReserveShipment(Sale\Shipment $shipment)
    {
        $context = self::prepareContext($shipment->getOrder());
        $r = self::checkContext($context);
        if (!$r->isSuccess())
        {
            return $r;
        }
 
        $shipmentItemList = [];
        foreach ($shipment->getShipmentItemCollection() as $item)
        {
            $basketItem = $item->getBasketItem();
            if ($basketItem->isReservableItem())
            {
                $shipmentItemList[] = $item;
            }
        }
 
        return self::tryReserveShipmentItemArray($shipmentItemList, $context);
    }
 
    protected static function tryReserveShipmentItemArray(array $shipmentItemList, array $context)
    {
        $result = new Sale\Result();
 
        $shipmentItem = current($shipmentItemList);
        if (!$shipmentItem)
        {
            return $result;
        }
 
        $availableQuantityList = [];
 
        $needQuantityList = self::getNeedQuantityByShipmentItemList($shipmentItemList);
        if (!$needQuantityList)
        {
            return $result;
        }
 
        $creator = Sale\Internals\ProviderCreator::create($context);
        foreach ($shipmentItemList as $shipmentItem)
        {
            $productData = $creator->createItemForReserveByShipmentItem($shipmentItem);
            $creator->addProductData($productData);
        }
 
        $r = $creator->getAvailableQuantityByStore();
        if ($r->isSuccess())
        {
            $data = $r->getData();
            if (array_key_exists('AVAILABLE_QUANTITY_LIST_BY_STORE', $data))
            {
                $availableQuantityList = $data['AVAILABLE_QUANTITY_LIST_BY_STORE'];
            }
        }
        else
        {
            $result->addErrors($r->getErrors());
        }
 
        if ($r->hasWarnings())
        {
            $result->addWarnings($r->getWarnings());
        }
 
        if (!$result->isSuccess())
        {
            return $result;
        }
 
        $applyItemsList = [];
 
        $pool = PoolQuantity::getInstance($shipmentItem->getCollection()->getShipment()->getOrder()->getInternalId());
 
        foreach ($availableQuantityList as $providerName => $productAvailableQuantityList)
        {
            $providerName = trim($providerName);
            foreach ($productAvailableQuantityList as $productId => $quantityByStore)
            {
                if (array_key_exists($productId, $needQuantityList[$providerName]))
                {
                    if (Sale\Configuration::getProductReservationCondition() !== Sale\Reservation\Configuration\ReserveCondition::ON_SHIP)
                    {
                        if (!isset($applyItemsList[$providerName][$productId]))
                        {
                            $applyItemsList[$providerName][$productId] = [];
                        }
 
                        foreach ($quantityByStore as $storeId => $quantity)
                        {
                            if ($quantity < $needQuantityList[$providerName][$productId][$storeId])
                            {
                                $poolQuantity = (float)$pool->getByStore(
                                    PoolQuantity::POOL_QUANTITY_TYPE,
                                    $productId,
                                    $storeId
                                );
 
                                $delta = $needQuantityList[$providerName][$productId][$storeId] - $quantity;
 
                                if ($delta < $poolQuantity)
                                {
                                    $applyItemsList[$providerName][$productId][$storeId] = $needQuantityList[$providerName][$productId][$storeId];
                                }
                                elseif ($poolQuantity > 0)
                                {
                                    $applyItemsList[$providerName][$productId][$storeId] = $quantity + $poolQuantity;
                                }
                                else
                                {
                                    $applyItemsList[$providerName][$productId][$storeId] = $quantity;
                                }
                            }
                            else
                            {
                                $applyItemsList[$providerName][$productId][$storeId] = $quantity;
                            }
                        }
                    }
                }
                else
                {
                    foreach ($shipmentItemList as $shipmentItem)
                    {
                        $basketItem = $shipmentItem->getBasketItem();
 
                        if ($basketItem->getProductId() === $productId)
                        {
                            $result->addWarning(
                                new Sale\ResultWarning(
                                    Main\Localization\Loc::getMessage(
                                        'SALE_PROVIDER_RESERVE_SHIPMENT_ITEM_WRONG_AVAILABLE_QUANTITY',
                                        ['#PRODUCT_NAME#' => $basketItem->getField('NAME')]
                                    ),
                                    'SALE_PROVIDER_RESERVE_SHIPMENT_ITEM_WRONG_AVAILABLE_QUANTITY'
                                )
                            );
 
                            break;
                        }
                    }
                }
            }
        }
 
        if (!empty($applyItemsList))
        {
            $shipmentItemMap = self::createProductShipmentItemMap($shipmentItemList);
 
            self::setQuantityAfterReserve($shipmentItemMap, $applyItemsList);
        }
 
        return $result;
    }
 
    public static function tryReserveShipmentItem(Sale\ShipmentItem $shipmentItem, array $context = array())
    {
        $order = $shipmentItem->getCollection()->getShipment()->getOrder();
 
        $context = self::prepareContext($order, $context);
        $r = self::checkContext($context);
        if (!$r->isSuccess())
        {
            return $r;
        }
 
        return self::tryReserveShipmentItemArray([$shipmentItem], $context);
    }
 
    public static function tryReserve(Sale\ReserveQuantity $reserveQuantity, array $context = array())
    {
        $result = new Sale\Result();
 
        $basketItem = $reserveQuantity->getCollection()->getBasketItem();
 
        $order = $basketItem->getBasket()->getOrder();
 
        $context = self::prepareContext($order, $context);
        $r = self::checkContext($context);
        if (!$r->isSuccess())
        {
            return $r;
        }
 
        $creator = Sale\Internals\ProviderCreator::create($context);
 
        $productData = $creator->createItemForReserve($reserveQuantity);
        $creator->addProductData($productData);
 
        $availableQuantityList = [];
 
        $r = $creator->getAvailableQuantityByStore();
        if ($r->isSuccess())
        {
            $data = $r->getData();
            if (array_key_exists('AVAILABLE_QUANTITY_LIST_BY_STORE', $data))
            {
                $availableQuantityList = $data['AVAILABLE_QUANTITY_LIST_BY_STORE'];
            }
        }
        else
        {
            return $result->addErrors($r->getErrors());
        }
 
        if ($r->hasWarnings())
        {
            $result->addWarnings($r->getWarnings());
        }
 
        $pool = PoolQuantity::getInstance($order->getInternalId());
 
        $providerName = $basketItem->getProviderName();
        $providerName = self::clearProviderName($providerName);
 
        $storeId = $reserveQuantity->getStoreId();
        $availableQuantity = $availableQuantityList[$providerName][$basketItem->getProductId()][$storeId] ?? 0;
 
        if ($availableQuantity < $productData['QUANTITY'])
        {
            $result->addError(
                new Sale\ResultError(
                    Main\Localization\Loc::getMessage('SALE_PROVIDER_RESERVE_WRONG_AVAILABLE_QUANTITY'),
                    'SALE_PROVIDER_RESERVE_WRONG_AVAILABLE_QUANTITY'
                )
            );
        }
        else
        {
            $pool->addByStore(
                Sale\Internals\PoolQuantity::POOL_RESERVE_TYPE,
                $basketItem->getProductId(),
                $storeId,
                $productData['QUANTITY']
            );
 
            $foundItem = false;
            $poolItems = Sale\Internals\ItemsPool::get($order->getInternalId(), $basketItem->getProductId());
            if (!empty($poolItems))
            {
                foreach ($poolItems as $poolItem)
                {
                    if (
                        $poolItem instanceof Sale\ReserveQuantity
                        && $poolItem->getInternalIndex() === $reserveQuantity->getInternalIndex()
                        && $poolItem->getCollection()->getBasketItem()->getInternalIndex() === $reserveQuantity->getCollection()->getBasketItem()->getInternalIndex()
                    )
                    {
                        $foundItem = true;
                        break;
                    }
                }
            }
 
            if (!$foundItem)
            {
                Sale\Internals\ItemsPool::add(
                    $order->getInternalId(),
                    $basketItem->getProductId(),
                    $reserveQuantity
                );
            }
        }
 
        return $result;
    }
 
    public static function tryUnreserveShipmentItem(Sale\ShipmentItem $shipmentItem) : Sale\Result
    {
        $result = new Sale\Result();
 
        $order = $shipmentItem->getCollection()->getShipment()->getOrder();
 
        $pool = PoolQuantity::getInstance($order->getInternalId());
 
        $basketItem = $shipmentItem->getBasketItem();
 
        $productId = $basketItem->getProductId();
 
        $reservedQuantity = $shipmentItem->getReservedQuantity();
 
        if ($reservedQuantity == 0)
        {
            return $result;
        }
 
        $pool->add(Sale\Internals\PoolQuantity::POOL_RESERVE_TYPE, $productId, -1 * $reservedQuantity);
 
        $foundItem = false;
        $poolItems = Sale\Internals\ItemsPool::get($order->getInternalId(), $productId);
        if (!empty($poolItems))
        {
            foreach ($poolItems as $poolItem)
            {
                if (
                    $poolItem instanceof Sale\ShipmentItem
                    && $poolItem->getInternalIndex() == $shipmentItem->getInternalIndex()
                )
                {
                    $foundItem = true;
                    break;
                }
            }
        }
 
        if (!$foundItem)
        {
            Sale\Internals\ItemsPool::add($order->getInternalId(), $productId, $shipmentItem);
        }
 
        $r = $shipmentItem->setField('RESERVED_QUANTITY', $shipmentItem->getReservedQuantity() + -1 * $reservedQuantity);
        if (!$r->isSuccess())
        {
            $result->addErrors($r->getErrors());
        }
 
        return $result;
    }
 
    private static function getNeedQuantityByShipmentItemList(array $shipmentItemList) : array
    {
        $needQuantityList = [];
 
        foreach ($shipmentItemList as $shipmentItem)
        {
            $quantityList = self::getNeedQuantityByShipmentItem($shipmentItem);
            $providerName = key($quantityList);
            $productId = key($quantityList[$providerName]);
 
            foreach ($quantityList[$providerName][$productId] as $storeId => $quantity)
            {
                if (!isset($needQuantityList[$providerName][$productId][$storeId]))
                {
                    $needQuantityList[$providerName][$productId][$storeId] = 0;
                }
 
                $needQuantityList[$providerName][$productId][$storeId] += $quantity;
            }
        }
 
        return $needQuantityList;
    }
 
    private static function getNeedQuantityByShipmentItem(Sale\ShipmentItem $shipmentItem) : array
    {
        $basketItem = $shipmentItem->getBasketItem();
 
        $productId = $basketItem->getProductId();
 
        $providerName = $basketItem->getProviderName();
        $providerName = self::clearProviderName($providerName);
 
        $quantity = $shipmentItem->getQuantity();
        if ($quantity == 0)
        {
            return [
                $providerName => [
                    $productId => [
                        Sale\Configuration::getDefaultStoreId() => -$shipmentItem->getReservedQuantity(),
                    ],
                ],
            ];
        }
        else
        {
            $quantityByStore = [];
 
            $shipmentItemStoreCollection = $shipmentItem->getShipmentItemStoreCollection();
            if ($shipmentItemStoreCollection)
            {
                foreach ($shipmentItemStoreCollection as $shipmentItemStore)
                {
                    if (!isset($quantityByStore[$shipmentItemStore->getStoreId()]))
                    {
                        $quantityByStore[$shipmentItemStore->getStoreId()] = 0;
                    }
 
                    $quantityByStore[$shipmentItemStore->getStoreId()] += $shipmentItemStore->getQuantity();
 
                    $quantity -= $shipmentItemStore->getQuantity();
                }
            }
 
            if ($quantity)
            {
                $storeId = Sale\Configuration::getDefaultStoreId();
 
                if (!isset($quantityByStore[$storeId]))
                {
                    $quantityByStore[$storeId] = 0;
                }
 
                $quantityByStore[$storeId] += $quantity;
            }
 
            return [
                $providerName => [
                    $productId => $quantityByStore,
                ],
            ];
        }
    }
 
    public static function tryUnreserveShipment(Sale\Shipment $shipment)
    {
        $result = new Sale\Result();
 
        $order = $shipment->getOrder();
 
        $pool = PoolQuantity::getInstance($order->getInternalId());
 
        foreach ($shipment->getShipmentItemCollection() as $shipmentItem)
        {
            if (!$basketItem = $shipmentItem->getBasketItem())
            {
                continue;
            }
 
            if ((int)$shipmentItem->getReservedQuantity() === 0)
            {
                continue;
            }
 
            $shipmentItemReserveQuantity = $shipmentItem->getReservedQuantity();
 
            $reserveCollection = $basketItem->getReserveQuantityCollection();
            if (!$reserveCollection)
            {
                continue;
            }
 
            $shipmentItemStoreCollection = $shipmentItem->getShipmentItemStoreCollection();
            if ($shipmentItemStoreCollection)
            {
                foreach ($shipmentItemStoreCollection as $itemStore)
                {
                    if ($shipmentItemReserveQuantity == 0)
                    {
                        break;
                    }
 
                    foreach ($reserveCollection as $reserve)
                    {
                        if ($reserve->getStoreId() !== $itemStore->getStoreId())
                        {
                            continue;
                        }
 
                        // try to guess reserved quantity on shipment item store
                        if ($shipmentItemReserveQuantity > $itemStore->getQuantity())
                        {
                            $reserveStoreQuantity =  $itemStore->getQuantity();
                        }
                        else
                        {
                            $reserveStoreQuantity =  $shipmentItemReserveQuantity;
                        }
 
                        if ($reserveStoreQuantity >= $reserve->getQuantity())
                        {
                            $poolQuantity = $reserve->getQuantity();
 
                            $reserve->deleteNoDemand();
                        }
                        else
                        {
                            $poolQuantity = $reserveStoreQuantity;
 
                            $reserve->setFieldNoDemand('QUANTITY', $reserve->getQuantity() - $reserveStoreQuantity);
                        }
 
                        $shipmentItemReserveQuantity -= $reserveStoreQuantity;
                        $pool->addByStore(
                            PoolQuantity::POOL_RESERVE_TYPE,
                            $basketItem->getProductId(),
                            $itemStore->getStoreId(),
                            -$poolQuantity
                        );
                    }
                }
            }
 
 
            if ($shipmentItemReserveQuantity > 0)
            {
                $storeId = Sale\Configuration::getDefaultStoreId();
 
                foreach ($reserveCollection as $reserve)
                {
                    if ($shipmentItemReserveQuantity == 0)
                    {
                        break;
                    }
 
                    if ($reserve->getStoreId() !== $storeId)
                    {
                        continue;
                    }
 
                    if ($shipmentItemReserveQuantity >= $reserve->getQuantity())
                    {
                        $poolQuantity = $reserve->getQuantity();
                        $shipmentItemReserveQuantity -= $poolQuantity;
 
                        $reserve->deleteNoDemand();
                    }
                    else
                    {
                        $reserve->setFieldNoDemand('QUANTITY', $reserve->getQuantity() - $shipmentItemReserveQuantity);
                        $shipmentItemReserveQuantity = 0;
 
                        $poolQuantity = $shipmentItemReserveQuantity;
                    }
 
                    $pool->addByStore(
                        PoolQuantity::POOL_RESERVE_TYPE,
                        $basketItem->getProductId(),
                        $storeId,
                        -$poolQuantity
                    );
                }
            }
 
            $shipmentItem->getFields()->set('RESERVED_QUANTITY', 0);
 
            if (!Sale\Internals\ActionEntity::isTypeExists(
                    $order->getInternalId(),
                    Sale\Internals\ActionEntity::ACTION_ENTITY_SHIPMENT_COLLECTION_RESERVED_QUANTITY
                )
            )
            {
                Sale\Internals\ActionEntity::add(
                    $order->getInternalId(),
                    Sale\Internals\ActionEntity::ACTION_ENTITY_SHIPMENT_COLLECTION_RESERVED_QUANTITY,
                    [
                        'METHOD' => 'Bitrix\Sale\Shipment::updateReservedFlag',
                        'PARAMS' => [$shipment],
                    ]
                );
            }
 
            $foundItem = false;
            $poolItems = Sale\Internals\ItemsPool::get($order->getInternalId(), $basketItem->getProductId());
            if (!empty($poolItems))
            {
                foreach ($poolItems as $poolItem)
                {
                    if (
                        $poolItem instanceof Sale\ShipmentItem
                        && $poolItem->getInternalIndex() == $shipmentItem->getInternalIndex()
                    )
                    {
                        $foundItem = true;
                        break;
                    }
                }
            }
 
            if (!$foundItem)
            {
                Sale\Internals\ItemsPool::add($order->getInternalId(), $basketItem->getProductId(), $shipmentItem);
            }
        }
 
        return $result;
    }
 
    private static function createProductShipmentItemMap(array $shipmentItemList)
    {
        $result = [];
 
        foreach ($shipmentItemList as $shipmentItem)
        {
            $basketItem = $shipmentItem->getBasketItem();
 
            $providerName = self::clearProviderName($basketItem->getProviderName());
 
            $result[$providerName][$basketItem->getProductId()][$shipmentItem->getInternalIndex()] = $shipmentItem;
        }
 
        return $result;
    }
 
    private static function setQuantityAfterReserve(array $shipmentItemMap, array $availableQuantityList)
    {
        $result = new Sale\Result();
 
        foreach ($availableQuantityList as $providerName => $productsList)
        {
            foreach ($productsList as $productId => $reservedQuantityByStore)
            {
                foreach ($reservedQuantityByStore as $storeId => $reservedQuantity)
                {
                    $r = self::setReserveQuantityByProduct($shipmentItemMap[$providerName][$productId], $storeId, $reservedQuantity);
                    if (!$r->isSuccess())
                    {
                        $result->addErrors($r->getErrors());
                    }
                }
            }
        }
 
        return $result;
    }
 
    private static function setReserveQuantityByProduct(array $shipmentItemList, $storeId, $quantity) : Sale\Result
    {
        $result = new Sale\Result();
 
        if ($quantity == 0)
        {
            return $result;
        }
 
        foreach ($shipmentItemList as $shipmentItem)
        {
            $basketItem = $shipmentItem->getBasketItem();
            if (!$basketItem->isReservableItem())
            {
                continue;
            }
 
            $reserveQuantityCollection = $basketItem->getReserveQuantityCollection();
            if (!$reserveQuantityCollection)
            {
                continue;
            }
 
            $productId = $basketItem->getProductId();
 
            $order = $basketItem->getBasket()->getOrder();
 
            $pool = PoolQuantity::getInstance($order->getInternalId());
 
            $reserve = null;
 
            foreach ($reserveQuantityCollection as $item)
            {
                if ($item->getStoreId() === $storeId)
                {
                    $reserve = $item;
                    break;
                }
            }
 
            if ($reserve === null)
            {
                $reserve = $reserveQuantityCollection->create();
                $reserve->setStoreId($storeId);
            }
 
            if ($quantity < 0)
            {
                $settableQuantity = $quantity;
                if ($shipmentItem->getReservedQuantity() < $quantity)
                {
                    $settableQuantity = $shipmentItem->getReservedQuantity();
                }
            }
            else
            {
                $needQuantity = $basketItem->getQuantity() - $reserve->getQuantity();
                $settableQuantity = (abs($needQuantity) >= abs($quantity)) ? $quantity : $needQuantity;
            }
 
            $reserve->setFieldNoDemand('QUANTITY', $reserve->getQuantity() + $settableQuantity);
 
            self::applyReserveToShipmentItem($shipmentItem, $settableQuantity);
 
            $quantity -= $settableQuantity;
 
            $pool->addByStore(Sale\Internals\PoolQuantity::POOL_RESERVE_TYPE, $productId, $storeId, $settableQuantity);
 
            $foundItem = false;
            $poolItems = Sale\Internals\ItemsPool::get($order->getInternalId(), $productId);
            if (!empty($poolItems))
            {
                foreach ($poolItems as $poolItem)
                {
                    if (
                        $poolItem instanceof Sale\ShipmentItem
                        && $poolItem->getInternalIndex() == $shipmentItem->getInternalIndex()
                    )
                    {
                        $foundItem = true;
                        break;
                    }
                }
            }
 
            if (!$foundItem)
            {
                Sale\Internals\ItemsPool::add($order->getInternalId(), $productId, $shipmentItem);
            }
        }
 
        return $result;
    }
 
    protected static function applyReserveToShipmentItem(Sale\ShipmentItem $item, $quantity)
    {
        $item->getFields()->set('RESERVED_QUANTITY', $item->getReservedQuantity() + $quantity);
 
        $shipment = $item->getCollection()->getShipment();
        $order = $shipment->getOrder();
 
        if (!Sale\Internals\ActionEntity::isTypeExists(
                $order->getInternalId(),
                Sale\Internals\ActionEntity::ACTION_ENTITY_SHIPMENT_RESERVED_QUANTITY
            )
        )
        {
            Sale\Internals\ActionEntity::add(
                $order->getInternalId(),
                Sale\Internals\ActionEntity::ACTION_ENTITY_SHIPMENT_RESERVED_QUANTITY,
                [
                    'METHOD' => 'Bitrix\Sale\Shipment::updateReservedFlag',
                    'PARAMS' => [$shipment],
                ]
            );
        }
 
    }
 
    public static function tryShipShipment(Sale\Shipment $shipment, array $context = array())
    {
        $result = new Sale\Result();
 
        $order = $shipment->getOrder();
 
        $context = self::prepareContext($order, $context);
 
        $pool = PoolQuantity::getInstance($order->getInternalId());
 
        $shipmentItemCollection = $shipment->getShipmentItemCollection();
 
        $needShipList = array();
        $creator = Sale\Internals\ProviderCreator::create($context);
        foreach ($shipmentItemCollection as $shipmentItem)
        {
            $creator->addShipmentItem($shipmentItem);
        }
 
        $r = $creator->isNeedShip();
        if ($r->isSuccess())
        {
            $data = $r->getData();
            if (array_key_exists('IS_NEED_SHIP', $data))
            {
                $needShipList = $data['IS_NEED_SHIP'] + $needShipList;
            }
        }
 
        $creator = Sale\Internals\ProviderCreator::create($context);
        foreach ($shipmentItemCollection as $shipmentItem)
        {
            $shipmentProductData = $creator->createItemForShip($shipmentItem, $needShipList);
            $creator->addProductData($shipmentProductData);
        }
 
        $tryShipProductList = array();
 
        $isIgnoreErrors = false;
 
        $r = $creator->tryShip();
 
        $needSetAfterResult = false;
        if ($r->isSuccess())
        {
            if ($r->hasWarnings())
            {
                $result->addWarnings($r->getWarnings());
            }
            else
            {
                $needSetAfterResult = true;
            }
        }
        else
        {
            $result->addWarnings($r->getErrors());
 
            if (self::isIgnoreErrors())
            {
                $isIgnoreErrors = true;
                $needSetAfterResult = true;
            }
            else
            {
                $result->addErrors($r->getErrors());
            }
 
        }
 
        $data = $r->getData();
        if (array_key_exists('TRY_SHIP_PRODUCTS_LIST', $data))
        {
            $tryShipProductList = $data['TRY_SHIP_PRODUCTS_LIST'] + $tryShipProductList;
        }
 
        if ($needSetAfterResult && !empty($tryShipProductList))
        {
 
            if ($isIgnoreErrors)
            {
                foreach ($tryShipProductList as &$productList)
                {
                    $productList = array_fill_keys(array_keys($productList), true);
                }
            }
 
            $creator->setItemsResultAfterTryShip($pool, $tryShipProductList);
        }
 
        return $result;
    }
 
    public static function deliver(Sale\Shipment $shipment)
    {
        $result = new Sale\Result();
 
        $order = $shipment->getOrder();
 
        $context = array(
            'USER_ID' => $order->getUserId(),
            'SITE_ID' => $order->getSiteId(),
        );
 
        $creator = Sale\Internals\ProviderCreator::create($context);
 
        foreach ($shipment->getShipmentItemCollection() as $shipmentItem)
        {
            $creator->addShipmentItem($shipmentItem);
        }
 
        $r = $creator->deliver();
        if ($r->isSuccess())
        {
            $r = $creator->createItemsResultAfterDeliver($r);
            if ($r->isSuccess())
            {
                $data = $r->getData();
                if (
                    !empty($data['RESULT_AFTER_DELIVER_LIST'])
                    && is_array($data['RESULT_AFTER_DELIVER_LIST'])
                )
                {
                    $result->setData($data['RESULT_AFTER_DELIVER_LIST']);
                }
            }
        }
        else
        {
            $result->addErrors($r->getErrors());
        }
 
        return $result;
    }
 
    public static function changeProductBatchBalance(Sale\Shipment $shipment): Sale\Result
    {
        $result = new Sale\Result();
 
        $order = $shipment->getOrder();
 
        $context = array(
            'USER_ID' => $order->getUserId(),
            'SITE_ID' => $order->getSiteId(),
        );
 
        $creator = Sale\Internals\ProviderCreator::create($context);
 
        foreach ($shipment->getShipmentItemCollection() as $shipmentItem)
        {
            $creator->addShipmentItem($shipmentItem);
        }
 
        $r =
            $shipment->isShipped()
                ? $creator->writeOffProductBatches()
                : $creator->returnProductBatches()
        ;
 
        if (!$r->isSuccess())
        {
            $result->addErrors($r->getErrors());
        }
 
        return $result;
    }
 
    public static function createMapShipmentItemStoreData(Sale\ShipmentItem $shipmentItem, $needUseReserve = true)
    {
        $resultList = array();
 
        $basketItem = $shipmentItem->getBasketItem();
        if (!$basketItem->isReservableItem())
        {
            return false;
        }
 
        $reserveQuantityCollection = $basketItem->getReserveQuantityCollection();
        if (!$reserveQuantityCollection)
        {
            return false;
        }
 
        $reserveQuantityStoreList = [];
 
        $countBarcode = 0;
 
        $shipmentItemStoreCollection = $shipmentItem->getShipmentItemStoreCollection();
        if ($shipmentItemStoreCollection)
        {
            foreach ($shipmentItemStoreCollection as $shipmentItemStore)
            {
                $productId = $basketItem->getProductId();
 
                $storeId = $shipmentItemStore->getStoreId();
 
                if (!isset($reserveQuantityStoreList[$storeId]))
                {
                    $reserveQuantityStoreList[$storeId] = $reserveQuantityCollection->getQuantityByStoreId($shipmentItemStore->getStoreId());
                }
 
                if (!isset($resultList[$storeId]))
                {
                    $resultList[$storeId] = [
                        'PRODUCT_ID' => $productId,
                        'QUANTITY' => 0,
                        'RESERVED_QUANTITY' => 0,
                        'STORE_ID' => $storeId,
                        'IS_BARCODE_MULTI' => $basketItem->isBarcodeMulti(),
                        'BARCODE' => [],
                    ];
                }
 
                $barcodeId = ($shipmentItemStore->getId() > 0)? $shipmentItemStore->getId() : 'n'.$countBarcode;
                $countBarcode++;
                $resultList[$storeId]['QUANTITY'] += $basketItem->isBarcodeMulti()? 1 : $shipmentItemStore->getQuantity();
                $resultList[$storeId]['BARCODE'][$barcodeId] = $shipmentItemStore->getBarcode();
 
                if ($needUseReserve)
                {
                    if ($reserveQuantityStoreList[$storeId] > $resultList[$storeId]['QUANTITY'])
                    {
                        $resultList[$storeId]['RESERVED_QUANTITY'] = $resultList[$storeId]['QUANTITY'];
                    }
                    elseif ($reserveQuantityStoreList[$storeId] > 0)
                    {
                        $resultList[$storeId]['RESERVED_QUANTITY'] = $reserveQuantityStoreList[$storeId];
                    }
 
                    $reserveQuantityStoreList[$storeId] -= $resultList[$storeId]['RESERVED_QUANTITY'];
                }
            }
        }
 
        return $resultList;
    }
 
    public static function createMapShipmentItemCollectionStoreData($shipmentItemList)
    {
        $resultList = array();
 
        foreach ($shipmentItemList as $shipmentItem)
        {
            $basketCode = $shipmentItem->getBasketCode();
 
            if (!isset($resultList[$basketCode]))
            {
                $resultList[$basketCode] = array();
            }
 
            $map = self::createMapShipmentItemStoreData($shipmentItem);
            if (!empty($map) && is_array($map))
            {
                $resultList[$basketCode] = $map + $resultList[$basketCode];
            }
        }
 
        return $resultList;
    }
 
 
    public static function save(Sale\Order $order, array $context = array())
    {
        $result = new Sale\Result();
 
        $context = self::prepareContext($order, $context);
 
        $r = self::checkContext($context);
        if (!$r->isSuccess())
        {
            $result->addErrors($r->getErrors());
            return $result;
        }
 
        $pool = PoolQuantity::getInstance($order->getInternalId());
 
        $rulesMap = Sale\Internals\ShipmentRules::createOrderRuleMap($order, $pool);
 
        if (empty($rulesMap))
        {
            return $result;
        }
 
        $r = Sale\Internals\ShipmentRules::saveRules($rulesMap, $context);
        if (!$r->isSuccess())
        {
            $result->addErrors($r->getErrors());
        }
 
        if ($r->hasWarnings())
        {
            $result->addWarnings($r->getWarnings());
        }
 
        $pool->reset(PoolQuantity::POOL_QUANTITY_TYPE);
        $pool->reset(PoolQuantity::POOL_RESERVE_TYPE);
 
        return $result;
    }
 
    private static function prepareContext(Sale\OrderBase $order, array $context = array())
    {
        if (empty($context))
        {
            $context = [
                'SITE_ID' => $order->getSiteId(),
                'USER_ID' => $order->getUserId(),
                'CURRENCY' => $order->getCurrency(),
            ];
        }
 
        if (!empty($context))
        {
            if (empty($context['SITE_ID']))
            {
                $context['SITE_ID'] = $order->getSiteId();
            }
 
            if (empty($context['USER_ID']) && $order->getUserId() > 0)
            {
                $context['USER_ID'] = $order->getUserId();
            }
 
            if (empty($context['CURRENCY']))
            {
                $context['CURRENCY'] = $order->getCurrency();
            }
        }
 
        return $context;
    }
 
    private static function checkContext(array $context)
    {
        $result = new Sale\Result();
 
        if (empty($context['SITE_ID']))
        {
            throw new Main\ArgumentNullException('SITE_ID');
        }
 
        if (empty($context['CURRENCY']))
        {
            throw new Main\ArgumentNullException('CURRENCY');
        }
 
        return $result;
    }
 
    public static function getProviderName($module, $name)
    {
        static $providerProxy = array();
        $code = $module."|".$name;
 
        if (array_key_exists($code, $providerProxy))
        {
            return $providerProxy[$code];
        }
 
        $providerName = null;
        if (strval($module) != '' && Main\Loader::includeModule($module) && class_exists($name))
        {
            $provider = self::getProviderEntity($name);
            if ($provider)
            {
                $providerName = $name;
            }
        }
 
        if ($providerName !== null)
        {
            $providerProxy[$code] = $providerName;
        }
 
        return $providerName;
    }
 
    public static function getProviderEntity($name)
    {
        static $providerEntityProxy = array();
        if (array_key_exists($name, $providerEntityProxy))
        {
            return $providerEntityProxy[$name];
        }
 
        if (
            class_exists($name)
            && (
                is_subclass_of($name, Sale\SaleProviderBase::class)
                || is_subclass_of($name, \IBXSaleProductProvider::class)
            )
        )
        {
            $providerEntityProxy[$name] = new $name();
            return $providerEntityProxy[$name];
        }
 
        return null;
    }
 
 
    private static function clearProviderName($providerName)
    {
        if (empty($providerName) || !is_string($providerName))
        {
            return '';
        }
 
        if (mb_substr($providerName, 0, 1) === "\\")
        {
            $providerName = mb_substr($providerName, 1);
        }
 
        return trim($providerName);
    }
 
    public static function setIgnoreErrors($value)
    {
        self::$ignoreErrors = ($value === true);
    }
 
    public static function isIgnoreErrors()
    {
        return self::$ignoreErrors;
    }
 
}