providercreator.php

<?php
 
namespace Bitrix\Sale\Internals;
 
use Bitrix\Main;
use Bitrix\Sale;
use Bitrix\Catalog;
 
class ProviderCreator
{
    private $context = array();
    private $pool = array();
 
    public static function create(array $context)
    {
        $creator = new static();
        $creator->context = $context;
 
        return $creator;
    }
 
    public function addBasketItem(Sale\BasketItemBase $basketItem)
    {
        $providerName = $basketItem->getProviderName();
        if (empty($providerName))
        {
            $providerName = $basketItem->getCallbackFunction();
        }
        $builder = $this->createBuilder($providerName);
        $builder->addProductByBasketItem($basketItem);
    }
 
    public function addShipmentItem(Sale\ShipmentItem $shipmentItem)
    {
        $basketItem = $shipmentItem->getBasketItem();
        if (!$basketItem)
        {
            return;
        }
 
        $providerName = $basketItem->getProviderName();
        if (empty($providerName))
        {
            $providerName = $basketItem->getCallbackFunction();
        }
        $builder = $this->createBuilder($providerName);
 
        $builder->addProductByShipmentItem($shipmentItem);
    }
 
    public function addProductData(array $productData)
    {
        $builder = $this->createBuilder($productData['PROVIDER_NAME']);
        $builder->addProductData($productData);
    }
 
    public function addBasketItemBarcodeData(Sale\BasketItem $basketItem, array $barcodeParams)
    {
        $providerName = $basketItem->getProviderName();
        if (empty($providerName))
        {
            $providerName = $basketItem->getCallbackFunction();
        }
        $builder = $this->createBuilder($providerName);
        $builder->addBasketItemBarcodeData($barcodeParams);
    }
    public function createItemForShip(Sale\ShipmentItem $shipmentItem, array $needShipList = [])
    {
        $basketItem = $shipmentItem->getBasketItem();
 
        $shipment = $shipmentItem->getCollection()->getShipment();
 
        $quantity = $shipmentItem->getQuantity();
 
        if ($shipment->needShip() == Sale\Internals\Catalog\Provider::SALE_TRANSFER_PROVIDER_SHIPMENT_NEED_SHIP)
        {
            if ($quantity > 0)
            {
                $quantity *= -1;
            }
        }
 
        $needUseReserve = $quantity < 0 || Sale\Configuration::isEnableAutomaticReservation();
 
        $providerName = $basketItem->getProviderName();
        $providerName = $this->clearProviderName($providerName);
        if (empty($needShipList[$providerName]) && $shipmentItem->getReservedQuantity() > 0)
        {
            $quantity = 0;
        }
 
        $item = [
            'PROVIDER_NAME' => $basketItem->getProviderName(),
            'SHIPMENT_ITEM' => $shipmentItem,
            'BASKET_ITEM' => $basketItem,
            'QUANTITY' =>  $quantity,
            'RESERVED_QUANTITY_BY_STORE' => [
                $shipmentItem->getInternalIndex() => []
            ],
        ];
 
        $storeData = Sale\Internals\Catalog\Provider::createMapShipmentItemStoreData($shipmentItem, $needUseReserve);
        if ($storeData)
        {
            $item['STORE_DATA'] = $storeData;
 
            $needReserveByStore = [];
            foreach ($storeData as $data)
            {
                $item['RESERVED_QUANTITY_BY_STORE'][$shipmentItem->getInternalIndex()][$data['STORE_ID']] = $data['RESERVED_QUANTITY'];
 
                $needReserveByStore[$data['STORE_ID']] = $data['RESERVED_QUANTITY'] > 0;
            }
 
            $item['RESERVED_QUANTITY'] = array_sum($item['RESERVED_QUANTITY_BY_STORE'][$shipmentItem->getInternalIndex()]);
            $item['NEED_RESERVE'] = $item['RESERVED_QUANTITY'] > 0;
            $item['NEED_RESERVE_BY_STORE'] = [
                $shipmentItem->getInternalIndex() => $needReserveByStore
            ];
        }
        else
        {
            $item['RESERVED_QUANTITY'] = $needUseReserve ? $basketItem->getReservedQuantity() : 0;
            $item['NEED_RESERVE'] = $item['RESERVED_QUANTITY'] > 0;
        }
 
        return $item;
    }
 
