basketcompatibility.php

См. документацию.

<?php
 
 
namespace Bitrix\Sale\Compatible;
 
use Bitrix\Main;
use Bitrix\Sale;
use Bitrix\Sale\Compatible\Internals;
use Bitrix\Sale\Internals\BasketTable;
 
Main\Localization\Loc::loadMessages(__FILE__);
 
class BasketCompatibility extends Internals\EntityCompatibility
{
 
    private static $proxyBasket = array();

    protected $orderCompatibility = null;

    protected static function getRegistryType()
    {
        return Sale\Registry::REGISTRY_TYPE_ORDER;
    }

    protected static function getEntity()
    {
        return BasketTable::getEntity();
    }

    protected static function getOrderCompatibilityClassName()
    {
        return OrderCompatibility::class;
    }

    protected function __construct(array $fields = array())
    {
        $this->query = new OrderQuery(static::getEntity());
        $this->fields = new Sale\Internals\Fields($fields);
    }

    public static function create(OrderCompatibility $orderCompatibility)
    {
        $basketCompatibility = new static();
 
        $basketCompatibility->orderCompatibility = $orderCompatibility;
 
        return $basketCompatibility;
    }

    public function fillBasket(Sale\Basket $basket, array $requestFields)
    {
        $orderCompatibility = $this->getOrderCompatibility();

        $order = $orderCompatibility->getOrder();
 
        $result = new Sale\Result();
 
        if (empty($requestFields['BASKET_ITEMS']))
            return $result;
 
        $isStartField = $order->isStartField();
 
        $basketCodeList = array();
 
        $r = $this->parseBasketItems($basket, $requestFields['BASKET_ITEMS']);
        if (!$r->isSuccess())
        {
            $result->addErrors($r->getErrors());
            return $result;
        }
 
        $resultData = $r->getData();
 
        if (isset($resultData['BASKET']))
        {
            $basket = $resultData['BASKET'];
        }
 
        if (isset($resultData['BASKET_CODE_LIST']))
        {
            $basketCodeList = $resultData['BASKET_CODE_LIST'];
        }
 
        if (isset($resultData['BASKET_CHANGED']) && $resultData['BASKET_CHANGED'] === true)
        {
            $order->refreshVat();
        }
 
        if (!empty($basketCodeList) && is_array($basketCodeList))
        {
            foreach ($basketCodeList as $index => $basketCode)
            {
                DiscountCompatibility::setBasketCode($index, $basketCode);
            }
        }
 
        if ($isStartField)
        {
            $r = $order->doFinalAction(true);
            if (!$r->isSuccess())
            {
                $result->addErrors($r->getErrors());
            }
            else
            {
                if (($data = $r->getData())
                    && !empty($data) && is_array($data))
                {
                    $result->setData($result->getData() + $data);
                }
            }
        }
 
        return $result;
    }

