discount.php

<?php
namespace Bitrix\Sale;
 
use Bitrix\Main,
    Bitrix\Main\Localization\Loc,
    Bitrix\Sale\Compatible,
    Bitrix\Sale\Discount\Context;
 
Loc::loadMessages(__FILE__);
 
class Discount extends DiscountBase
{
    /* Sale objects */
    protected $shipment = null;
    protected $shipmentIds = array();
 
    protected $enableCheckingPrediction = false;
 
    public function enableCheckingPrediction()
    {
        $this->enableCheckingPrediction = true;
        $this->saleOptions = array(
            'APPLY_MODE' => $this::APPLY_MODE_ADD,
        );
    }
 
    public function disableCheckingPrediction()
    {
        $this->enableCheckingPrediction = false;
    }
 
    public static function loadByFuser($fuser, $site)
    {
        $instanceIndex = static::getInstanceIndexByFuser((int)$fuser, (string)$site);
        if (!static::instanceExists($instanceIndex))
            return null;
        return static::getInstance($instanceIndex);
    }
 
    public static function getRegistryType()
    {
        return Registry::REGISTRY_TYPE_ORDER;
    }
 
    public function setCalculateShipments(Shipment $shipment = null)
    {
        $this->shipment = $shipment;
    }
 
    public function getShipmentsIds()
    {
        return $this->shipmentIds;
    }
 
    public function createClone(\SplObjectStorage $cloneEntity)
    {
        $discountClone = parent::createClone($cloneEntity);
 
        if ($this->isShipmentExists())
        {
            if ($cloneEntity->contains($this->shipment))
                $discountClone->shipment = $cloneEntity[$this->shipment];
        }
 
        return $discountClone;
    }
 
    /* apply result methods */
 
    public function setApplyResult($applyResult)
    {
        parent::setApplyResult($applyResult);
 
        if (!empty($this->applyResult['DISCOUNT_LIST']))
        {
            if (!empty($this->applyResult['DELIVERY']) && is_array($this->applyResult['DELIVERY']))
            {
                foreach ($this->applyResult['DELIVERY'] as $orderDiscountId => $apply)
                {
                    if ($apply == 'Y')
                        $this->applyResult['DISCOUNT_LIST'][$orderDiscountId] = 'Y';
                }
                unset($apply, $orderDiscountId);
            }
        }
    }
 
    public function getApplyResult($extMode = false)
    {
        if (Compatible\DiscountCompatibility::isUsed())
            return Compatible\DiscountCompatibility::getApplyResult($extMode);
 
        $extMode = ($extMode === true);
 
        $result = parent::getApplyResult($extMode);
        $result = $this->getApplyDeliveryList() + $result;
 
        $result['CONVERTED_ORDER'] = (!$this->isValidState() ? 'Y' : 'N');
 
        if (!$extMode)
        {
            /* for compatibility only */
            if (isset($this->discountResult['APPLY_BLOCKS'][0]['BASKET']))
                $result['BASKET'] = $this->discountResult['APPLY_BLOCKS'][0]['BASKET'];
            if (isset($this->discountResult['APPLY_BLOCKS'][0]['ORDER']))
                $result['ORDER'] = $this->discountResult['APPLY_BLOCKS'][0]['ORDER'];
        }
        return $result;
    }
 
    public function getShowPrices()
    {
        $result = parent::getShowPrices();
        $result['DELIVERY'] = $this->getApplyDeliveryPrice();
 
        return $result;
    }
 
    public function save()
    {
        $result = new Result;
        if (!$this->isOrderExists() || !$this->isBasketNotEmpty())
            return $result;
 
        if ($this->isUsedDiscountCompatibility())
        {
            if (Compatible\DiscountCompatibility::isRepeatSave())
                return $result;
            $compatibleResult = Compatible\DiscountCompatibility::getResult();
            if ($compatibleResult === false)
                return $result;
            if (empty($compatibleResult))
                return $result;
 
            $this->setUseMode($compatibleResult['CALCULATE']['USE_MODE']);
            $this->newOrder = $compatibleResult['CALCULATE']['NEW_ORDER'];
            $this->discountsCache = $compatibleResult['DISCOUNT_LIST'];
            $this->couponsCache = $compatibleResult['COUPONS_LIST'];
            $this->discountResult = $compatibleResult['DISCOUNT_RESULT'];
            $this->forwardBasketTable = $compatibleResult['FORWARD_BASKET_TABLE'];
            $this->reverseBasketTable = $compatibleResult['REVERSE_BASKET_TABLE'];
            if ($this->isOrderNew())
            {
                $shipmentResult = $this->loadShipment();
                if (!$shipmentResult->isSuccess())
                {
                    $result->addErrors($shipmentResult->getErrors());
                    unset($shipmentResult);
                    return $result;
                }
                unset($shipmentResult);
                $this->fillShipmentData();
            }
            unset($compatibleResult);
        }
 
        $result = parent::save();
 
        return $result;
    }
 
