shipmentitemstorecollection.php

<?php
 
 
namespace Bitrix\Sale;
 
use Bitrix\Main;
use Bitrix\Main\Localization\Loc;
 
Loc::loadMessages(__FILE__);
 
class ShipmentItemStoreCollection extends Internals\EntityCollection
{
    private $shipmentItem;
 
    protected function getEntityParent()
    {
        return $this->getShipmentItem();
    }
 
    private static function createShipmentItemStoreCollectionObject()
    {
        $registry = Registry::getInstance(static::getRegistryType());
        $shipmentItemStoreCollectionClassName = $registry->getShipmentItemStoreCollectionClassName();
 
        return new $shipmentItemStoreCollectionClassName();
    }
 
    public static function getRegistryType()
    {
        return Registry::REGISTRY_TYPE_ORDER;
    }
 
    public static function load(ShipmentItem $shipmentItem)
    {
        $shipmentItemStoreCollection = static::createShipmentItemStoreCollectionObject();
        $shipmentItemStoreCollection->shipmentItem = $shipmentItem;
 
        if ($shipmentItem->getId() > 0)
        {
            $registry = Registry::getInstance(static::getRegistryType());
 
            $itemClassName = $registry->getShipmentItemStoreClassName();
 
            $shipmentItemStoreList = $itemClassName::loadForShipmentItem($shipmentItem->getId());
 
            foreach ($shipmentItemStoreList as $shipmentItemStore)
            {
                $shipmentItemStore->setCollection($shipmentItemStoreCollection);
                $shipmentItemStoreCollection->addItem($shipmentItemStore);
            }
        }
 
        return $shipmentItemStoreCollection;
    }
 
    public function createItem(BasketItem $basketItem)
    {
        $registry = Registry::getInstance(static::getRegistryType());
 
        $itemClassName =  $registry->getShipmentItemStoreClassName();
 
        $item = $itemClassName::create($this, $basketItem);
 
        $this->addItem($item);
 
        return $item;
    }
 
    public function getQuantityByBasketCode($basketCode)
    {
        $quantity = 0;
 
        foreach ($this->collection as $item)
        {
            $quantity += $item->getQuantity();
        }
 
        return $quantity;
    }
 
 
    public function getShipmentItem()
    {
        return $this->shipmentItem;
    }
 
    public function onShipmentItemModify($action, ShipmentItem $shipmentItem, $name = null, $oldValue = null, $value = null)
    {
        if ($action !== EventActions::UPDATE)
        {
            return new Result();
        }
 
        if ($name == "QUANTITY")
        {
            return $this->syncQuantityAfterModify($shipmentItem, $oldValue, $value);
        }
 
        return new Result();
    }
 
    protected function syncQuantityAfterModify(ShipmentItem $shipmentItem, $oldValue = null, $value = null)
    {
        if (!($basketItem = $shipmentItem->getBasketItem()) || $basketItem->getId() == 0)
            return new Result();
 
        $result = new Result();
 
        $deltaQuantity = $value - $oldValue;
 
        if ($deltaQuantity >= 0)
            return $result;
 
        $barcodeList = array();
        foreach($this->collection as $shipmentItemStore)
        {
            if (strval($shipmentItemStore->getBarcode()) == "")
            {
                $barcodeList[$shipmentItemStore->getId()] = $shipmentItemStore;
            }
        }
 
        if ($basketItem->isBarcodeMulti())
        {
            if (count($barcodeList) < $oldValue)
            {
                return $result;
            }
 
            $oldItemsList = array();
 
            foreach ($this->collection as $shipmentItemStore)
            {
                $oldItemsList[$shipmentItemStore->getId()] = $shipmentItemStore;
            }
 
            $cutBarcodeList = array_slice($barcodeList, 0, $deltaQuantity, true);
            if (!empty($oldItemsList) && is_array($oldItemsList))
            {
                foreach($oldItemsList as $oldItemId => $oldItem)
                {
                    if (!isset($cutBarcodeList[$oldItemId]))
                    {
                        $oldItem->delete();
                    }
                }
            }
        }
        elseif (count($barcodeList) == 1)
        {
            $barcodeItem = reset($barcodeList);
 
            if ($barcodeItem->getQuantity() < $oldValue)
                return new Result();
 
            $r = $barcodeItem->setField(
                    "QUANTITY",
                    $barcodeItem->getField("QUANTITY") + $deltaQuantity
            );
 
            if (!$r->isSuccess())
            {
                $result->addErrors($r->getErrors());
                return $result;
            }
        }
 
        return $result;
    }
 