    protected function parseBasketItems(Sale\Basket $basket, array $requestBasketItems)
    {
        $result = new Sale\Result();
 
        $basketCodeList = array();
        $basketItemList = array();
        $basketParentList = array();
        $basketChildList = array();
 
        $basketChanged = false;
 
        $registry = Sale\Registry::getInstance(static::getRegistryType());
        $basketItemEntity = $registry->getBasketItemClassName();
 
        $publicMode = DiscountCompatibility::usedByClient();
        foreach ($requestBasketItems as $basketIndex => $basketItemData)
        {
            if (isset($basketItemData['SET_PARENT_ID']) && strval($basketItemData['SET_PARENT_ID']) != '')
            {
                $parentId = intval($basketItemData['SET_PARENT_ID']);
                if ($basketItemData['TYPE'] != $basketItemEntity::TYPE_SET && !array_key_exists($parentId, $basketParentList))
                {
                    $basketChildList[intval($basketItemData['SET_PARENT_ID'])] = $basketItemData['SET_PARENT_ID'];
                }
            }
        }
 
        $orderCompatibility = $this->getOrderCompatibility();

        $order = $orderCompatibility->getOrder();
        $basketItemsIndexList = array();
 
        foreach ($basket as $basketItem)
        {
            $basketItemsIndexList[$basketItem->getId()] = true;
        }
 
        $sort = 100;
        foreach ($requestBasketItems as $basketIndex => $basketItemData)
        {
            if (!isset($basketItemData['BASE_PRICE']) && isset($basketItemData['PRICE']))
            {
                $basketItemData['BASE_PRICE'] = $basketItemData['PRICE'];
            }
 
            $basketItem = null;
            if (isset($basketItemData['ID']) && intval($basketItemData['ID']) > 0)
            {
                if ($basketItem = $basket->getItemById($basketItemData['ID']))
                {
                    if (isset($basketItemsIndexList[$basketItem->getId()]))
                        unset($basketItemsIndexList[$basketItem->getId()]);
                }
            }
 
 
            if (!$basketItem)
            {
                $basketItem = $basketItemEntity::create($basket, $basketItemData['MODULE'], $basketItemData['PRODUCT_ID']);
                $basketChanged = true;
            }
 
            $itemDuplicate = (isset($basketItemData['DUPLICATE']) && $basketItemData['DUPLICATE'] == "Y");
 
            $basketItemData['SORT'] = $sort;
            $sort += 100;
 
            $basketFields = static::clearFields($basketItemData);
 
            if ($order->getId() > 0)
            {
                if ($shipmentCollection = $order->getShipmentCollection())
                {
                    if (count($shipmentCollection) == 2
                        && (isset($basketItemData['QUANTITY']) && floatval($basketItemData['QUANTITY']) <= $basketItem->getQuantity()))
                    {

                        foreach ($shipmentCollection as $shipment)
                        {
                            if ($shipment->isSystem())
                                continue;
 
 
                            $basketQuantity = $shipment->getBasketItemQuantity($basketItem);
                            if ($basketQuantity <= floatval($basketItemData['QUANTITY']))
                                continue;
 

                            if ($shipmentItemCollection = $shipment->getShipmentItemCollection())
                            {
                                if (!$shipmentItem = $shipmentItemCollection->getItemByBasketCode($basketItem->getBasketCode()))
                                    continue;
 
                                $shipmentItem->setQuantity(floatval($basketItemData['QUANTITY']));
                            }
                        }
                    }
                }
            }
 
 
            $isBasketItemCanBeAdded = true;
            if ($publicMode)
            {
                if (\CSaleBasketHelper::isSetParent($basketItemData))
                {
                    $parentId = (int)$basketItemData['ID'];
                    $parentCode = $basketItemData['ID'];
                }
                else
                {
                    $parentId = (int)$basketItemData['SET_PARENT_ID'];
                    $parentCode = $basketItemData['SET_PARENT_ID'];
                }
            }
            else
            {
                $parentId = (int)$basketItemData['SET_PARENT_ID'];
                $parentCode = $basketItemData['SET_PARENT_ID'];
            }
 
            if ($parentId > 0)
            {
                if ($basketItem->isBundleParent())
                {
                    $basketParentList[$parentCode] = $basketItem->getBasketCode();
                }
                else
                {
                    $isBasketItemCanBeAdded = false;
                    $basketItemList[$parentCode][$basketIndex] = $basketItem;
                }
            }
 
            if ($isBasketItemCanBeAdded)
            {
                $propList = array();
                if ($propertyCollection = $basketItem->getPropertyCollection())
                {
                    $propList = $propertyCollection->getPropertyValues();
                }

                $foundedBasketItem = null;
 
                if ($basketItem->getId() > 0 && ($foundedBasketItem = $basket->getItemById($basketItem->getId())))
                {
                    $basketCodeList[($publicMode ? $foundedBasketItem->getId() : $basketIndex)] = $foundedBasketItem->getBasketCode();
                }
                else
                {
                    if (!$itemDuplicate && ($foundedBasketItem = $basket->getExistsItem($basketItem->getField('MODULE'), $basketItem->getProductId(), $propList)))
                    {
                        $basketCodeList[($publicMode ? $foundedBasketItem->getId() : $basketIndex)] = $foundedBasketItem->getBasketCode();
                    }
                }
 
                if ($foundedBasketItem === null)
                {
                    $basket->addItem($basketItem);
                    $basketCodeList[($publicMode ? $basketItem->getId() : $basketIndex)] = $basketItem->getBasketCode();
 
                    $basketChanged = true;
                }
            }
 

            $r = $basketItem->setFields($basketFields);
            if ($r->isSuccess())
            {
                if (array_key_exists('PROPS', $basketItemData) && is_array($basketItemData))
                {
                    if ($propertyCollection = $basketItem->getPropertyCollection())
                    {
                        $propertyCollection->setProperty($basketItemData['PROPS']);
                    }
                }
            }
            else
            {
                $result->addErrors($r->getErrors());
            }
 
        }
 
        if (!empty($basketChildList))
        {
            foreach($basketItemList as $parentBasketCode => $childBasketItemList)
            {
                $parentCode = null;
                if (!empty($basketParentList[$parentBasketCode]))
                    $parentCode = $basketParentList[$parentBasketCode];
 
                if (strval($parentCode) == '')
                    continue;

                if (!$parentBasketItem = $basket->getItemByBasketCode($parentCode))
                {
                    throw new Main\ObjectNotFoundException('Entity parent "BasketItem" not found');
                }
 
                if (!empty($childBasketItemList) && is_array($childBasketItemList))
                {
                    foreach ($childBasketItemList as $indexChildBasketItem => $childBasketItem)
                    {
                        $basketCodeIndex = ($publicMode ? $childBasketItem->getId() : $indexChildBasketItem);
                        $childBasketCode = $childBasketItem->getBasketCode();
 
                        $propList = array();
                        if ($propertyCollection = $childBasketItem->getPropertyCollection())
                        {
                            $propList = $propertyCollection->getPropertyValues();
                        }
 
                        $bundleCollection = $parentBasketItem->getBundleCollection();
                        if ($foundedBasketItem = $bundleCollection->getExistsItem($childBasketItem->getField('MODULE'), $childBasketItem->getProductId(), $propList))
                        {
                            $childBasketCode = $foundedBasketItem->getBasketCode();
                            unset($childBasketItemList[$indexChildBasketItem]);
                            $basketCodeIndex = ($publicMode ? $foundedBasketItem->getId() : $indexChildBasketItem);
                        }
 
                        if (strval($childBasketCode) != '')
                            $basketCodeList[$basketCodeIndex] = $childBasketCode;
                    }
 
                    if (!empty($childBasketItemList))
                    {
                        $this->setChildBundleCollection($basket, $childBasketItemList, $parentBasketItem);
                    }
                }
            }
        }
 
        if (!empty($basketItemsIndexList) && is_array($basketItemsIndexList))
        {
            foreach ($basketItemsIndexList as $basketIndexId => $basketIndexValue)
            {
                if ($foundedBasketItem = $basket->getItemById($basketIndexId))
                {
                    $foundedBasketItem->delete();
                    $basketChanged = true;
                }
            }
        }
 
        $result->setData(array(
            'BASKET' => $basket,
            'BASKET_CODE_LIST' => $basketCodeList,
            'BASKET_CHANGED' => $basketChanged,
        ));
 
        return $result;
    }

