countlimiter.php

<?php
namespace Bitrix\Sender\Transport;
 
use Bitrix\Main\ArgumentException;
use Bitrix\Main\Config\Option;
use Bitrix\Main\SystemException;
use Bitrix\Main\Type\DateTime;
use Bitrix\Main\Localization\Loc;
 
Loc::loadMessages(__FILE__);
 
class CountLimiter implements iLimiter
{
    private $name;
 
    private $caption;
 
    private $parameters = array();
 
    private $limit;
 
    private $current;
 
    private $interval;
 
    private $unit;
 
    private $unitName;
 
    private $hidden = false;
 
    public static function create()
    {
        return new static();
    }
 
    private static function parseUnit($unit)
    {
        $unit = explode(' ', $unit);
        $num = (int) $unit[0];
        $unit = $unit[1] ?? '';
 
        return array(
            'num' => $num,
            'unit' => $unit
        );
    }
 
    public static function getUnitInterval($unit)
    {
        $parsed = self::parseUnit($unit);
 
        switch ($parsed['unit'])
        {
            case iLimiter::MINUTES:
                $interval = 60;
                break;
 
            case iLimiter::HOURS:
                $interval = 3600;
                break;
 
            case iLimiter::MONTHS:
                $interval = 86400 * 31;
                break;
 
            case iLimiter::DAYS:
            default:
                $interval = 86400;
                break;
        }
 
        return $interval * $parsed['num'];
    }
 
    public function __construct()
    {
    }
 
    public function withName($name)
    {
        $this->name = $name;
        return $this;
    }
 
    public function withCaption($caption)
    {
        $this->caption = $caption;
        return $this;
    }
 
    public function withLimit($limit)
    {
        $this->limit = (int) $limit;
        return $this;
    }
 
    public function withInterval($interval)
    {
        $this->interval = (int) $interval;
        return $this;
    }
 
    public function withUnit($unit)
    {
        $this->unit = $unit;
        $this->interval = self::getUnitInterval($unit);
        return $this;
    }
 
    public function withUnitName($unitName)
    {
        $this->unitName = $unitName;
        return $this;
    }
 
    public function withCurrent($callable)
    {
        if (!is_callable($callable))
        {
            throw new ArgumentException('Wrong type of parameter \'callable\'.');
        }
 
        $this->current = $callable;
        return $this;
    }
 
    public function getInitialLimit()
    {
        return $this->limit;
    }
 
    public function getLimit()
    {
        $limit = (int) $this->limit;
        $percentage = (int) $this->getParameter('percentage');
        if ($percentage > 0 && $percentage <= 100)
        {
            $limit *= $percentage / 100;
        }
 
        return $limit;
    }
 
    public function getUnit()
    {
        return $this->unit;
    }
 
    public function getUnitName()
    {
        if ($this->unitName)
        {
            return $this->unitName;
        }
 
        $parsed = self::parseUnit($this->unit);
        switch ($parsed['unit'])
        {
            case iLimiter::MINUTES:
                $format = 'idiff';
                break;
 
            case iLimiter::HOURS:
                $format = 'Hdiff';
                break;
 
            case iLimiter::MONTHS:
                $format = 'mdiff';
                break;
 
            case iLimiter::DAYS:
            default:
                $format = 'ddiff';
                break;
        }
 
 
        $formatted = \FormatDate($format, $this->getCurrentTimestamp() - $this->interval);
        if (mb_substr($formatted, 0, 2) == '1 ')
        {
            $formatted = mb_substr($formatted, 2);
        }
 
        return Loc::getMessage('SENDER_TRANSPORT_COUNT_LIMIT_UNIT_DATE_AT') . ' ' . $formatted;
    }
 
    public function getCaption()
    {
        return $this->caption;
    }
 
    public function getName()
    {
        return $this->name;
    }
 
    public function getText()
    {
        return Loc::getMessage(
            'SENDER_TRANSPORT_COUNT_LIMIT_TEXT_MONTHLY',
            [
                '%current%' => number_format($this->getAvailable(), 0, '.', ' '),
                '%limit%' => number_format($this->getLimit(), 0, '.', ' '),
                '%setupUri%' => $this->getParameter('setupUri'),
                '%setupCaption%' => $this->getParameter('setupCaption'),
            ]
        );
    }
 
    public function getParameter($name)
    {
        return isset($this->parameters[$name]) ? $this->parameters[$name] : null;
    }
 
    public function setParameter($name, $value)
    {
        $this->parameters[$name] = $value;
        return $this;
    }
 
    public function inc($amount = 1)
    {
        if ($this->getTimestamp())
        {
            $isNewPeriod = ($this->getCurrentTimestamp() - $this->getTimestamp()) >= $this->interval;
        }
        else
        {
            $isNewPeriod = true;
        }
 
 
        if ($isNewPeriod)
        {
            $this->setCurrent(0);
            $this->setTimestamp($this->getCurrentTimestamp());
        }
 
        $current = $this->getCurrent() + $amount;
        if ($current >= $this->getLimit())
        {
            throw new SystemException(Loc::getMessage(
                'SENDER_TRANSPORT_COUNT_LIMIT_EXCEEDED',
                array('%limit%' => $this->getLimit(), '%unit%' => $this->getUnitName())
            ));
        }
 
        if (!$isNewPeriod)
        {
            $this->setCurrent($current);
        }
 
        return $this;
    }
 
    public function getAvailable()
    {
        $available = $this->getLimit() - $this->getCurrent();
        return (!$available || $available < 0) ? 0 : $available;
    }
 
    public function getCurrent()
    {
        if (is_callable($this->current))
        {
            return call_user_func($this->current);
        }
 
        return (int) Option::get('main', $this->getCounterOptionName(), 0);
    }
 
    private function setCurrent($value)
    {
        Option::set('main', $this->getCounterOptionName(), $value);
        return $this;
    }
 
    private function setTimestamp($value)
    {
        Option::set('main', $this->getDateOptionName(), $value);
        return $this;
    }
 
    public function getTimestamp()
    {
        return (int) Option::get('main', $this->getDateOptionName(), 0);
    }
 
    private function getCurrentTimestamp()
    {
        $dateTime = new DateTime();
        return $dateTime->getTimestamp();
    }
 
    private function getCounterOptionName()
    {
        return "~sender_limit_count_" . $this->name;
    }
 
    private function getDateOptionName()
    {
        return "~sender_limit_date_" . $this->name;
    }
 
    public function setHidden(bool $hidden): CountLimiter
    {
        $this->hidden = $hidden;
        return $this;
    }
    public function isHidden()
    {
        return $this->hidden;
    }
}