    public function onItemModify(Internals\CollectableEntity $item, $name = null, $oldValue = null, $value = null)
    {
        $result = new Result();
 
        if ($name == "QUANTITY")
        {
            $r = $this->checkAvailableQuantity($item);
            if (!$r->isSuccess())
            {
                return $result->addErrors($r->getErrors());
            }
        }
 
        return new Result();
    }
 
    public function checkAvailableQuantity(Internals\CollectableEntity $item)
    {
        $result = new Result();
 
        if (!$item instanceof ShipmentItemStore)
        {
            return $result;
        }
 
        $shipmentItem = $this->getShipmentItem();
 
        $itemStoreQuantity = (float)$this->getQuantityByBasketCode($shipmentItem->getBasketCode());
 
        if (
            (float)$item->getQuantity() > $shipmentItem->getQuantity()
            ||
            $itemStoreQuantity > $shipmentItem->getQuantity()
        )
        {
            $result->addError(new Main\Error(
                    Loc::getMessage(
                        'SALE_SHIPMENT_ITEM_STORE_QUANTITY_LARGER_ALLOWED',
                        ['#PRODUCT_NAME#' => $this->getShipmentItem()->getBasketItem()->getField('NAME')]
                    ),
                    'SALE_SHIPMENT_ITEM_STORE_QUANTITY_LARGER_ALLOWED'
                )
            );
        }
 
        return $result;
    }
 
    public function save()
    {
        $result = new Main\Entity\Result();
 
        $originalItemValues = $this->getOriginalItemValues();
 
        foreach ($this->collection as $item)
        {
            $r = $item->save();
            if (!$r->isSuccess())
            {
                $result->addErrors($r->getErrors());
            }
 
            if (isset($originalItemValues[$item->getId()]))
            {
                unset($originalItemValues[$item->getId()]);
            }
        }
 
        if ($originalItemValues)
        {
            foreach ($originalItemValues as $id => $itemValues)
            {
                $this->callEventOnBeforeSaleShipmentItemStoreDeleted($itemValues);
 
                $this->deleteInternal($id);
 
                $this->callEventOnSaleShipmentItemStoreDeleted($itemValues);
            }
        }
 
        return $result;
    }
 
    protected function getOriginalItemValues() : array
    {
        $itemsFromDb = array();
 
        if ($this->getShipmentItem()->getId() > 0)
        {
            $itemsFromDbList = static::getList(
                array(
                    "filter" => array("ORDER_DELIVERY_BASKET_ID" => $this->getShipmentItem()->getId()),
                )
            );
            while ($itemsFromDbItem = $itemsFromDbList->fetch())
            {
                $itemsFromDb[$itemsFromDbItem["ID"]] = $itemsFromDbItem;
            }
        }
 
        return $itemsFromDb;
    }
 
    protected function callEventOnBeforeSaleShipmentItemStoreDeleted(array $itemValues)
    {
        $itemValues['ENTITY_REGISTRY_TYPE'] = static::getRegistryType();
 
        $event = new Main\Event('sale', "OnBeforeSaleShipmentItemStoreDeleted", ['VALUES' => $itemValues]);
        $event->send();
    }
 
    protected function callEventOnSaleShipmentItemStoreDeleted(array $itemValues)
    {
        $itemValues['ENTITY_REGISTRY_TYPE'] = static::getRegistryType();
 
        $event = new Main\Event('sale', "OnSaleShipmentItemStoreDeleted", ['VALUES' => $itemValues]);
        $event->send();
    }
 