    private function setChildBundleCollection(Sale\Basket $basket, array $basketItemList, Sale\BasketItem $externalParentBasketItem = null)
    {
        $order = null;
 
        $isExternalBasketParent = false;
 
        if ($externalParentBasketItem !== null)
        {
            if (!$externalParentBasketItem->isBundleParent())
            {
                throw new Main\ObjectException('basketItem not parent');
            }
            $isExternalBasketParent = true;
        }

        foreach ($basketItemList as $item)
        {
            if ($item->isBundleChild() || (!$item->isBundleParent() && $isExternalBasketParent && $externalParentBasketItem !== null))
            {
                $parentBasketItem = $item->getParentBasketItem();
 
                if (!$parentBasketItem && $externalParentBasketItem !== null)
                {
                    $parentBasketItem = $externalParentBasketItem;
                }
 
                if ($parentBasketItem)
                {
                    $bundleCollection = $parentBasketItem->createBundleCollection();
 
                    if ($basket->getItemByBasketCode($parentBasketItem->getBasketCode()))
                    {
                        $bundleCollection->addItem($item);
                    }
                    else
                    {
                        $basket->addItem($item);
                    }
 
                    if ($order === null)
                    {
                        if (!$basket = $parentBasketItem->getCollection())
                        {
                            throw new Main\ObjectNotFoundException('Entity "Basket" not found');
                        }

                        $order = $basket->getOrder();
                    }
 
                    if ($bundleCollection->getOrder() === null && $order instanceof Sale\OrderBase)
                        $bundleCollection->setOrder($order);
                }
            }
        }
    }