    protected function getOrderConfig()
    {
        $shipmentClassName = $this->getShipmentClassName();
        $config = parent::getOrderConfig();
        $config['DELIVERY'] = [
            'DELIVERY_ID' => $this->orderData['DELIVERY_ID'],
            'CUSTOM_PRICE_DELIVERY' => $this->orderData['CUSTOM_PRICE_DELIVERY'],
            'SHIPMENT_ID' => 0
        ];
        if ($this->shipment instanceof $shipmentClassName)
            $config['DELIVERY']['SHIPMENT_ID'] = $this->shipment->getId();
        unset($shipmentClassName);
        return $config;
    }
 
    /* instance tools */
 
    protected static function getInstanceIndexByFuser($fuser, $site)
    {
        return '0|'.$fuser.'|'.$site;
    }
 
    protected function getExecuteFieldList()
    {
        if (!$this->enableCheckingPrediction)
            return parent::getExecuteFieldList();
        return ['PREDICTIONS_APP', 'APPLICATION'];
    }
 
    protected function getConditionField()
    {
        if (!$this->enableCheckingPrediction)
            return parent::getConditionField();
        return 'PREDICTIONS_APP';
    }
 
    protected static function getStepResult(array $order)
    {
        $result = parent::getStepResult($order);;
        $stepResult = &$order['DISCOUNT_RESULT'];
        if (!empty($stepResult['DELIVERY']) && is_array($stepResult['DELIVERY']))
        {
            $result['DELIVERY'] = array(
                'APPLY' => 'Y',
                'DELIVERY_ID' => (isset($order['DELIVERY_ID']) ? $order['DELIVERY_ID'] : false),
                'SHIPMENT_CODE' => (isset($order['SHIPMENT_CODE']) ? $order['SHIPMENT_CODE'] : false),
                'DESCR' => Discount\Formatter::formatList($stepResult['DELIVERY']),
                'DESCR_DATA' => $stepResult['DELIVERY'],
                'ACTION_BLOCK_LIST' => array_keys($stepResult['DELIVERY'])
            );
            if (is_array($result['DELIVERY']['DESCR']))
                $result['DELIVERY']['DESCR'] = implode(', ', $result['DELIVERY']['DESCR']);
        }
        unset($stepResult);
 
        return $result;
    }
 
    protected function normalizeDiscountResult()
    {
        parent::normalizeDiscountResult();
 
        if (empty($this->orderData))
        {
            return;
        }
 
        $customPrice = isset($this->orderData['CUSTOM_PRICE_DELIVERY']) && $this->orderData['CUSTOM_PRICE_DELIVERY'] == 'Y';
        $this->orderData['PRICE_DELIVERY_DIFF'] = (!$customPrice
            ? PriceMaths::roundPrecision($this->orderData['PRICE_DELIVERY_DIFF'])
            : 0
        );
        if (!$customPrice)
        {
            if ($this->orderData['PRICE_DELIVERY_DIFF'] > 0)
                $this->orderData['PRICE_DELIVERY'] = $this->orderData['BASE_PRICE_DELIVERY'] - $this->orderData['PRICE_DELIVERY_DIFF'];
            else
                $this->orderData['PRICE_DELIVERY'] = PriceMaths::roundPrecision($this->orderData['PRICE_DELIVERY']);
        }
        unset($customPrice);
    }
 
    protected function getApplyPrices()
    {
        parent::getApplyPrices();
        $this->discountResult['PRICES']['DELIVERY'] = $this->getApplyDeliveryPrice();
    }
 
    protected function remakingDiscountResult()
    {
        parent::remakingDiscountResult();
 
        $delivery = [];
        if (!empty($this->discountResult['APPLY_BLOCKS']))
        {
            foreach ($this->discountResult['APPLY_BLOCKS'] as $counter => $applyBlock)
            {
                if (!empty($applyBlock['ORDER']))
                {
                    foreach ($applyBlock['ORDER'] as $discount)
                    {
                        if (!empty($discount['RESULT']['DELIVERY']))
                        {
                            $delivery[] = [
                                'DISCOUNT_ID' => $discount['DISCOUNT_ID'],
                                'COUPON_ID' => $discount['COUPON_ID'],
                                'DELIVERY_ID' => $discount['RESULT']['DELIVERY']['DELIVERY_ID'],
                                'APPLY' => $discount['RESULT']['DELIVERY']['APPLY'],
                                'DESCR' => $discount['RESULT']['DELIVERY']['DESCR']
                            ];
                        }
                    }
                    unset($discount);
                }
            }
            unset($counter, $applyBlock);
        }
        $this->discountResult['RESULT']['DELIVERY'] = $delivery;
        unset($delivery);
    }
 
