Класс Provider

Открытые статические члены
static	getProductData ($basketList, array $context)
static	getBundleItems (Sale\BasketItemBase $basketItem, array $context)
static	checkAvailableQuantityByBasketItem (Sale\BasketItemBase $basketItem, array $context=array())
static	getAvailableQuantityAndPriceByBasketItem (Sale\BasketItemBase $basketItem, array $context=array())
static	tryReserveShipment (Sale\Shipment $shipment, array $context=array())
static	tryReserveShipmentItem (Sale\ShipmentItem $shipmentItem, array $context=array())
static	tryUnreserveShipmentItem (Sale\ShipmentItem $shipmentItem)
static	tryUnreserveShipment (Sale\Shipment $shipment)
static	tryShipShipment (Sale\Shipment $shipment, array $context=array())
static	createProviderItemsMap (Sale\ShipmentItemCollection $shipmentItemCollection)
static	createProviderItemsMapByRules (array $rulesProducts)
static	createMapShipmentItemStoreData (Sale\ShipmentItem $shipmentItem)
static	createMapShipmentItemCollectionStoreData ($shipmentItemList)
static	save (Sale\Order $order, array $context=array())
static	getOrderByShipment (Sale\Shipment $shipment)
static	getProviderName ($module, $name)
static	getProviderEntity ($name)
static	isProviderCallbackFunction ($name)
static	setIgnoreErrors ($value)
static	isIgnoreErrors ()

Поля данных
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

Подробное описание

См. определение в файле sale/lib/internals/catalog/provider.php строка 17

Методы

checkAvailableQuantityByBasketItem()

static checkAvailableQuantityByBasketItem ( Sale\BasketItemBase  $basketItem, array  $context = array()  )

static

Аргументы

Sale\BasketItemBase	$basketItem
array | null	$context

Возвращает

Sale\Result

Исключения

Main

См. определение в файле sale/lib/internals/catalog/provider.php строка 114

    {
        $result = new Sale\Result();
 
        /** @var \Bitrix\Sale\Basket $basket */
        if (!$basket = $basketItem->getCollection())
        {
            throw new Main\ObjectNotFoundException('Entity "Basket" not found');
        }
 
        $order = $basket->getOrder();
        if (empty($context) && $order)
        {
            $context = static::prepareContext($order, $context);
        }
 
        $r = static::checkContext($context);
        if (!$r->isSuccess())
        {
            return $r;
        }
 
        $quantity = $basketItem->getQuantity();
        $productId = $basketItem->getProductId();
        $poolQuantity = 0;
 
        if ($order)
        {
            $fields = $basketItem->getFields();
            $originalValues = $fields->getOriginalValues();
            $values = $fields->getValues();
            $deltaQuantity = floatval($values['QUANTITY']) - floatval($originalValues['QUANTITY']);
 
            if ($deltaQuantity <= 0)
            {
                $result->setData(
                    array(
                        'AVAILABLE_QUANTITY' => $quantity
                    )
                );
 
                return $result;
            }
 
            $pool = PoolQuantity::getInstance($order->getInternalId());
            $poolQuantity = $pool->get(PoolQuantity::POOL_RESERVE_TYPE, $productId);
            if (!empty($poolQuantity))
            {
                $tryQuantity = $quantity + $poolQuantity;
                if ($tryQuantity == 0)
                {
                    $result->setData(array(
                         'AVAILABLE_QUANTITY' => $quantity
                     ));
 
                    return $result;
                }
            }
        }
 
 
        $resultList = array();
 
        $creator = Sale\Internals\ProviderCreator::create($context);
 
        /** @var Sale\BasketItem $basketItem */
        $creator->addBasketItem($basketItem);
 
        $r = $creator->getAvailableQuantity();
        if ($r->isSuccess())
        {
            $providerName = null;
            $providerName = $basketItem->getProviderName();
 
            if (strval(trim($providerName)) == '')
            {
                $providerName = $basketItem->getCallbackFunction();
            }
 
            if (!empty($providerName) && $providerName[0] == "\\")
            {
                $providerName = ltrim($providerName, '\\');
            }
 
            $checkProviderName = $providerName;
            $data = $r->getData();
            if (array_key_exists('AVAILABLE_QUANTITY_LIST', $data) && isset($data['AVAILABLE_QUANTITY_LIST'][$checkProviderName]))
            {
                $resultList = $data['AVAILABLE_QUANTITY_LIST'][$checkProviderName];
            }
        }
        else
        {
            $result->addErrors($r->getErrors());
        }
 
        if (isset($resultList[$productId]))
        {
            $result->setData(
                array(
                    'AVAILABLE_QUANTITY' => $resultList[$productId] - $poolQuantity
                )
            );
        }
 
        return $result;
    }