    public static function add(array $fields)
    {
        $result = new Sale\Result();
 
        $order = null;
        $basket = null;
        $item = null;
 
        $registry = Sale\Registry::getInstance(static::getRegistryType());
 
        if (!array_key_exists('FUSER_ID', $fields) || intval($fields['FUSER_ID']) <= 0)
        {
            $fields['FUSER_ID'] = Sale\Fuser::getId(false);
        }
 
        if (!empty($fields['ORDER_ID']) && intval($fields['ORDER_ID']) > 0)
        {
            $orderClassName = $registry->getOrderClassName();
            $order = $orderClassName::load(intval($fields['ORDER_ID']));
 
            if ($order)
            {
                $basket = $order->getBasket();
            }
        }
 
        if (!$basket)
        {
            $basketClassName = $registry->getBasketClassName();
            $basket = $basketClassName::loadItemsForFUser($fields["FUSER_ID"], $fields['LID']);
        }
 

        if ($item = $basket->getExistsItem($fields["MODULE"], $fields["PRODUCT_ID"], ((!empty($fields["PROPS"]) && is_array($fields["PROPS"]))? $fields["PROPS"] : array())))
        {
            $item->setField('QUANTITY', $item->getQuantity() + $fields['QUANTITY']);
 
            unset($fields['QUANTITY']);

            $r = $item->setFields(static::clearFields($fields));
            if (!$r->isSuccess())
            {
                $result->addErrors($r->getErrors());
                return $result;
            }
            else
            {
                if (!$order)
                    $basket->refreshData(array('PRICE', 'COUPONS', 'QUANTITY'), $item);
            }
        }
 
        if ($item === null)
        {
            $item = $basket->createItem($fields["MODULE"], $fields["PRODUCT_ID"]);
 
            if (isset($fields["PROPS"]) && is_array($fields["PROPS"]))
            {
                $property = $item->getPropertyCollection();
                $property->setProperty($fields["PROPS"]);
            }

            $r = $item->setFields(static::clearFields($fields));
            if (!$r->isSuccess())
            {
                $result->addErrors($r->getErrors());
                return $result;
            }
 
            if ($order)
            {
                $shipmentCollection = $order->getShipmentCollection();
                $systemShipment = $shipmentCollection->getSystemShipment();
                $systemShipmentItemCollection = $systemShipment->getShipmentItemCollection();
                $systemShipmentItemCollection->resetCollection($basket);
 
                if ($systemShipment->getDeliveryId() > 0)
                {
                    $orderCompatibilityClassName = static::getOrderCompatibilityClassName();
                    $shipment = $orderCompatibilityClassName::getShipmentByDeliveryId($shipmentCollection, $systemShipment->getDeliveryId());
 
                    if (!$shipment)
                    {
                        if ($service = Sale\Delivery\Services\Manager::getObjectById($systemShipment->getDeliveryId()))
                        {
                            $shipment = $shipmentCollection->createItem($service);
                        }
                    }
 
 
                    if ($shipment)
                    {
                        $shipmentItemCollection = $shipment->getShipmentItemCollection();

                        $shipmentItem = $shipmentItemCollection->createItem($item);
                        if ($shipmentItem)
                            $shipmentItem->setQuantity($item->getQuantity());
                    }
                }

                $r = $order->refreshData(array('PRICE', 'PRICE_DELIVERY'));
                if (!$r->isSuccess())
                {
                    $result->addErrors($r->getErrors());
                    return $result;
                }
 
            }
        }
 
        if ($order !== null)
        {
            $r = $order->save();
            if (!$r->isSuccess())
            {
                $result->addErrors($r->getErrors());
            }
        }
        else
        {
            $isNew = false;
            if ($item->getId() == 0)
            {
                $isNew = true;
            }
 
            $r = $basket->save();
            if (!$r->isSuccess())
            {
                $result->addErrors($r->getErrors());
            }
        }
 
        if ($r->isSuccess())
        {
            if (!DiscountCompatibility::isInited())
                DiscountCompatibility::init();
            if (DiscountCompatibility::usedByClient())
            {
                $id = $item->getId();
                DiscountCompatibility::setBasketItemData($id, $fields);
                DiscountCompatibility::setBasketCode($id, $item->getBasketCode());
            }
 
            $result->setId($item->getId());
            $result->addData(array(
                'QUANTITY' => $item->getQuantity()
            ));
        }
 
 
        return $result;
    }