    protected function getApplyDeliveryPrice()
    {
        return array(
            'BASE_PRICE' => $this->orderData['BASE_PRICE_DELIVERY'] ?? 0.0,
            'PRICE' => $this->orderData['PRICE_DELIVERY'] ?? 0.0,
            'DISCOUNT' => $this->orderData['PRICE_DELIVERY_DIFF'] ?? 0.0,
        );
    }
 
    protected function getApplyDeliveryList()
    {
        $result = array();
 
        $delivery = array();
        if (!empty($this->discountResult['APPLY_BLOCKS']))
        {
            foreach ($this->discountResult['APPLY_BLOCKS'] as $counter => $applyBlock)
            {
                if (!empty($applyBlock['ORDER']))
                {
                    foreach ($applyBlock['ORDER'] as $discount)
                    {
                        if (empty($discount['RESULT']['DELIVERY']))
                            continue;
                        $id = $discount['RESULT']['DELIVERY']['DELIVERY_ID'];
                        $delivery[$id] = $id;
                    }
                    unset($id, $discount);
                }
            }
            unset($counter, $applyBlock);
        }
        $result['DELIVERY_LIST'] = (empty($delivery) ? array() : array_values($delivery));
        unset($delivery);
 
        $shipmentClassName = $this->getShipmentClassName();
        $shipment = [];
        if ($this->shipment instanceof $shipmentClassName)
            $shipment[] = $this->shipment->getShipmentCode();
        $result['SHIPMENT_LIST'] = $shipment;
        unset($shipment);
 
        return $result;
    }
 
    protected function fillEmptyDiscountResult()
    {
        parent::fillEmptyDiscountResult();
        $this->discountResult['DELIVERY_LIST'] = [];
        $this->discountResult['SHIPMENT_LIST'] = [];
    }
 
    protected function fillDiscountResult()
    {
        $result = parent::fillDiscountResult();
 
        $orderKeys = ['PRICE_DELIVERY', 'PRICE_DELIVERY_DIFF'];
        foreach ($orderKeys as $key)
        {
            if (isset($this->orderData[$key]))
                $result[$key] = $this->orderData[$key];
        }
        unset($key, $orderKeys);
        if (isset($result['PRICE_DELIVERY_DIFF']))
        {
            $result['DISCOUNT_PRICE'] = $result['PRICE_DELIVERY_DIFF'];
            unset($result['PRICE_DELIVERY_DIFF']);
        }
 
        $shipmentClassName = $this->getShipmentClassName();
        $result['SHIPMENT'] = null;
        if ($this->shipment instanceof $shipmentClassName)
            $result['SHIPMENT'] = $this->shipment->getShipmentCode();
        unset($shipmentClassName);
 
        return $result;
    }
 
    protected function resetPrices()
    {
        parent::resetPrices();
        $this->resetDeliveryPrices();
    }
 
    protected function resetDeliveryPrices()
    {
        if ($this->orderData['CUSTOM_PRICE_DELIVERY'] !== 'N')
            return;
        $this->orderData['PRICE_DELIVERY'] = $this->orderData['BASE_PRICE_DELIVERY'];
        $this->orderData['PRICE_DELIVERY_DIFF'] = 0;
    }
 
    protected function loadOrderData()
    {
        $result = parent::loadOrderData();
        if (!$result->isSuccess())
            return $result;
 
        if (!$this->isShipmentExists())
        {
            $this->shipmentIds = [];
            $shipmentResult = $this->loadShipment();
            if (!$shipmentResult->isSuccess())
            {
                $result->addErrors($shipmentResult->getErrors());
                return $result;
            }
            unset($shipmentResult);
        }
        $this->fillShipmentData();
 
        return $result;
    }
 