createMapShipmentItemCollectionStoreData()

static createMapShipmentItemCollectionStoreData (   $shipmentItemList )

static

См. определение в файле sale/lib/internals/catalog/provider.php строка 1355

    {
        $resultList = array();
 
        /** @var Sale\ShipmentItem $shipmentItem */
        foreach ($shipmentItemList as $shipmentItem)
        {
            $basketCode = $shipmentItem->getBasketCode();
 
            if (!isset($resultList[$basketCode]))
            {
                $resultList[$basketCode] = array();
            }
            
            $map = static::createMapShipmentItemStoreData($shipmentItem);
            if (!empty($map) && is_array($map))
            {
                $resultList[$basketCode] = $map + $resultList[$basketCode];
            }
        }
 
        return $resultList;
    }

createMapShipmentItemStoreData()

static createMapShipmentItemStoreData ( Sale\ShipmentItem  $shipmentItem )

static

См. определение в файле sale/lib/internals/catalog/provider.php строка 1294

    {
        $resultList = array();
 
        /** @var Sale\BasketItem $basketItem */
        if (!$basketItem = $shipmentItem->getBasketItem())
        {
            throw new Main\ObjectNotFoundException('Entity "BasketItem" not found');
        }
 
        if ($basketItem->isBundleParent())
        {
            return false;
        }
 
        /** @var Sale\ShipmentItemStoreCollection $shipmentItemStoreCollection */
        if (!$shipmentItemStoreCollection = $shipmentItem->getShipmentItemStoreCollection())
        {
            throw new Main\ObjectNotFoundException('Entity "ShipmentItemStoreCollection" not found');
        }
 
        if ($shipmentItemStoreCollection->count() > 0)
        {
            $countBarcode = 0;
            /** @var Sale\ShipmentItemStore $shipmentItemStore */
            foreach ($shipmentItemStoreCollection as $shipmentItemStore)
            {
                $productId = $basketItem->getProductId();
 
                $storeId = $shipmentItemStore->getStoreId();
 
                if (!isset($resultList[$storeId]))
                {
                    $resultList[$storeId] = array(
                        'PRODUCT_ID' => $productId,
                        'QUANTITY' => 0,
                        'STORE_ID' => $storeId,
                        'IS_BARCODE_MULTI' => $basketItem->isBarcodeMulti(),
                        'BARCODE' => array()
                    );
                }
 
                $barcodeId = ($shipmentItemStore->getId() > 0)? $shipmentItemStore->getId() : 'n'.$countBarcode;
                $countBarcode++;
                $resultList[$storeId]['QUANTITY'] += $basketItem->isBarcodeMulti()? 1 : $shipmentItemStore->getQuantity();
                $resultList[$storeId]['BARCODE'][$barcodeId] = $shipmentItemStore->getBarcode();
 
            }
        }
 
        return $resultList;
    }

createProviderItemsMap()

static createProviderItemsMap ( Sale\ShipmentItemCollection  $shipmentItemCollection )

static

Аргументы

Sale\ShipmentItemCollection

$shipmentItemCollection

Возвращает

array

Исключения

Main

См. определение в файле sale/lib/internals/catalog/provider.php строка 1174

    {
        $providerProductList = array();
        /** @var Sale\ShipmentItem $shipmentItem */
        foreach ($shipmentItemCollection as $shipmentItem)
        {
            $basketItem = $shipmentItem->getBasketItem();
 
            if (!$basketItem)
            {
                throw new Main\ObjectNotFoundException('Entity "BasketItem" not found');
            }
            if ($basketItem->isBundleParent())
            {
                continue;
            }
 
            $productId = $basketItem->getProductId();
            $providerName = $basketItem->getProvider();
            if (!isset($providerProductList[$providerName][$productId]))
            {
                $fields = array(
                    'PRODUCT_ID' => $productId,
                    'QUANTITY' => floatval($shipmentItem->getQuantity()),
                    'SHIPMENT_ITEM_LIST' => array(),
                    'IS_BUNDLE_CHILD' => $basketItem->isBundleChild(),
                );
            }
            else
            {
                $fields = $providerProductList[$providerName][$productId];
                $fields['QUANTITY'] += floatval($shipmentItem->getQuantity());
            }
 
            $shipmentItemIndex = $shipmentItem->getInternalIndex();
            $barcodeStoreData = static::createMapShipmentItemStoreData($shipmentItem);
            if (!empty($barcodeStoreData))
            {
                $fields['STORE'][$shipmentItemIndex] = $barcodeStoreData;
//              $fields['STORE'][$shipmentItemIndex]['IS_BARCODE_MULTI'] = $basketItem->isBarcodeMulti();
            }
 
            $fields['SHIPMENT_ITEM_LIST'][$shipmentItemIndex] = $shipmentItem;
 
            $providerProductList[$providerName][$productId] = $fields;
        }
 
        return $providerProductList;
    }