    public static function update($id, array $fields)
    {
        $result = new Sale\Result();
 
        $item = null;
        $basket = null;
        $order = null;
        $orderId = null;
 
        $registry = Sale\Registry::getInstance(static::getRegistryType());

        $itemResult = static::loadEntityFromBasket($id);
        if ($itemResult->isSuccess())
        {
            $itemResultData = $itemResult->getData();
            if (isset($itemResultData['BASKET_ITEM']))
            {
                $item = $itemResultData['BASKET_ITEM'];
                $basket = $item->getBasket();
            }
 
            if (isset($itemResultData['ORDER']))
            {
                $order = $itemResultData['ORDER'];
            }
        }
 
        if (!$item)
        {
            $result->addError(new Sale\ResultError(Main\Localization\Loc::getMessage('SALE_BASKET_COMPATIBLE_BASKET_ITEM_NOT_FOUND'), 'BASKET_ITEM_NOT_FOUND'));
            return $result;
 
        }
 
        if ($order !== null &&
            $fields['ORDER_ID'] > 0 &&
            (int)$fields['ORDER_ID'] !== (int)$order->getId()
        )
        {
            $result->addError(
                new Sale\ResultError(
                    Main\Localization\Loc::getMessage('SALE_BASKET_COMPATIBLE_BASKET_ITEM_ERROR_BIND_TO_ORDER'),
                    'BASKET_ITEM_NOT_FOUND'
                )
            );
 
            return $result;
        }
 
        if (isset($fields["PROPS"]) && is_array($fields["PROPS"]))
        {
            $property = $item->getPropertyCollection();
            $property->clearCollection();
            $property->setProperty($fields["PROPS"]);
        }
 
        if ($order !== null && isset($fields['PRICE']))
        {
            if ($fields['PRICE'] != $item->getPrice())
                $fields['CUSTOM_PRICE'] = 'Y';
        }
 
        if (!empty($fields['FUSER_ID']))
        {
            $item->setFieldNoDemand('FUSER_ID', intval($fields['FUSER_ID']));
            unset($fields['FUSER_ID']);
        }
 
        $r = $item->setFields(static::clearFields($fields));
        if (!$r->isSuccess())
        {
            $result->addErrors($r->getErrors());
        }
 
        if(DiscountCompatibility::isUsed())
        {
            if (!DiscountCompatibility::isInited())
                DiscountCompatibility::init();
            if (DiscountCompatibility::usedByClient())
            {
                DiscountCompatibility::setBasketItemData($id, $fields);
                DiscountCompatibility::setBasketCode($id, $item->getBasketCode());
            }
        }
 
 
        if ($order === null && !empty($fields['ORDER_ID']) && intval($fields['ORDER_ID']) > 0)
        {
            $orderId = intval($fields['ORDER_ID']);
 
            $orderClassName = $registry->getOrderClassName();
            if ($order = $orderClassName::load($orderId))
            {
                if ($basket = $order->getBasket())
                {
                    $basket->addItem($item);

                    if (!$shipmentCollection = $order->getShipmentCollection())
                    {
                        throw new Main\ObjectNotFoundException('Entity "ShipmentCollection" not found');
                    }

                    $orderCompatibilityClassName = static::getOrderCompatibilityClassName();
                    $orderCompatibilityClassName::createShipmentFromShipmentSystem($shipmentCollection);

                    $r = static::syncShipmentCollectionAndBasket($shipmentCollection, $basket);
                    if (!$r->isSuccess())
                    {
                        $result->addErrors($r->getErrors());
                        return $result;
                    }
 
                    $r = $order->refreshData(array("PRICE_DELIVERY"));
                    if (!$r->isSuccess())
                    {
                        $result->addErrors($r->getErrors());
                        return $result;
                    }
 
                    $r = $order->doFinalAction(true);
                    if (!$r->isSuccess())
                    {
                        $result->addErrors($r->getErrors());
                        return $result;
                    }
                }
 
            }
        }
 
        if ($order !== null)
        {
            if ($shipmentCollection = $order->getShipmentCollection())
            {
                if (count($shipmentCollection) == 2 && $shipmentCollection->isExistsSystemShipment())
                {
                    foreach ($shipmentCollection as $shipment)
                    {
                        if ($shipment->isSystem() || $shipment->isShipped())
                            continue;

                        $systemShipment = $shipmentCollection->getSystemShipment();

                        $systemShipmentItemCollection = $systemShipment->getShipmentItemCollection();

                        if (!$systemShipmentItem = $systemShipmentItemCollection->getItemByBasketCode($item->getBasketCode()))
                            continue;

                        if (!$shipmentItemCollection = $shipment->getShipmentItemCollection())
                            continue;
 

                        if (!$shipmentItem = $shipmentItemCollection->getItemByBasketCode($item->getBasketCode()))
                            continue;
 
 
                        if ($systemShipmentItem->getQuantity() > 0)
                        {
                            $r = $shipmentItem->setQuantity(($shipmentItem->getQuantity() + $systemShipmentItem->getQuantity()));
                            if (!$r->isSuccess())
                            {
                                $result->addErrors($r->getErrors());
                            }
                        }
                    }
                }
            }
 
            if (!$result->isSuccess())
            {
                return $result;
            }
 
            $r = $order->save();
        }
        else
        {
            if (!$result->isSuccess())
            {
                return $result;
            }
 
            $r = $basket->save();
        }
 
        if (!$r->isSuccess())
        {
            $result->addErrors($r->getErrors());
        }
 
        return $result;
    }

