userbudgetpool.php

<?php
namespace Bitrix\Sale\Internals;
 
use Bitrix\Main\Localization\Loc;
use Bitrix\Sale;
use Bitrix\Main;
 
Loc::loadMessages(__FILE__);
 
class UserBudgetPool
{
    private const STATUS_LOCKED_NOW = 1;
    private const STATUS_LOCKED_EARLIER = -1;
    private const STATUS_NOT_LOCKED = 0;
 
    private $statusLock = self::STATUS_NOT_LOCKED;
    private $userId;
 
    protected static $userBudgetPool = [];
 
    protected $items = [];
 
    const BUDGET_TYPE_ORDER_CANCEL_PART = 'ORDER_CANCEL_PART';
    const BUDGET_TYPE_ORDER_UNPAY = 'ORDER_UNPAY';
    const BUDGET_TYPE_ORDER_PART_RETURN = 'ORDER_PART_RETURN';
    const BUDGET_TYPE_OUT_CHARGE_OFF = 'OUT_CHARGE_OFF';
    const BUDGET_TYPE_EXCESS_SUM_PAID = 'EXCESS_SUM_PAID';
    const BUDGET_TYPE_MANUAL = 'MANUAL';
    const BUDGET_TYPE_ORDER_PAY = 'ORDER_PAY';
    const BUDGET_TYPE_ORDER_PAY_PART = 'ORDER_PAY_PART';
 
    protected function __construct($userId)
    {
        $this->userId = $userId;
    }
 
    public function add($sum, $budgetType, Sale\Order $order, Sale\Payment $payment = null)
    {
        if (!$this->isLocked())
        {
            $this->lock();
        }
 
        if ($this->isStatusLockEarlier())
        {
            return;
        }
 
        $fields = [
            "SUM" => $sum,
            "CURRENCY" => $order->getCurrency(),
            "TYPE" => $budgetType,
            "ORDER" => $order,
        ];
 
        if ($payment !== null)
        {
            $fields['PAYMENT'] = $payment;
        }
 
        $this->items[] = $fields;
 
    }
 
    protected function lock()
    {
        if ($this->statusLock === self::STATUS_NOT_LOCKED)
        {
            $connection = Main\Application::getConnection();
            $name = $connection->getSqlHelper()->forSql($this->getUniqLockName());
            $dbRes = $connection->query("SELECT GET_LOCK('{$name}', 0) as L");
            $result = $dbRes->fetch();
            if ($result['L'] === '0')
            {
                $this->statusLock = self::STATUS_LOCKED_EARLIER;
 
                return;
            }
 
            $this->statusLock = self::STATUS_LOCKED_NOW;
        }
    }
 
    private function getUniqLockName() : string
    {
        return "user_budget_{$this->userId}";
    }
 
    protected function unlock()
    {
        if ($this->statusLock === self::STATUS_LOCKED_NOW)
        {
            $connection = Main\Application::getConnection();
            $name = $connection->getSqlHelper()->forSql($this->getUniqLockName());
            $connection->query("SELECT RELEASE_LOCK('{$name}')");
 
            $this->statusLock = self::STATUS_NOT_LOCKED;
        }
    }
 
    protected function isLocked()
    {
        return
            $this->statusLock === self::STATUS_LOCKED_EARLIER
            || $this->statusLock === self::STATUS_LOCKED_NOW
        ;
    }
 
    protected function isStatusLockEarlier()
    {
        return $this->statusLock === self::STATUS_LOCKED_EARLIER;
    }
 
    public function get()
    {
        if (isset($this->items))
        {
            return $this->items;
        }
 
        return false;
    }
 
    public function delete($index)
    {
        if (isset($this->items) && isset($this->items[$index]))
        {
            unset($this->items[$index]);
            if (count($this->items) === 0)
            {
                $this->unlock();
            }
 
            return true;
        }
 
        return false;
    }
 