createProviderItemsMapByRules()

static createProviderItemsMapByRules ( array  $rulesProducts )

static

Аргументы

array

$rulesProducts

Возвращает

array

Исключения

Main

См. определение в файле sale/lib/internals/catalog/provider.php строка 1230

    {
        $providerProductList = array();
 
        foreach ($rulesProducts as $ruleData)
        {
            /** @var Sale\ShipmentItem $shipmentItem */
            $shipmentItem = $ruleData['SHIPMENT_ITEM'];
            if (!$shipmentItem)
            {
                throw new Main\ObjectNotFoundException('Entity "ShipmentItem" not found');
            }
 
 
            $productId = $ruleData['PRODUCT_ID'];
            $providerName = $ruleData['PROVIDER_NAME'];
            $shipmentItemIndex = $shipmentItem->getInternalIndex();
 
 
            if (!isset($providerProductList[$providerName][$productId]))
            {
                $fields = $ruleData;
                unset($fields['SHIPMENT_ITEM']);
                unset($fields['STORE']);
                unset($fields['NEED_RESERVE']);
                unset($fields['NEED_SHIP']);
                $fields['SHIPMENT_ITEM_LIST'] = array();
            }
            else
            {
                $fields = $providerProductList[$providerName][$productId];
                $fields['QUANTITY'] += $ruleData['QUANTITY'];
            }
 
            if (array_key_exists('NEED_RESERVE', $ruleData))
            {
                $fields['NEED_RESERVE'][$shipmentItemIndex] = $ruleData['NEED_RESERVE'];
            }
 
            if (array_key_exists('NEED_SHIP', $ruleData))
            {
                $fields['NEED_SHIP'][$shipmentItemIndex] = $ruleData['NEED_SHIP'];
            }
 
            if (!empty($ruleData['STORE']))
            {
                $fields['STORE'][$shipmentItemIndex] = $ruleData['STORE'][$shipmentItemIndex];
            }
 
            $fields['SHIPMENT_ITEM_LIST'][$shipmentItemIndex] = $shipmentItem;
 
            $providerProductList[$providerName][$productId] = $fields;
        }
 
        return $providerProductList;
    }

getAvailableQuantityAndPriceByBasketItem()

static getAvailableQuantityAndPriceByBasketItem ( Sale\BasketItemBase  $basketItem, array  $context = array()  )

static

Аргументы

Sale\BasketItemBase	$basketItem
array | null	$context

Возвращает

Sale\Result

Исключения

Main

