price.php

<?php
namespace Bitrix\Catalog\Product;
 
use Bitrix\Main,
    Bitrix\Catalog;
class Price
{
    /* cache id template */
    const CACHE_ID = 'catalog_price_round_';
    /* cache time */
    const CACHE_TIME = 360000;
    /* maximal precision */
    const VALUE_EPS = 1E-6;
 
    /* static cache */
    protected static $roundRules = array();
 
    public static function handlerAfterUpdateCurrencyBaseRate(Main\Event $event)
    {
        $params = $event->getParameters();
        if (empty($params))
            return;
 
        $oldBaseRate = (float)$params['OLD_BASE_RATE'];
        if ($oldBaseRate < 1E-4)
            return;
        $currentBaseRate = (float)$params['CURRENT_BASE_RATE'];
        if (abs($currentBaseRate - $oldBaseRate)/$oldBaseRate < 1E-4)
            return;
        $currency = $params['CURRENCY'];
 
        $conn = Main\Application::getConnection();
        $helper = $conn->getSqlHelper();
 
        $query = 'update '.$helper->quote(Catalog\PriceTable::getTableName()).
            ' set '.$helper->quote('PRICE_SCALE').' = '.$helper->quote('PRICE').' * '.$currentBaseRate.
            ' where '.$helper->quote('CURRENCY').' = \''.$helper->forSql($currency).'\'';
        $conn->queryExecute($query);
 
        if (defined('BX_COMP_MANAGED_CACHE'))
        {
            $taggedCache = Main\Application::getInstance()->getTaggedCache();
            $taggedCache->clearByTag('currency_id_'.$currency);
        }
    }
 
    public static function loadRoundRules(array $priceTypes)
    {
        if (empty($priceTypes))
            return;
        Main\Type\Collection::normalizeArrayValuesByInt($priceTypes);
        if (empty($priceTypes))
            return;
 
        $skipCache = (defined('CATALOG_SKIP_CACHE') && CATALOG_SKIP_CACHE);
        $cacheTime = (int)self::CACHE_TIME;
        $managedCache = Main\Application::getInstance()->getManagedCache();
 
        $needLoad = array();
        foreach ($priceTypes as $priceTypeId)
        {
            if (!isset(self::$roundRules[$priceTypeId]))
            {
                $rulesFound = false;
                $cacheId = static::getRulesCacheId($priceTypeId);
                if (!$skipCache)
                {
                    $cacheExist = $managedCache->read($cacheTime, $cacheId, Catalog\RoundingTable::getTableName());
                    if ($cacheExist)
                    {
                        $rulesFound = true;
                        self::$roundRules[$priceTypeId] = $managedCache->get($cacheId);
                    }
                }
                if ($skipCache || !$rulesFound)
                    $needLoad[] = $priceTypeId;
                unset($cacheId, $rulesFound);
            }
        }
        unset($priceTypeId);
 
        if (!empty($needLoad))
        {
            foreach ($needLoad as $priceTypeId)
                self::$roundRules[$priceTypeId] = array();
            unset($priceTypeId);
            $iterator = Catalog\RoundingTable::getList(array(
                'select' => array('PRICE', 'ROUND_TYPE', 'ROUND_PRECISION', 'CATALOG_GROUP_ID'),
                'filter' => array('@CATALOG_GROUP_ID' => $needLoad),
                'order' => array('CATALOG_GROUP_ID' => 'ASC', 'PRICE' => 'DESC')
            ));
            while ($row = $iterator->fetch())
            {
                $priceTypeId = (int)$row['CATALOG_GROUP_ID'];
                self::$roundRules[$priceTypeId][] = $row;
                unset($priceTypeId);
            }
            unset($row, $iterator);
 
            if (!$skipCache)
            {
                foreach ($needLoad as $priceTypeId)
                    $managedCache->set(static::getRulesCacheId($priceTypeId), self::$roundRules[$priceTypeId]);
                unset($priceType);
            }
        }
        unset($needLoad);
        unset($managedCache, $cacheTime, $skipCache);
    }
 
    public static function getRoundRules($priceType)
    {
        $priceType = (int)$priceType;
        if ($priceType <= 0)
            return array();
        if (!isset(self::$roundRules[$priceType]))
            static::loadRoundRules(array($priceType));
 
        return self::$roundRules[$priceType];
    }
 
    public static function clearRoundRulesCache($priceType)
    {
        $priceType = (int)$priceType;
        if ($priceType <= 0)
            return;
        if (isset(self::$roundRules[$priceType]))
            unset(self::$roundRules[$priceType]);
        Main\Application::getInstance()->getManagedCache()->clean(
            static::getRulesCacheId($priceType),
            Catalog\RoundingTable::getTableName()
        );
    }
 
    public static function searchRoundRule(
        $priceType,
        $price,
 $currency = ''
    )
    {
        $rules = static::getRoundRules($priceType);
        if (empty($rules))
            return array();
        foreach ($rules as $row)
        {
            if ($row['PRICE'] < $price)
                return $row;
        }
        return array();
    }
 
    public static function roundPrice($priceType, $price, $currency)
    {
        $price = (float)$price;
        if ($price <= 0)
            return $price;
        $priceType = (int)$priceType;
        if ($priceType <= 0)
            return $price;
        $rule = static::searchRoundRule($priceType, $price, $currency);
        if (empty($rule))
            return $price;
        return static::roundValue($price, $rule['ROUND_PRECISION'], $rule['ROUND_TYPE']);
    }
 
    public static function roundValue($value, $precision, $type)
    {
        $type = (int)$type;
        if (!in_array($type, Catalog\RoundingTable::getRoundTypes(false)))
            return $value;
 
        $precision = (float)$precision;
        if ($precision <= 0)
            return 0;
        if ($precision >= 1)
            $precision = (int)$precision;
 
        $value = (float)$value;
        if (abs($value) <= self::VALUE_EPS)
            return 0;
 
        return ($precision < 1
            ? static::roundFraction($value, $precision, $type)
            : static::roundWhole($value, $precision, $type)
        );
    }
 
    protected static function getRulesCacheId($priceType)
    {
        return self::CACHE_ID.$priceType;
    }
 
    protected static function roundWhole($value, $precision, $type)
    {
        $quotient = $value/$precision;
        $quotientFloor = floor($quotient);
        switch ($type)
        {
            case Catalog\RoundingTable::ROUND_UP:
                if (($quotient - $quotientFloor) > self::VALUE_EPS)
                    $quotientFloor += 1;
                break;
            case Catalog\RoundingTable::ROUND_DOWN:
                if ($quotientFloor < floor(($value + self::VALUE_EPS)/$precision))
                    $quotientFloor += 1;
                break;
            case Catalog\RoundingTable::ROUND_MATH:
            default:
                if (($quotient - $quotientFloor + self::VALUE_EPS) >= .5)
                    $quotientFloor += 1;
                break;
        }
 
        return $quotientFloor*$precision;
    }
 
    protected static function roundFraction($value, $precision, $type)
    {
        $valueFloor = floor($value);
        $fraction = $value - $valueFloor;
        if ($fraction <= self::VALUE_EPS)
            return $value;
 
        return $valueFloor + static::roundWhole($fraction, $precision, $type);
    }
}