    public static function delete($id)
    {
        $result = new Sale\Result();
 
        $item = null;
        $basket = null;
        $order = null;
 
        $registry = Sale\Registry::getInstance(static::getRegistryType());
        $basketClassName = $registry->getBasketClassName();
        $res = $basketClassName::getList(
            array(
                'filter' => array(
                    'ID' => $id
                ),
                'select' => array(
                    'ID', 'ORDER_ID', 'SET_PARENT_ID', 'TYPE', 'FUSER_ID', 'LID'
                ),
            ));
        if (!$itemDat = $res->fetch())
        {
            $result->addError(new Sale\ResultError(Main\Localization\Loc::getMessage('SALE_BASKET_COMPATIBLE_BASKET_ITEM_NOT_FOUND'), 'BASKET_ITEM_NOT_FOUND'));
            return $result;
        }
 
        if (intval($itemDat['ORDER_ID']) > 0)
        {
            $orderClassName = $registry->getOrderClassName();
            if ($order = $orderClassName::load(intval($itemDat['ORDER_ID'])))
            {
                if ($basket = $order->getBasket())
                {
                    $item = $basket->getItemById($id);
                }
            }
        }
        else
        {
            if (!array_key_exists('FUSER_ID', $itemDat) || intval($itemDat['FUSER_ID']) <= 0)
            {
                $itemDat['FUSER_ID'] = Sale\Fuser::getId();
            }

            $basketClassName = $registry->getBasketClassName();
            if ($basket = $basketClassName::loadItemsForFUser($itemDat["FUSER_ID"], $itemDat['LID']))
            {
                $item = $basket->getItemById($id);
            }
        }
 
        if ($basket === null)
        {
            $result->addError(new Sale\ResultError(Main\Localization\Loc::getMessage('SALE_BASKET_COMPATIBLE_BASKET_COLLECTION_NOT_FOUND'), 'BASKET_COLLECTION_NOT_FOUND'));
            return $result;
        }
 
 
        if ($item === null)
        {
            $result->addError(new Sale\ResultError(Main\Localization\Loc::getMessage('SALE_BASKET_COMPATIBLE_BASKET_ITEM_PROPS_NOT_FOUND'), 'BASKET_ITEM_PROPS_NOT_FOUND'));
            return $result;
 
        }

        $r = $item->delete();
        if (!$r->isSuccess())
        {
            $result->addErrors($r->getErrors());
        }
 
        if ($order !== null)
        {
            if (!$result->isSuccess())
            {
                return $result;
            }

            $r = $order->save();
        }
        else
        {
            if (!$result->isSuccess())
            {
                return $result;
            }

            $r = $basket->save();
 
            if ($r->isSuccess())
            {
                Sale\BasketComponentHelper::clearFUserBasketQuantity($itemDat['FUSER_ID'], $itemDat['LID']);
                Sale\BasketComponentHelper::clearFUserBasketPrice($itemDat['FUSER_ID'], $itemDat['LID']);
            }
        }
 
        if (!$r->isSuccess())
        {
            $result->addErrors($r->getErrors());
        }
 
        return $result;
    }

    public static function getAliasFields()
    {
        return array(
            'ORDER_STATUS' => 'ORDER.STATUS_ID',
            'ORDER_CANCELED' => 'ORDER.CANCELED',
            'ORDER_PRICE' => 'ORDER.PRICE',
            'ORDER_DATE' => 'ORDER.DATE_INSERT',
 
            'USER_ID' => 'USER.ID',
 
            'SUM_PRICE' => 'SUMMARY_PRICE',
 
            'ORDER_ALLOW_DELIVERY' => 'SHIPMENT.ALLOW_DELIVERY',
            'ORDER_DATE_ALLOW_DELIVERY' => 'SHIPMENT.DATE_ALLOW_DELIVERY',
            'DEDUCTED' => 'SHIPMENT.DEDUCTED',
            'SHIPMENT_SYSTEM' => 'SHIPMENT.SYSTEM',
 
            'ORDER_PAYED' => 'PAYMENT.PAID',
            'ORDER_DATE_PAYED' => 'PAYMENT.DATE_PAID',
 
 
        );
    }

    protected static function getSelectFields()
    {
        return array_keys(static::getEntity()->getScalarFields());
    }

    public static function getAvailableFields()
    {
        $registry = Sale\Registry::getInstance(static::getRegistryType());
        $basketItemClassName = $registry->getBasketItemClassName();
        $fields = $basketItemClassName::getAvailableFields();
 
        if ($index = array_search('SET_PARENT_ID', $fields))
            unset($fields[$index]);
 
        return $fields;
    }