См. определение в файле sale/lib/internals/catalog/provider.php строка 230

    {
        $result = new Sale\Result();
 
        /** @var \Bitrix\Sale\Basket $basket */
        if (!$basket = $basketItem->getCollection())
        {
            throw new Main\ObjectNotFoundException('Entity "Basket" not found');
        }
 
        $order = $basket->getOrder();
 
        if (empty($context) && !$order)
        {
            $context = $basket->getContext();
        }
 
        if (empty($context) && $order)
        {
            $context = static::prepareContext($order, $context);
        }
 
        $r = static::checkContext($context);
        if (!$r->isSuccess())
        {
            return $r;
        }
 
        $resultData = array();
 
        $creator = Sale\Internals\ProviderCreator::create($context);
 
        /** @var Sale\BasketItem $basketItem */
        $creator->addBasketItem($basketItem);
 
        $r = $creator->getAvailableQuantityAndPrice();
        if ($r->isSuccess())
        {
            $providerName = $basketItem->getProviderName();
 
            if (strval($providerName) == '')
            {
                $providerName = $basketItem->getCallbackFunction();
            }
 
            $providerName = static::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;
    }

getBundleItems()

static getBundleItems ( Sale\BasketItemBase  $basketItem, array  $context  )

static

Аргументы

Sale\BasketItemBase	$basketItem
array	$context

Возвращает

Sale\Result

Исключения

Main

См. определение в файле sale/lib/internals/catalog/provider.php строка 80

    {
        if (empty($context))
        {
            throw new Main\ArgumentNullException('context');
        }
 
        $result = new Sale\Result();
 
        $creator = Sale\Internals\ProviderCreator::create($context);
        /** @var Sale\BasketItem $basketItem */
        $creator->addBasketItem($basketItem);
 
        $r = $creator->getBundleItems();
        if ($r->isSuccess())
        {
            return $r;
        }
        else
        {
            $result->addErrors($r->getErrors());
        }
 
        return $result;
    }

getOrderByShipment()

static getOrderByShipment ( Sale\Shipment  $shipment )

static

Аргументы

Sale\Shipment

$shipment

Возвращает

Sale\Order

Исключения

Main

См. определение в файле sale/lib/internals/catalog/provider.php строка 1441

    {
        /** @var Sale\ShipmentCollection $shipmentCollection */
        $shipmentCollection = $shipment->getCollection();
        if (!$shipmentCollection)
        {
            throw new Main\ObjectNotFoundException('Entity "ShipmentCollection" not found');
        }
 
        $order = $shipmentCollection->getOrder();
        if (!$order)
        {
            throw new Main\ObjectNotFoundException('Entity "Order" not found');
        }
 
        return $order;
    }

getProductData()

static getProductData (   $basketList, array  $context  )

static

Аргументы

	$basketList
array	$context

Возвращает

Sale\Result

Исключения

Main

См. определение в файле sale/lib/internals/catalog/provider.php строка 35

    {
        $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);
        /** @var Sale\BasketItem $basketItem */
        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;
    }

getProviderEntity()

static getProviderEntity (   $name )

static

Аргументы

$name

Возвращает

mixed|null

См. определение в файле sale/lib/internals/catalog/provider.php строка 1602

    {
        static $providerEntityProxy = array();
        if (array_key_exists($name, $providerEntityProxy))
        {
            return $providerEntityProxy[$name];
        }
 
        if (class_exists($name))
        {
            $productProvider = new $name();
            if ($productProvider instanceof Sale\SaleProviderBase || array_key_exists("IBXSaleProductProvider", class_implements($name)))
            {
                $providerEntityProxy[$name] = $productProvider;
                return $productProvider;
            }
        }
 
        return null;
    }

getProviderName()

static getProviderName (   $module,   $name  )

static

Аргументы

$module
$name

Возвращает

string|null

Исключения

Main

См. определение в файле sale/lib/internals/catalog/provider.php строка 1569

    {
        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 = static::getProviderEntity($name);
            if ($provider)
            {
                $providerName = $name;
            }
        }
 
        if ($providerName !== null)
        {
            $providerProxy[$code] = $providerName;
        }
 
        return $providerName;
    }

isIgnoreErrors()

static isIgnoreErrors ( )

static

См. определение в файле sale/lib/internals/catalog/provider.php строка 1662

    {
        return static::$ignoreErrors;
    }

isProviderCallbackFunction()

static isProviderCallbackFunction (   $name )

static

Аргументы

$name

Возвращает

bool

См. определение в файле sale/lib/internals/catalog/provider.php строка 1628

    {
        return (array_key_exists("IBXSaleProductProvider", class_implements($name)));
    }

save()

static save ( Sale\Order  $order, array  $context = array()  )

static

Аргументы

Sale\Order	$order
array | null	$context

Возвращает

Sale\Result

Исключения

Main

См. определение в файле sale/lib/internals/catalog/provider.php строка 1387

    {
        $result = new Sale\Result();
 
        $context = static::prepareContext($order, $context);
 
        $r = static::checkContext($context);
        if (!$r->isSuccess())
        {
            $result->addErrors($r->getErrors());
            return $result;
        }
 
        $pool = PoolQuantity::getInstance($order->getInternalId());
        /** @var array $poolQuantitiesList */
        $poolQuantitiesList = $pool->getQuantities(PoolQuantity::POOL_QUANTITY_TYPE);
 
        /** @var array $poolReservationList */
        $poolReservationList = $pool->getQuantities(PoolQuantity::POOL_RESERVE_TYPE);
 
        if (empty($poolQuantitiesList) && empty($poolReservationList))
            return $result;
 
        $rulesMap = ShipmentRules::createOrderRuleMap($order, $pool);
 
        if (empty($rulesMap))
        {
            return $result;
        }
 
        $r = 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;
    }