    public function createItemForReserveByShipmentItem(Sale\ShipmentItem $shipmentItem) : array
    {
        $basketItem = $shipmentItem->getBasketItem();
 
        $result = [
            'PROVIDER_NAME' => $basketItem->getProviderName(),
            'BASKET_ITEM' => $basketItem,
            'SHIPMENT_ITEM' => $shipmentItem,
            'QUANTITY' => 0,
            'RESERVED_QUANTITY' => 0,
        ];
 
        if (!$basketItem->isReservableItem())
        {
            return $result;
        }
 
        $shipmentItemQuantity = $shipmentItem->getQuantity();
        if ($shipmentItemQuantity == 0)
        {
            $storeId = Sale\Configuration::getDefaultStoreId();
 
            $result['QUANTITY_BY_STORE'][$storeId] = $shipmentItemQuantity - $shipmentItem->getReservedQuantity();
            $result['QUANTITY'] += $result['QUANTITY_BY_STORE'][$storeId];
 
            $result['RESERVED_QUANTITY_BY_STORE'][$storeId] = $shipmentItem->getReservedQuantity();
            $result['RESERVED_QUANTITY'] += $result['RESERVED_QUANTITY_BY_STORE'][$storeId];
        }
        else
        {
            $quantityStoreList = [];
 
            $shipmentItemStoreCollection = $shipmentItem->getShipmentItemStoreCollection();
            if ($shipmentItemStoreCollection)
            {
                foreach ($shipmentItemStoreCollection as $itemStore)
                {
                    $storeId = $itemStore->getStoreId();
                    if (!isset($quantityStoreList[$storeId]))
                    {
                        $quantityStoreList[$storeId] = 0;
                    }
 
                    $quantityStoreList[$storeId] += $itemStore->getQuantity();
                    $shipmentItemQuantity -= $itemStore->getQuantity();
                }
            }
 
            if ($shipmentItemQuantity > 0)
            {
                $storeId = Sale\Configuration::getDefaultStoreId();
                if (!isset($quantityStoreList[$storeId]))
                {
                    $quantityStoreList[$storeId] = 0;
                }
 
                $quantityStoreList[$storeId] += $shipmentItemQuantity;
            }
 
            $result['QUANTITY_BY_STORE'] = [];
            $result['RESERVED_QUANTITY_BY_STORE'] = [];
 
            $shipmentItemReservedQuantity = $shipmentItem->getReservedQuantity();
            foreach ($quantityStoreList as $storeId => $quantity)
            {
                $reserveQuantity = 0;
 
                $reserveQuantityCollection = $basketItem->getReserveQuantityCollection();
 
                if ($reserveQuantityCollection && $shipmentItemReservedQuantity > 0)
                {
                    $reserveQuantity = $reserveQuantityCollection->getQuantityByStoreId($storeId);
                    if ($reserveQuantity > $shipmentItemReservedQuantity)
                    {
                        $reserveQuantity = $shipmentItemReservedQuantity;
                    }
 
                    $shipmentItemReservedQuantity -= $reserveQuantity;
                }
 
                $result['QUANTITY_BY_STORE'][$storeId] = $quantity - $reserveQuantity;
                $result['QUANTITY'] += $result['QUANTITY_BY_STORE'][$storeId];
 
                $result['RESERVED_QUANTITY_BY_STORE'][$storeId] = $reserveQuantity;
                $result['RESERVED_QUANTITY'] += $result['RESERVED_QUANTITY_BY_STORE'][$storeId];
            }
        }
 
        return $result;
    }
 
    public function createItemForReserve(Sale\ReserveQuantity $reserve)
    {
        $basketItem = $reserve->getCollection()->getBasketItem();
 
        $originalFields = $reserve->getFields()->getOriginalValues();
        $reservedQuantity = $originalFields['QUANTITY'] ?? 0;
        $quantity = $reserve->getField('QUANTITY') - $reservedQuantity;
 
        return [
            'PROVIDER_NAME' => $basketItem->getProviderName(),
            'RESERVE_ITEM' => $reserve,
            'BASKET_ITEM' => $basketItem,
            'QUANTITY' => $quantity,
            'QUANTITY_BY_STORE' => [
                $reserve->getStoreId() => $quantity
            ],
            'RESERVED_QUANTITY' => $reservedQuantity,
            'RESERVED_QUANTITY_BY_STORE' => [
                $reserve->getStoreId() => $reservedQuantity
            ]
        ];
    }
 
    public function getProductData()
    {
        return $this->callBuilderMethod('getProductData', ['PRODUCT_DATA_LIST']);
    }
 
    public function getAvailableQuantity()
    {
        return $this->callBuilderMethod('getAvailableQuantity', ['AVAILABLE_QUANTITY_LIST']);
    }
 
    public function getAvailableQuantityByStore()
    {
        return $this->callBuilderMethod('getAvailableQuantityByStore', ['AVAILABLE_QUANTITY_LIST_BY_STORE']);
    }
 
    public function getAvailableQuantityAndPrice()
    {
        return $this->callBuilderMethod('getAvailableQuantityAndPrice', ['PRODUCT_DATA_LIST']);
    }
 
    public function setItemsResultAfterTryShip(PoolQuantity $pool, array $productTryShipList)
    {
        $result = new Sale\Result();
 
        foreach ($this->pool as $builder)
        {
            $providerName = $builder->getProviderName();
 
            if (!$productTryShipList[$providerName])
            {
                continue;
            }
 
            $r = $builder->setItemsResultAfterTryShip($pool, $productTryShipList[$providerName]);
            if (!$r->isSuccess())
            {
                $result->addErrors($r->getErrors());
            }
        }
 
        return $result;
    }
 
    public function setItemsResultAfterShip(Sale\Result $resultAfterShip)
    {
        return $this->callBuilderMethod('setItemsResultAfterShip', ['RESULT_AFTER_SHIP_LIST'], $resultAfterShip);
    }
 