    protected static function loadEntityFromBasket($id)
    {
        $result = new Sale\Result();
 
        $order = null;
        $basket = null;
        $item = null;
 
        $registry = Sale\Registry::getInstance(static::getRegistryType());
        $basketClassName = $registry->getBasketClassName();
        $res = $basketClassName::getList(array(
                'filter' => array(
                    'ID' => $id
                ),
                'select' => array(
                    'ID', 'ORDER_ID', 'SET_PARENT_ID', 'TYPE', 'FUSER_ID', 'LID'
                ),
        ));
        if (!$itemDat = $res->fetch())
        {
            $result->addError(new Sale\ResultError(Main\Localization\Loc::getMessage('SALE_BASKET_COMPATIBLE_BASKET_ITEM_NOT_FOUND'), 'BASKET_ITEM_NOT_FOUND'));
            return $result;
        }
 
        if (intval($itemDat['ORDER_ID']) > 0)
        {
            $orderClassName = $registry->getOrderClassName();
            if ($order = $orderClassName::load(intval($itemDat['ORDER_ID'])))
            {
                if ($basket = $order->getBasket())
                {
                    $item = $basket->getItemById($id);
                }
            }
        }
        else
        {
            $basketClassName = $registry->getBasketClassName();
            $basket = $basketClassName::loadItemsForFUser($itemDat["FUSER_ID"], $itemDat['LID']);
 
            if ($basket)
            {
                $item = $basket->getItemById($id);
            }
 
        }
 
        $data = array(
            'BASKET_ITEM' => $item
        );
 
        if ($order !== null)
        {
            $data['ORDER'] = $order;
        }
 
        $result->setData($data);
 
        return $result;
    }

    protected static function appendBasketToOrder(Sale\Order $order, Sale\Basket $basket)
    {
        $result = new Sale\Result();
 
        $orderBasketCollection = $order->getBasket();
 
        $shipmentCollection = $order->getShipmentCollection();
        $systemShipment = $shipmentCollection->getSystemShipment();
        $systemShipmentItemCollection = $systemShipment->getShipmentItemCollection();

        foreach ($basket as $basketItem)
        {
            $basketProperty = array();
            if ($basketPropertyCollection = $basketItem->getPropertyCollection())
            {
                $basketProperty = $basketPropertyCollection->getPropertyValues();
            }
 
            if ($orderBasketItem = $orderBasketCollection->getExistsItem($basketItem->getField('MODULE'), $basketItem->getField('PRODUCT_ID'), $basketProperty))
            {
                $fields = $basketItem->getFieldValues();
                $orderBasketItem->setFields(static::clearFields($fields));
            }
            else
            {
                $orderBasketCollection->addItem($basketItem);
                $basketItem->setCollection($orderBasketCollection);
 
 
                $systemShipmentItemCollection->resetCollection($orderBasketCollection);
            }
        }

        foreach ($basket as $basketItem)
        {
            if ($systemShipment->getDeliveryId() > 0)
            {
                $orderCompatibilityClassName = static::getOrderCompatibilityClassName();

                $shipment = $orderCompatibilityClassName::getShipmentByDeliveryId($shipmentCollection, $systemShipment->getDeliveryId());
 
                if (!$shipment)
                {
                    if ($service = Sale\Delivery\Services\Manager::getObjectById($systemShipment->getDeliveryId()))
                    {
                        $shipment = $shipmentCollection->createItem($service);
                    }
                }
 
 
                if ($shipment)
                {
                    $shipmentItemCollection = $shipment->getShipmentItemCollection();
 
                    if (!$shipmentItem = $shipmentItemCollection->getItemByBasketCode($basketItem->getBasketCode()))
                    {
                        $shipmentItem = $shipmentItemCollection->createItem($basketItem);
                    }

                    $r = $shipmentItem->setQuantity($basketItem->getQuantity());
                    if (!$r->isSuccess())
                    {
                        $result->addErrors($r->getErrors());
                    }
                }
            }
        }
 
        return $result;
 
    }

    public static function setBasketFields(array $list)
    {
        $result = new Sale\Result();
 
        $order = null;
        $basket = null;
        $basketItem = null;
        $orderId = null;
 
        foreach ($list as $basketId => $fields)
        {
            $basketItemResult = static::loadEntityFromBasket($basketId);
            if ($basketItemResult->isSuccess())
            {
                $basketItemResultList = $basketItemResult->getData();
                if (isset($basketItemResultList['BASKET']))
                {
                    $basket = $basketItemResultList['BASKET'];
                }
 
                if (isset($basketItemResultList['BASKET_ITEM']))
                {
                    $basketItem = $basketItemResultList['BASKET_ITEM'];
                }
 
                if (isset($basketItemResultList['ORDER']))
                {
                    $order = $basketItemResultList['ORDER'];
                }
            }
 
            if ($basketItem === null)
            {
                $result->addError(new Sale\ResultError(Main\Localization\Loc::getMessage('SALE_BASKET_COMPATIBLE_BASKET_ITEM_NOT_FOUND'), 'BASKET_ITEM_NOT_FOUND'));
                return $result;
            }
 
            if ($orderId === null && isset($fields['ORDER_ID']) && intval($fields['ORDER_ID']) > 0)
            {
                $orderId = (int)$fields['ORDER_ID'];
            }
 
            if (isset($fields['ORDER_ID']))
                unset($fields['ORDER_ID']);
 
            $basketItem->setFields($fields);
 
            if ($order === null && intval($orderId) > 0)
            {
                $registry = Sale\Registry::getInstance(static::getRegistryType());
                $orderClassName = $registry->getOrderClassName();
                $order = $orderClassName::load($orderId);
            }
 
        }
 
        if ($order === null)
        {
            return $result;
        }
 
        if ($order !== null && $basket !== null)
        {
            $r = static::appendBasketToOrder($order, $basket->getOrderableItems());
            if(!$r->isSuccess())
            {
                $result->addErrors($r->getErrors());
            }
        }

        $r = $order->save();
        if (!$r->isSuccess())
        {
            $result->addErrors($r->getErrors());
        }
        return $result;
    }
 