setIgnoreErrors()

static setIgnoreErrors (   $value )

static

См. определение в файле sale/lib/internals/catalog/provider.php строка 1653

    {
        static::$ignoreErrors = ($value === true);
    }

tryReserveShipment()

static tryReserveShipment ( Sale\Shipment  $shipment, array  $context = array()  )

static

Аргументы

Sale\Shipment	$shipment
array	$context

Возвращает

Sale\Result

Исключения

Main

См. определение в файле sale/lib/internals/catalog/provider.php строка 317

    {
        $result = new Sale\Result();
 
        /** @var Sale\ShipmentCollection $shipmentCollection */
        if (!$shipmentCollection = $shipment->getCollection())
        {
            throw new Main\ObjectNotFoundException('Entity "ShipmentCollection" not found');
        }
 
        /** @var Sale\Order $order */
        $order = $shipmentCollection->getOrder();
        if (!$order)
        {
            throw new Main\ObjectNotFoundException('Entity "Order" not found');
        }
 
        $context = static::prepareContext($order, $context);
        $r = static::checkContext($context);
        if (!$r->isSuccess())
        {
            return $r;
        }
 
        $pool = PoolQuantity::getInstance($order->getInternalId());
 
        /** @var Sale\ShipmentItemCollection $shipmentCollection */
        $shipmentItemCollection = $shipment->getShipmentItemCollection();
 
        $availableQuantityList = array();
        $needQuantityList = array();
 
        /** @var Sale\Result $r */
        $r = static::getNeedQuantityByShipmentItemCollection($shipmentItemCollection);
        if (!$r->isSuccess())
        {
            $result->addErrors($r->getErrors());
        }
        else
        {
            $data = $r->getData();
            if (!empty($data['NEED_QUANTITY_LIST']))
            {
                $needQuantityList = $data['NEED_QUANTITY_LIST'];
            }
        }
 
        if ($r->hasWarnings())
        {
            $result->addWarnings($r->getWarnings());
        }
 
        if ($shipmentItemCollection->count() == 0)
        {
            return $result;
        }
 
        $creator = Sale\Internals\ProviderCreator::create($context);
        /** @var Sale\ShipmentItem $shipmentItem */
        foreach ($shipmentItemCollection as $shipmentItem)
        {
            $shipmentProductData = $creator->createItemForReserve($shipmentItem);
            $creator->addShipmentProductData($shipmentProductData);
        }
 
        $r = $creator->getAvailableQuantity();
        if ($r->isSuccess())
        {
            $data = $r->getData();
            if (array_key_exists('AVAILABLE_QUANTITY_LIST', $data))
            {
                $availableQuantityList = $data['AVAILABLE_QUANTITY_LIST'] + $availableQuantityList;
            }
        }
        else
        {
            $result->addErrors($r->getErrors());
        }
 
        if ($r->hasWarnings())
        {
            $result->addWarnings($r->getWarnings());
        }
 
        if (!empty($needQuantityList) && $result->isSuccess())
        {
            $applyItemsList = array();
 
            foreach ($availableQuantityList as $providerName => $productAvailableQuantityList)
            {
                $providerName = trim($providerName);
                foreach ($productAvailableQuantityList as $productId => $productAvailableQuantity)
                {
                    if (array_key_exists($productId, $needQuantityList[$providerName]))
                    {
                        if (Sale\Configuration::getProductReservationCondition() != Sale\Configuration::RESERVE_ON_SHIP)
                        {
                            $poolQuantity = 0;
                            if ($order->getId() > 0)
                            {
                                $poolQuantity = (float)$pool->get(PoolQuantity::POOL_RESERVE_TYPE, $productId);
                            }
                            $needQuantity = $needQuantityList[$providerName][$productId];
 
                            $productAvailableQuantity -= $poolQuantity;
                            $reservedQuantity = ($needQuantity >= $productAvailableQuantity ? $productAvailableQuantity : $needQuantity);
 
                            $applyItemsList[$providerName][$productId] = $reservedQuantity;
                        }
                    }
                    else
                    {
                        /** @var Sale\ShipmentItem $shipmentItem */
                        foreach ($shipmentItemCollection 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', array(
                                    '#PRODUCT_NAME#' => $basketItem->getField('NAME')
                                )), 'SALE_PROVIDER_RESERVE_SHIPMENT_ITEM_WRONG_AVAILABLE_QUANTITY') );
                                break;
                            }
                        }
                    }
                }
 
            }
 
            if (!empty($applyItemsList))
            {
                $shipmentProductIndex = static::createProductShipmentItemMapByShipmentItemCollection($shipmentItemCollection);
 
                /** @var Sale\Shipment $shipment */
                if (!$shipment = $shipmentItemCollection->getShipment())
                {
                    throw new Main\ObjectNotFoundException('Entity "ShipmentItemCollectionCollection" not found');
                }
 
                /** @var Sale\ShipmentCollection $shipmentCollection */
                if (!$shipmentCollection = $shipment->getCollection())
                {
                    throw new Main\ObjectNotFoundException('Entity "ShipmentCollection" not found');
                }
 
                /** @var Sale\Order $order */
                if (!$order = $shipmentCollection->getOrder())
                {
                    throw new Main\ObjectNotFoundException('Entity "Order" not found');
                }
 
                $pool = PoolQuantity::getInstance($order->getInternalId());
 
                static::setAvailableQuantityToShipmentItemCollection($pool, $shipmentProductIndex, $applyItemsList);
            }
        }
 
        return $result;
    }