    public function setBarcodeQuantityFromArray(array $values)
    {
        $result = new Result();
        $requestBarcodeList = static::getBarcodeListFromArray($values);
 
        $plusList = array();
        $oldQuantityList = $this->getAllBarcodeList();
 
        foreach ($requestBarcodeList as $storeId => $barcodeDat)
        {
            foreach ($barcodeDat as $barcodeValue => $barcode)
            {
                if (isset($oldQuantityList[$storeId][$barcodeValue])
                    && $oldQuantityList[$storeId][$barcodeValue]['ID'] == $barcode['ID'])
                {
                    $oldBarcode = $oldQuantityList[$storeId][$barcodeValue];
                    if ($barcode['QUANTITY'] == $oldBarcode['QUANTITY'])
                    {
                        continue;
                    }
                    elseif ($barcode['QUANTITY'] < $oldBarcode['QUANTITY'])
                    {
                        $item = $this->getItemById($oldBarcode['ID']);
                        if ($item)
                            $item->setField('QUANTITY', $barcode['QUANTITY']);
                    }
                    else
                    {
                        $plusList[$barcodeValue] = array(
                            'ID' => $barcode['ID'],
                            'QUANTITY' => $barcode['QUANTITY']
                        );
                    }
                }
            }
        }
 
        foreach ($plusList as $barcode)
        {
            if ($barcode['ID'] <= 0)
                continue;
 
            $item = $this->getItemById($barcode['ID']);
            if ($item)
            {
                $r = $item->setField('QUANTITY', $barcode['QUANTITY']);
                if (!$r->isSuccess())
                {
                    $result->addErrors($r->getErrors());
                }
            }
        }
 
        return $result;
    }
 
 
    private function getBarcodeListFromArray(array $values)
    {
        $result = array();
 
        foreach ($values['BARCODE_INFO'] as $barcodeDat)
        {
            $storeId = $barcodeDat['STORE_ID'];
 
            if (!isset($barcodeDat['BARCODE']) || !is_array($barcodeDat['BARCODE']))
                continue;
 
            if (count($barcodeDat['BARCODE']) > 1)
            {
                $quantity = floatval($barcodeDat['QUANTITY'] / count($barcodeDat['BARCODE']));
            }
            else
            {
                $quantity = floatval($barcodeDat['QUANTITY']);
            }
 
            foreach ($barcodeDat['BARCODE'] as $barcode)
            {
                if (!isset($result[$storeId]))
                    $result[$storeId] = array();
 
                $result[$storeId][$barcode['VALUE']] = array(
                    "QUANTITY" => $quantity,
                );
 
                if (isset($barcode['ID']) && intval($barcode['ID']) > 0)
                {
                    $result[$storeId][$barcode['VALUE']]['ID'] = intval($barcode['ID']);
                }
            }
        }
 
        return $result;
    }
 
    public function getAllBarcodeList()
    {
        $result = [];
 
        foreach ($this->collection as $item)
        {
            if (!isset($result[$item->getStoreId()]))
            {
                $result[$item->getStoreId()] = [];
            }
 
            $result[$item->getStoreId()][$item->getBarcode()] = [
                'ID' => $item->getId(),
                'QUANTITY' => $item->getQuantity(),
            ];
        }
 
        return $result;
    }
 
    public function getItemByBarcode($barcode)
    {
        foreach ($this->collection as $item)
        {
            if ((string)$item->getBarcode() === (string)$barcode)
            {
                return $item;
            }
        }
 
        return null;
    }
 
    public function getItemsByStoreId(int $storeId) : Internals\CollectionFilterIterator
    {
        $callback = function (ShipmentItemStore $itemStore) use ($storeId)
        {
            return $itemStore->getStoreId() === $storeId;
        };
 
        return new Internals\CollectionFilterIterator($this->getIterator(), $callback);
    }
 
    public function createClone(\SplObjectStorage $cloneEntity)
    {
        if ($this->isClone() && $cloneEntity->contains($this))
        {
            return $cloneEntity[$this];
        }
 
        $shipmentItemStoreCollectionClone = parent::createClone($cloneEntity) ;
 
        if ($shipmentItem = $this->shipmentItem)
        {
            if (!$cloneEntity->contains($shipmentItem))
            {
                $cloneEntity[$shipmentItem] = $shipmentItem->createClone($cloneEntity);
            }
 
            if ($cloneEntity->contains($shipmentItem))
            {
                $shipmentItemStoreCollectionClone->shipmentItem = $cloneEntity[$shipmentItem];
            }
        }
 
        return $shipmentItemStoreCollectionClone;
    }
 
    public function getErrorEntity($value)
    {
        $className = null;
 
        foreach ($this->collection as $shipmentItemStore)
        {
            if ($className = $shipmentItemStore->getErrorEntity($value))
            {
                break;
            }
        }
 
        return $className;
    }
 
    public function canAutoFixError($value)
    {
        $autoFix = false;
        foreach ($this->collection as $shipmentItemStore)
        {
            if ($autoFix = $shipmentItemStore->canAutoFixError($value))
            {
                break;
            }
        }
        return $autoFix;
    }
 
    public static function getList(array $parameters = array())
    {
        return Internals\ShipmentItemStoreTable::getList($parameters);
    }
 
    protected function deleteInternal($primary)
    {
        return Internals\ShipmentItemStoreTable::delete($primary);
    }
}