    protected function getOrderCompatibility()
    {
        return $this->orderCompatibility;
    }

    public static function syncShipmentCollectionAndBasket(Sale\ShipmentCollection $shipmentCollection, Sale\Basket $basket)
    {
        $result = new Sale\Result();
 
        if (count($shipmentCollection) > 2)
        {
            return $result;
        }

        if (!$order = $shipmentCollection->getOrder())
        {
            throw new Main\ObjectNotFoundException('Entity "Order" not found');
        }
 
        $baseShipment = null;
 
        $shipmentCollection->setMathActionOnly(true);
 
        if (count($shipmentCollection) == 1 && $shipmentCollection->isExistsSystemShipment())
        {
            if (!$systemShipment = $shipmentCollection->getSystemShipment())
            {
                throw new Main\ObjectNotFoundException('Entity system "Shipment" not found');
            }
 
            $shipment = $shipmentCollection->createItem();
            $r = $shipmentCollection->cloneShipment($systemShipment, $shipment);
            if (!$r->isSuccess())
            {
                $result->addErrors($r->getErrors());
                return $result;
            }
        }
 

        foreach ($shipmentCollection as $shipment)
        {
            if ($shipment->isSystem() || $shipment->isShipped())
                continue;

            foreach ($basket as $basketItem)
            {
                $shipmentItemCollection = $shipment->getShipmentItemCollection();
                if (!$shipmentItem = $shipmentItemCollection->getItemByBasketCode($basketItem->getBasketCode()))
                {
                    $shipmentItem = $shipmentItemCollection->createItem($basketItem);
                }
 
                if (!$shipmentItem)
                    continue;

                $r = $shipmentItem->setQuantity($basketItem->getQuantity());
                if (!$r->isSuccess())
                {
                    $result->addErrors($r->getErrors());
                }
 
            }
 
            break;
        }
 
        $shipmentCollection->setMathActionOnly(false);
 
        return $result;
 
    }

    public static function convertBasketItemToArray(Sale\BasketItem $basketItem)
    {
        $fields = $basketItem->getFieldValues();

        $collection = $basketItem->getCollection();

        if (!$basket = $collection->getBasket())
        {
            throw new Main\ObjectNotFoundException('Entity "Basket" not found');
        }
 
        if (empty($fields['LID']))
            $fields['LID'] = $basket->getSiteId();
 
        if (empty($fields['LID']))
        {
            if ($order = $basket->getOrder())
            {
                $fields['LID'] = $order->getField('LID');
            }
            //$order->getField('LID')
 
        }
 
        if (empty($fields['FUSER_ID']))
            $fields['FUSER_ID'] = $basket->getFUserId(true);
 

        if ($propertyCollection = $basketItem->getPropertyCollection())
        {
            $fields['PROPS'] = $propertyCollection->getPropertyValues();
        }
 
        return $fields;
    }
 
    protected function getWhiteListFields()
    {
        return array_merge(parent::getWhiteListFields(), array('USER_ID'), array_keys(static::getAliasFields()));
    }
}
 
 
class BasketFetchAdapter implements FetchAdapter
{
    public function adapt(array $row)
    {
        if(!empty($row["~DIMENSIONS"]) && is_array($row["~DIMENSIONS"]))
            $row["~DIMENSIONS"] = serialize($row["~DIMENSIONS"]);
 
        if(!empty($row["DIMENSIONS"]) && is_array($row["DIMENSIONS"]))
            $row["DIMENSIONS"] = serialize($row["DIMENSIONS"]);
 
        if(!empty($row["QUANTITY"]))
            $row["QUANTITY"] = Sale\BasketItem::formatQuantity($row['QUANTITY']);
 
        if(!empty($row["~QUANTITY"]))
            $row["~QUANTITY"] = Sale\BasketItem::formatQuantity($row['~QUANTITY']);
 
        return $row;
    }
}