    protected function fillEmptyOrderData()
    {
        parent::fillEmptyOrderData();
        $this->orderData += [
            'BASE_PRICE_DELIVERY' => 0,
            'PRICE_DELIVERY' => 0,
            'PRICE_DELIVERY_DIFF' => 0,
            'DELIVERY_ID' => 0,
            'CUSTOM_PRICE_DELIVERY' => 'N',
            'SHIPMENT_CODE' => 0,
            'SHIPMENT_ID' => 0,
            'PAY_SYSTEM_ID' => 0
        ];
 
        if ($this->isOrderExists())
        {
            $order = $this->getOrder();
 
            $this->orderData['PAY_SYSTEM_ID'] = null;
            $paymentCollection = $order->getPaymentCollection();
            foreach ($paymentCollection as $payment)
            {
                if ($payment->isInner())
                    continue;
                if (!isset($this->orderData['PAY_SYSTEM_ID']))
                {
                    $this->orderData['PAY_SYSTEM_ID'] = (int)$payment->getPaymentSystemId();
                    break;
                }
            }
            unset($payment, $paymentCollection);
            if (!isset($this->orderData['PAY_SYSTEM_ID']))
                $this->orderData['PAY_SYSTEM_ID'] = 0;
 
            unset($order);
        }
    }
 
    protected function loadBasket()
    {
        $result = parent::loadBasket();
        if (!$result->isSuccess())
            return $result;
 
        if ($this->isBasketNotEmpty())
        {
            $basket = $this->getBasket();
            foreach ($basket as $basketItem)
            {
                if (
                    !$basketItem->canBuy()
                    || !$basketItem->isBundleParent()
                )
                    continue;
 
                $bundle = $basketItem->getBundleCollection();
                if ($bundle->count() == 0)
                {
                    $result->addError(new Main\Entity\EntityError(
                        Loc::getMessage('BX_SALE_DISCOUNT_ERR_BASKET_BUNDLE_EMPTY'),
                        self::ERROR_ID
                    ));
                    break;
                }
                foreach ($bundle as $bundleItem)
                {
                    $item = $this->getBasketItemFields($bundleItem);
                    $item['IN_SET'] = 'Y';
                    $this->orderData['BASKET_ITEMS'][$bundleItem->getBasketCode()] = $item;
                }
                unset($item, $bundle, $bundleItem);
            }
            unset($basketItem);
        }
 
        return $result;
    }
 
    protected function loadDefaultOrderConfig()
    {
        parent::loadDefaultOrderConfig();
 
        $this->shipment = null;
 
        $this->fillCompatibleOrderFields();
    }
 
    protected function applyLoadedOrderConfig(array $data)
    {
        parent::applyLoadedOrderConfig($data);
 
        if (isset($data['OLD_ORDER']))
            $this->setValidState(false);
 
        $order = $this->getOrder();
        if (!empty($data['DELIVERY']))
        {
            $delivery = $data['DELIVERY'];
            $this->orderData['DELIVERY_ID'] = $delivery['DELIVERY_ID'];
            if (isset($delivery['CUSTOM_PRICE_DELIVERY']))
                $this->orderData['CUSTOM_PRICE_DELIVERY'] = $delivery['CUSTOM_PRICE_DELIVERY'];
            if (isset($delivery['SHIPMENT_ID']))
            {
                $delivery['SHIPMENT_ID'] = (int)$delivery['SHIPMENT_ID'];
                if ($delivery['SHIPMENT_ID'] > 0)
                {
                    $this->shipmentIds[] = $delivery['SHIPMENT_ID'];
                    $orderShipmentList = $order->getShipmentCollection();
                    $this->shipment = $orderShipmentList->getItemById($delivery['SHIPMENT_ID']);
                    if (empty($this->shipment))
                    {
                        $this->shipment = null;
                        $this->shipmentIds = array();
                    }
                }
            }
            unset($delivery);
        }
 
        $this->fillCompatibleOrderFields();
    }
 
    protected function isShipmentExists()
    {
        $shipmentClassName = $this->getShipmentClassName();
        return ($this->shipment instanceof $shipmentClassName);
    }
 
    protected function fillShipmentData()
    {
        if (!$this->isShipmentExists())
            return;
 
        $this->orderData['DELIVERY_ID'] = $this->shipment->getDeliveryId();
        $this->orderData['CUSTOM_PRICE_DELIVERY'] = ($this->shipment->isCustomPrice() ? 'Y' : 'N');
        $this->orderData['BASE_PRICE_DELIVERY'] = $this->shipment->getField('BASE_PRICE_DELIVERY');
        $this->orderData['PRICE_DELIVERY'] = $this->shipment->getPrice();
        $this->orderData['PRICE_DELIVERY_DIFF'] = $this->shipment->getField('DISCOUNT_PRICE');
        $this->orderData['SHIPMENT_CODE'] = $this->shipment->getShipmentCode();
        $this->orderData['SHIPMENT_ID'] = (int)$this->shipment->getId();
    }
 