    public function createItemsResultAfterDeliver(Sale\Result $resultAfterDeliver)
    {
        return $this->callBuilderMethod('createItemsResultAfterDeliver', ['RESULT_AFTER_DELIVER_LIST'], $resultAfterDeliver);
    }
 
 
    public function tryShip()
    {
        return $this->callBuilderMethod('tryShip', ['TRY_SHIP_PRODUCTS_LIST']);
    }
 
    public function isNeedShip()
    {
        return $this->callBuilderMethod('isNeedShip', ['IS_NEED_SHIP']);
    }
 
 
    public function checkBarcode()
    {
        return $this->callBuilderMethod('checkBarcode', ['BARCODE_CHECK_LIST']);
    }
 
    public function reserve()
    {
        return $this->callBuilderMethod('reserve', ['RESERVED_PRODUCTS_LIST']);
    }
 
    public function ship()
    {
        return $this->callBuilderMethod('ship', ['SHIPPED_PRODUCTS_LIST']);
    }
 
    public function getBundleItems()
    {
        return $this->callBuilderMethod('getBundleItems', ['BUNDLE_LIST']);
    }
 
    public function deliver()
    {
        return $this->callBuilderMethod('deliver', ['DELIVER_PRODUCTS_LIST']);
    }
 
    public function viewProduct()
    {
        return $this->callBuilderMethod('viewProduct', ['VIEW_PRODUCTS_LIST']);
    }
 
    public function getProductStores()
    {
        return $this->callBuilderMethod('getProductStores', ['PRODUCT_STORES_LIST']);
    }
 
    public function recurring()
    {
        return $this->callBuilderMethod('recurring', ['RECURRING_PRODUCTS_LIST']);
    }
 
    public function createItemsResultAfterRecurring(Sale\Result $resultAfterDeliver)
    {
        return $this->callBuilderMethod('createItemsResultAfterDeliver', ['RESULT_AFTER_DELIVER_LIST'], $resultAfterDeliver);
    }
 
    public function returnProductBatches(): Sale\Result
    {
        return $this->callBuilderMethod('returnProductBatches', []);
    }
 
    public function writeOffProductBatches(): Sale\Result
    {
        return $this->callBuilderMethod('writeOffProductBatches', []);
    }
 
    private function callBuilderMethod($method, array $outputNames, $methodParameters = null)
    {
        $result = new Sale\Result();
 
        $resultList = array();
 
        foreach ($this->pool as $builder)
        {
            if (!method_exists($builder, $method))
            {
                throw new Main\ArgumentOutOfRangeException('method');
            }
 
            if (!$methodParameters)
            {
                $compatibilityOutputName = $outputNames[0];
                $r = $builder->$method($compatibilityOutputName);
            }
            else
            {
                $r = $builder->$method($methodParameters);
            }
 
            if (!$r->isSuccess())
            {
                $result->addErrors($r->getErrors());
            }
 
            if ($r->hasWarnings())
            {
                $result->addWarnings($r->getWarnings());
            }
 
            $data = $r->getData();
            if (!empty($data))
            {
                $providerName = null;
 
                $providerClass = $builder->getProviderClass();
                if ($providerClass)
                {
                    $reflect = new \ReflectionClass($providerClass);
                    $providerName = $this->clearProviderName($reflect->getName());
                }
 
                if (empty($providerName))
                {
                    $providerName = $builder->getCallbackFunction();
                }
 
                foreach ($outputNames as $outputName)
                {
                    if (!empty($data[$outputName]))
                    {
                        $resultList[$outputName] = [
                            $providerName => $data[$outputName],
                        ];
                    }
                }
            }
        }
 
        if (!empty($resultList))
        {
            $result->setData($resultList);
        }
 
        return $result;
    }
 
    private function createBuilder($providerName)
    {
        if (!$this->isExistsProvider($providerName))
        {
            $providerClass = null;
 
            if (!empty($providerName) && class_exists($providerName))
            {
                $providerClass = new $providerName($this->getContext());
            }
 
            if (!$providerClass)
            {
                $providerClass = $providerName;
            }
 
            $builder = ProviderBuilderBase::createBuilder($providerClass, $this->getContext());
 
            $this->addBuilder($providerName, $builder);
        }
        else
        {
            $builder = $this->getBuilder($providerName);
        }
 
        return $builder;
    }
 
    private function addBuilder($providerName, ProviderBuilderBase $builder)
    {
        $providerName = $this->clearProviderName($providerName);
 
        $this->pool[$providerName] = $builder;
    }
 
    private function getBuilder($providerName)
    {
        $providerName = $this->clearProviderName($providerName);
 
        if ($this->isExistsProvider($providerName))
        {
            return $this->pool[$providerName];
        }
 
        return false;
    }
    private function isExistsProvider($providerName)
    {
        $providerName = $this->clearProviderName($providerName);
        return (isset($this->pool[$providerName]));
    }
 
    private function getContext()
    {
        return $this->context;
    }
 
    private function clearProviderName($providerName)
    {
        if (!empty($providerName) && $providerName[0] == "\\")
        {
            $providerName = ltrim($providerName, '\\');
        }
 
        return $providerName;
    }
}