tryReserveShipmentItem()

static tryReserveShipmentItem ( Sale\ShipmentItem  $shipmentItem, array  $context = array()  )

static

Аргументы

Sale\ShipmentItem	$shipmentItem
array	$context

Возвращает

Sale\Result

Исключения

Main

См. определение в файле sale/lib/internals/catalog/provider.php строка 489

    {
        $result = new Sale\Result();
 
        /** @var Sale\ShipmentItemCollection $shipmentItemCollection */
        $shipmentItemCollection = $shipmentItem->getCollection();
        if (!$shipmentItemCollection)
        {
            throw new Main\ObjectNotFoundException('Entity "ShipmentItemCollection" not found');
        }
 
        /** @var Sale\Shipment $shipment */
        $shipment = $shipmentItemCollection->getShipment();
        if (!$shipment)
        {
            throw new Main\ObjectNotFoundException('Entity "Shipment" not found');
        }
 
        /** @var Sale\ShipmentCollection $shipmentCollection */
        $shipmentCollection = $shipment->getCollection();
        if (!$shipmentCollection)
        {
            throw new Main\ObjectNotFoundException('Entity "ShipmentCollection" not found');
        }
 
        /** @var Sale\Order $order */
        $order = $shipmentCollection->getOrder();
        if (!$order)
        {
            throw new Main\ObjectNotFoundException('Entity "Order" not found');
        }
 
        $context = static::prepareContext($order, $context);
        $r = static::checkContext($context);
        if (!$r->isSuccess())
        {
            return $r;
        }
 
        $pool = PoolQuantity::getInstance($order->getInternalId());
 
        /** @var Sale\ShipmentItemCollection $shipmentCollection */
        $shipmentItemCollection = $shipment->getShipmentItemCollection();
 
        $availableQuantityList = [];
        $needQuantityList = [];
 
        $r = static::getNeedQuantityByShipmentItem($shipmentItem);
        if (!$r->isSuccess())
        {
            $result->addErrors($r->getErrors());
        }
        else
        {
            $data = $r->getData();
            if (!empty($data['NEED_QUANTITY_LIST']))
            {
                $needQuantityList = $data['NEED_QUANTITY_LIST'];
            }
        }
 
        $creator = Sale\Internals\ProviderCreator::create($context);
 
        $shipmentProductData = $creator->createItemForReserve($shipmentItem);
        $creator->addShipmentProductData($shipmentProductData);
 
        $r = $creator->getAvailableQuantity();
        if ($r->isSuccess())
        {
            $data = $r->getData();
            if (array_key_exists('AVAILABLE_QUANTITY_LIST', $data))
            {
                $availableQuantityList = $data['AVAILABLE_QUANTITY_LIST'];
            }
        }
        else
        {
            $result->addErrors($r->getErrors());
        }
 
        if ($r->hasWarnings())
        {
            $result->addWarnings($r->getWarnings());
        }
 
        if (!empty($needQuantityList) && $result->isSuccess())
        {
            $applyItemsList = [];
 
            foreach ($availableQuantityList as $providerName => $productAvailableQuantityList)
            {
                $providerName = trim($providerName);
                foreach ($productAvailableQuantityList as $productId => $productAvailableQuantity)
                {
                    if (array_key_exists($productId, $needQuantityList[$providerName]))
                    {
                        if (Sale\Configuration::getProductReservationCondition() != Sale\Configuration::RESERVE_ON_SHIP)
                        {
                            $poolQuantity = 0;
                            if ($order->getId() > 0)
                            {
                                $poolQuantity = (float)$pool->get(PoolQuantity::POOL_RESERVE_TYPE, $productId);
                            }
                            $needQuantity = $needQuantityList[$providerName][$productId];
 
                            $productAvailableQuantity -= $poolQuantity;
                            $reservedQuantity = ($needQuantity >= $productAvailableQuantity ? $productAvailableQuantity : $needQuantity);
 
                            $applyItemsList[$providerName][$productId] = $reservedQuantity;
                        }
                    }
                    else
                    {
                        /** @var Sale\ShipmentItem $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', array(
                                '#PRODUCT_NAME#' => $basketItem->getField('NAME')
                            )), 'SALE_PROVIDER_RESERVE_SHIPMENT_ITEM_WRONG_AVAILABLE_QUANTITY') );
                            break;
                        }
                    }
                }
 
            }
 
            if (!empty($applyItemsList))
            {
                $shipmentProductIndex = static::createProductShipmentItemMapByShipmentItem($shipmentItem);
 
                /** @var Sale\Shipment $shipment */
                if (!$shipment = $shipmentItemCollection->getShipment())
                {
                    throw new Main\ObjectNotFoundException('Entity "ShipmentItemCollectionCollection" not found');
                }
 
                /** @var Sale\ShipmentCollection $shipmentCollection */
                if (!$shipmentCollection = $shipment->getCollection())
                {
                    throw new Main\ObjectNotFoundException('Entity "ShipmentCollection" not found');
                }
 
                /** @var Sale\Order $order */
                if (!$order = $shipmentCollection->getOrder())
                {
                    throw new Main\ObjectNotFoundException('Entity "Order" not found');
                }
 
                $pool = PoolQuantity::getInstance($order->getInternalId());
                static::setAvailableQuantityToShipmentItemCollection($pool, $shipmentProductIndex, $applyItemsList);
            }
        }
 
        return $result;
    }

tryShipShipment()

static tryShipShipment ( Sale\Shipment  $shipment, array  $context = array()  )

static

Аргументы

Sale\Shipment	$shipment
array	$context

Возвращает

Sale\Result

Исключения

Main

См. определение в файле sale/lib/internals/catalog/provider.php строка 1060

    {
        $result = new Sale\Result();
 
        $context = static::prepareContextByShipment($shipment, $context);
 
        /** @var Sale\ShipmentCollection $shipmentCollection */
        $shipmentCollection = $shipment->getCollection();
        if (!$shipmentCollection)
        {
            throw new Main\ObjectNotFoundException('Entity "ShipmentCollection" not found');
        }
 
        $order = $shipmentCollection->getOrder();
        if (!$order)
        {
            throw new Main\ObjectNotFoundException('Entity "Order" not found');
        }
 
        $pool = PoolQuantity::getInstance($order->getInternalId());
 
        /** @var Sale\ShipmentItemCollection $shipmentCollection */
        $shipmentItemCollection = $shipment->getShipmentItemCollection();
 
        $needShipList = array();
        $creator = Sale\Internals\ProviderCreator::create($context);
        /** @var Sale\ShipmentItem $shipmentItem */
        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);
        /** @var Sale\ShipmentItem $shipmentItem */
        foreach ($shipmentItemCollection as $shipmentItem)
        {
            $shipmentProductData = $creator->createItemForShip($shipmentItem, $needShipList);
            $creator->addShipmentProductData($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 (static::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 $providerName => &$productList)
                {
                    $productList = array_fill_keys(array_keys($productList), true);
                }
            }
 
            $creator->setItemsResultAfterTryShip($pool, $tryShipProductList);
        }
 
        return $result;
    }

tryUnreserveShipment()

static tryUnreserveShipment ( Sale\Shipment  $shipment )

static

Аргументы

Sale\Shipment

$shipment

Возвращает

Sale\Result

Исключения

Main

См. определение в файле sale/lib/internals/catalog/provider.php строка 825

    {
        $result = new Sale\Result();
 
        /** @var Sale\ShipmentCollection $shipmentCollection */
        if (!$shipmentCollection = $shipment->getCollection())
        {
            throw new Main\ObjectNotFoundException('Entity "ShipmentCollection" not found');
        }
 
        /** @var Sale\Order $order */
        if (!$order = $shipmentCollection->getOrder())
        {
            throw new Main\ObjectNotFoundException('Entity "Order" not found');
        }
 
        $pool = PoolQuantity::getInstance($order->getInternalId());
 
        /** @var Sale\ShipmentItemCollection $shipmentCollection */
        $shipmentItemCollection = $shipment->getShipmentItemCollection();
 
        /** @var Sale\ShipmentItem $shipmentItem */
        foreach ($shipmentItemCollection as $shipmentItem)
        {
            /** @var Sale\BasketItem $basketItem */
            if (!$basketItem = $shipmentItem->getBasketItem())
            {
                continue;
            }
 
            $productId = $basketItem->getProductId();
 
            $reservedQuantity = $shipmentItem->getReservedQuantity();
 
            if ($reservedQuantity == 0)
                continue;
 
            $pool->add(Sale\Internals\PoolQuantity::POOL_RESERVE_TYPE, $productId, -1 * $reservedQuantity);
            if ($shipmentItem)
            {
                $foundItem = false;
                $poolItems = Sale\Internals\ItemsPool::get($order->getInternalId(), $productId);
                if (!empty($poolItems))
                {
                    /** @var Sale\Shipment $poolItem */
                    foreach ($poolItems as $poolItem)
                    {
                        if ($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;
    }

tryUnreserveShipmentItem()

static tryUnreserveShipmentItem ( Sale\ShipmentItem  $shipmentItem )

static

Аргументы

Sale\ShipmentItem

$shipmentItem

Возвращает

Sale\Result

Исключения

Main

См. определение в файле sale/lib/internals/catalog/provider.php строка 656

    {
        $result = new Sale\Result();
 
        /** @var Sale\ShipmentItemCollection $shipmentItemCollection */
        $shipmentItemCollection = $shipmentItem->getCollection();
        if (!$shipmentItemCollection)
        {
            throw new Main\ObjectNotFoundException('Entity "ShipmentItemCollection" not found');
        }
 
        /** @var Sale\Shipment $shipment */
        $shipment = $shipmentItemCollection->getShipment();
        if (!$shipment)
        {
            throw new Main\ObjectNotFoundException('Entity "Shipment" not found');
        }
 
        /** @var Sale\ShipmentCollection $shipmentCollection */
        $shipmentCollection = $shipment->getCollection();
        if (!$shipmentCollection)
        {
            throw new Main\ObjectNotFoundException('Entity "ShipmentCollection" not found');
        }
 
        /** @var Sale\Order $order */
        $order = $shipmentCollection->getOrder();
        if (!$order)
        {
            throw new Main\ObjectNotFoundException('Entity "Order" not found');
        }
 
        $pool = PoolQuantity::getInstance($order->getInternalId());
 
        /** @var Sale\BasketItem $basketItem */
        $basketItem = $shipmentItem->getBasketItem();
        if (!$basketItem)
        {
            throw new Main\ObjectNotFoundException('Entity "BasketItem" not found');
        }
 
        $productId = $basketItem->getProductId();
 
        $reservedQuantity = $shipmentItem->getReservedQuantity();
 
        if ($reservedQuantity == 0)
        {
            return $result;
        }
 
        $pool->add(Sale\Internals\PoolQuantity::POOL_RESERVE_TYPE, $productId, -1 * $reservedQuantity);
        if ($shipmentItem)
        {
            $foundItem = false;
            $poolItems = Sale\Internals\ItemsPool::get($order->getInternalId(), $productId);
            if (!empty($poolItems))
            {
                /** @var Sale\Shipment $poolItem */
                foreach ($poolItems as $poolItem)
                {
                    if ($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;
    }

Поля

SALE_TRANSFER_PROVIDER_SHIPMENT_NEED_EMPTY

const SALE_TRANSFER_PROVIDER_SHIPMENT_NEED_EMPTY = null

См. определение в файле sale/lib/internals/catalog/provider.php строка 22

SALE_TRANSFER_PROVIDER_SHIPMENT_NEED_NOT_SHIP

const SALE_TRANSFER_PROVIDER_SHIPMENT_NEED_NOT_SHIP = false

См. определение в файле sale/lib/internals/catalog/provider.php строка 21

SALE_TRANSFER_PROVIDER_SHIPMENT_NEED_SHIP

const SALE_TRANSFER_PROVIDER_SHIPMENT_NEED_SHIP = true

См. определение в файле sale/lib/internals/catalog/provider.php строка 20

---

Объявления и описания членов класса находятся в файле:

• sale/lib/internals/catalog/provider.php