    public static function getUserBudgetPool($userId)
    {
        if (!isset(static::$userBudgetPool[$userId]))
        {
            static::$userBudgetPool[$userId] = new static($userId);
        }
 
        return static::$userBudgetPool[$userId];
    }
 
    public static function addPoolItem(Sale\Order $order, $value, $type, Sale\Payment $payment = null)
    {
        if (floatval($value) == 0)
            return;
 
        $userId = $order->getUserId();
        $pool = static::getUserBudgetPool($userId);
        $pool->add($value, $type, $order, $payment);
    }
 
    public static function onUserBudgetSave($userId)
    {
        $result = new Sale\Result();
 
        $pool = static::getUserBudgetPool($userId);
 
        if ($pool->isStatusLockEarlier())
        {
            return $result->addError(
                new Sale\ResultError(
                    Loc::getMessage('SALE_PROVIDER_USER_BUDGET_LOCKED')
                )
            );
        }
 
        foreach ($pool->get() as $key => $budgetDat)
        {
            $orderId = null;
            $paymentId = null;
 
            if (isset($budgetDat['ORDER'])
                && ($budgetDat['ORDER'] instanceof Sale\OrderBase))
            {
                $orderId = $budgetDat['ORDER']->getId();
            }
 
            if (isset($budgetDat['PAYMENT'])
                && ($budgetDat['PAYMENT'] instanceof Sale\Payment))
            {
                $paymentId = $budgetDat['PAYMENT']->getId();
            }
 
            if (!\CSaleUserAccount::UpdateAccount($userId, $budgetDat['SUM'], $budgetDat['CURRENCY'], $budgetDat['TYPE'], $orderId, '', $paymentId))
            {
                $result->addError( new Sale\ResultError(Loc::getMessage("SALE_PROVIDER_USER_BUDGET_".$budgetDat['TYPE']."_ERROR"), "SALE_PROVIDER_USER_BUDGET_".$budgetDat['TYPE']."_ERROR") );
            }
 
            $pool->delete($key);
        }
 
        return $result;
    }
 
    public static function getUserBudgetTransForOrder(Sale\Order $order)
    {
        $ignoreTypes = array(
            static::BUDGET_TYPE_ORDER_PAY
        );
        $sumTrans = 0;
 
        if ($order->getId() > 0)
        {
            $resTrans = \CSaleUserTransact::GetList(
                array("TRANSACT_DATE" => "DESC"),
                array(
                    "ORDER_ID" => $order->getId(),
                ),
                false,
                false,
                array("AMOUNT", "CURRENCY", "DEBIT")
            );
            while ($transactDat = $resTrans->Fetch())
            {
                if ($transactDat['DEBIT'] == "Y")
                {
                    $sumTrans += $transactDat['AMOUNT'];
                }
                else
                {
                    $sumTrans -= $transactDat['AMOUNT'];
                }
            }
        }
 
        if ($userBudgetPool = static::getUserBudgetPool($order->getUserId()))
        {
            foreach ($userBudgetPool->get() as $userBudgetDat)
            {
                if (in_array($userBudgetDat['TYPE'], $ignoreTypes))
                    continue;
 
                $sumTrans += $userBudgetDat['SUM'];
            }
        }
 
        return $sumTrans;
    }
 
    public static function getUserBudgetByOrder(Sale\Order $order)
    {
        $budget = static::getUserBudget($order->getUserId(), $order->getCurrency());
        if ($userBudgetPool = static::getUserBudgetPool($order->getUserId()))
        {
            foreach ($userBudgetPool->get() as $userBudgetDat)
            {
                $budget += $userBudgetDat['SUM'];
            }
        }
 
        return $budget;
    }
 
    public static function getUserBudget($userId, $currency)
    {
        $budget = null;
        if ($userAccount = \CSaleUserAccount::GetByUserId($userId, $currency))
        {
            if ($userAccount['LOCKED'] != 'Y')
                $budget = floatval($userAccount['CURRENT_BUDGET']);
        }
 
        return $budget;
    }
 
    public function __destruct()
    {
        $this->unlock();
    }
}