adapter.php

<?php
namespace Bitrix\Sender\Transport;
 
use Bitrix\Main\ArgumentException;
use Bitrix\Sender\Consent\AbstractConsentMessageBuilder;
use Bitrix\Sender\Consent\ConsentMessageBuilderFactory as ConsentFactory;
use Bitrix\Sender\Message;
 
class Adapter implements iBase, iLimitation
{
    protected $transport;
 
    protected static $list;
 
    protected $startResult = null;
 
 
    protected $isStarted = false;
 
    protected $isEnded = false;
 
    protected $limiters = null;
 
    protected $sendCount = 0;
 
    public static function getInstance($code)
    {
        return isset(self::$list[$code]) ? self::$list[$code] : self::create($code);
    }
 
    public static function create($code)
    {
        $transport = Factory::getTransport($code);
        if (!$transport)
        {
            throw new ArgumentException($code);
        }
 
        return new static($transport);
    }
 
    public function __construct(iBase $transport)
    {
        $this->transport = $transport;
    }
 
    public function getName()
    {
        return $this->transport->getName();
    }
 
    public function getCode()
    {
        return $this->transport->getCode();
    }
 
    public function getSupportedRecipientTypes()
    {
        return $this->transport->getSupportedRecipientTypes();
    }
 
    public function setSendCount($sendCount)
    {
        $this->sendCount = $sendCount;
        return $this;
    }
 
    public function getSendCount()
    {
        return $this->sendCount;
    }
 
    public function loadConfiguration()
    {
        return $this->transport->loadConfiguration();
    }
 
    public function saveConfiguration(Message\Configuration $configuration)
    {
        $this->transport->saveConfiguration($configuration);
    }
    public function getConsentMaxRequests()
    {
        if($this->isConsentSupported())
        {
            return $this->transport->getConsentMaxRequests();
        }
        return null;
    }
    public function start()
    {
        if ($this->startResult !== null)
        {
            return $this->startResult;
        }
 
        $startResult = $this->transport->start();
        if ($startResult === null)
        {
            $startResult = true;
        }
        $this->startResult = $startResult;
 
        return $this->startResult;
    }
 
    public function send(Message\Adapter $message)
    {
        if (!$this->isStarted && $this->getSendCount())
        {
            \Bitrix\Sender\Log::stat('sending_started', $this->transport->getCode(), $message->getId());
        }
        $this->start();
        $this->isStarted = true;
 
        $result = $this->transport->send($message);
        \Bitrix\Sender\Log::stat('item_sent', $message->getId(), $result ? 'Y' : 'N');
        return $result;
    }
    public function end()
    {
        if ($this->isEnded)
        {
            return;
        }
 
        $this->transport->end();
        $this->isEnded = true;
    }
 
    public function __destroy()
    {
        $this->end();
    }
 
    public function getDuration($message = null)
    {
        if (!($this->transport instanceof iDuration))
        {
            return 0;
        }
 
        return $this->transport->getDuration($message);
    }
 
    public function isConsentAvailable()
    {
        return $this->isConsentSupported();
    }
 
    public function isConsentSupported()
    {
        return  $this->transport instanceof iConsent;
    }
 
    public function sendConsent($message, $data) : ?bool
    {
        if(!$this->isConsentAvailable())
        {
            return false;
        }
 
        $builder = ConsentFactory::getConsentBuilder($this->transport::CODE)->setFields($data);
        return $this->sendConsentByBuilder($message, $builder);
    }
 
    public function sendTestConsent($message, $data): bool
    {
        if(!$this->isConsentSupported())
        {
            return false;
        }
        $builder = ConsentFactory::getTestMessageConsentBuilder($this->transport::CODE)->setFields($data);
        return $this->sendConsentByBuilder($message, $builder);
    }
 
    protected function sendConsentByBuilder(Message\Adapter $message,  AbstractConsentMessageBuilder $builder): bool
    {
        return $builder? $this->transport->sendConsent($message, $builder) : false;
    }
    public function hasLimiters()
    {
        return count($this->getLimiters()) > 0;
    }
 
    public function getLimiters(Message\iBase $message = null)
    {
        if ($this->limiters === null)
        {
            if (!($this->transport instanceof iLimitation))
            {
                $this->limiters = array();
            }
            else
            {
                $this->limiters = $this->transport->getLimiters($message);
            }
        }
 
        return $this->limiters;
    }
 
    public function isLimitsExceeded(Message\iBase $message = null)
    {
        foreach ($this->getLimiters($message) as $limiter)
        {
            if ($limiter->getCurrent() < $limiter->getLimit())
            {
                continue;
            }
 
            return true;
        }
 
        return false;
    }
 
    public function getExceededLimiter(Message\iBase $message = null)
    {
        foreach ($this->getLimiters($message) as $limiter)
        {
            if ($limiter->getCurrent() < $limiter->getLimit())
            {
                continue;
            }
 
            return $limiter;
        }
 
        return null;
    }
}