    protected function loadShipment()
    {
        $result = new Result;
        if (!$this->isOrderExists())
            return $result;
        if (!$this->isShipmentExists())
        {
            $loadDelivery = false;
            $order = $this->getOrder();
            $orderShipmentList = $order->getShipmentCollection();
            if ($this->isOrderNew())
            {
                foreach ($orderShipmentList as $shipment)
                {
                    if ($shipment->isSystem())
                        continue;
 
                    if (!$loadDelivery)
                    {
                        $this->shipment = $shipment;
                        $loadDelivery = true;
                        break;
                    }
                }
            }
            else
            {
                $shipmentId = false;
                foreach ($orderShipmentList as $shipment)
                {
                    if ($shipment->isSystem())
                        continue;
 
                    $currentShipmentId = (int)$shipment->getId();
                    if ($shipmentId === false || $shipmentId > $currentShipmentId)
                        $shipmentId = $currentShipmentId;
                }
                unset($currentShipmentId, $shipment);
                if (!empty($shipmentId))
                {
                    $this->shipment = $orderShipmentList->getItemById($shipmentId);
                    $loadDelivery = true;
                }
                unset($shipmentId);
            }
            unset($loadDelivery);
        }
        return $result;
    }
 
    protected function initInstanceFromOrder()
    {
        parent::initInstanceFromOrder();
        $this->loadShipment();
        $this->fillShipmentData();
    }
 
    /* entities id tools */
 
    protected function getEntitySaveIdentifier(array $entity)
    {
        $result = null;
 
        switch ($entity['ENTITY_TYPE'])
        {
            case self::ENTITY_DELIVERY:
                $result = [
                    'ENTITY_TYPE' => self::ENTITY_DELIVERY,
                    'ENTITY_ID' => (int)$entity['ENTITY_CODE'],
                    'ENTITY_VALUE' => (string)$entity['ENTITY_CODE']
                ];
                break;
            default:
                $result = parent::getEntitySaveIdentifier($entity);
                break;
        }
 
        return $result;
    }
 
    /* entities id tools finish */
 
    /* compatibility tools */
    private function isUsedDiscountCompatibility()
    {
        return (Compatible\DiscountCompatibility::isUsed() && Compatible\DiscountCompatibility::isInited());
    }
 
    protected function fillCompatibleOrderFields()
    {
        $this->orderData['USE_BASE_PRICE'] = $this->saleOptions['USE_BASE_PRICE'];
    }
 
    /* compatibility tools finish */
 
    /* deprecated methods */
 
    public function setBasketItemBasePrice($code, $price, $currency) {}
 
    public function setBasketBasePrice($basket) {}
 
    public function getBasketItemBasePrice($code)
    {
        return (isset($this->orderData[$code]) ? $this->orderData[$code]['BASE_PRICE'] : null);
    }
 
    public function setBasketItemDiscounts($code, $discountList) {}
 
    public function setBasketItemData($code, $providerData) {}
 
    public function clearBasketItemData($code) {}
 
    public static function loadByBasket(Basket $basket)
    {
        $order = $basket->getOrder();
        if ($order instanceof Order)
            return static::buildFromOrder($order);
 
        return self::buildFromBasket($basket, new Context\Fuser($basket->getFUserId(true)));
    }
 
    public static function load(Order $order)
    {
        return static::buildFromOrder($order);
    }
 
    public function saveExternalLastApplyblock(BasketItem $basketItem, $orderDiscountId)
    {
        $basket = $basketItem->getCollection();
        $this->order = $basket->getOrder();
 
        $this->loadOrderData();
 
        $listItems[$basketItem->getBasketCode()] = array('APPLY'=>'Y', 'ACTION_BLOCK_LIST'=>array(), 'DESCR_DATA'=>array(), 'DESCR'=>array());
 
        $this->discountsCache[$orderDiscountId]['MODULE_ID'] = 'sale';
        $applyBlock = &$this->discountResult['APPLY_BLOCKS'][$this->discountResultCounter];
        $applyBlock['ORDER'][] = array(
            'DISCOUNT_ID' => $orderDiscountId,
            'COUPON_ID' => 0,
            'RESULT' => array('BASKET' => $listItems)
        );
 
        $this->saveLastApplyBlock();
    }
 
    protected function getBasketCurrency($basketCode)
    {
        return $this->getCurrency();
    }
 
    /* deprecated methods finish */
}