smsmanager.php

См. документацию.

<?php
namespace Bitrix\MessageService\Sender;
 
use Bitrix\Main;
use Bitrix\Main\Event;
use Bitrix\Main\EventResult;
use Bitrix\Main\Result;
use Bitrix\MessageService\Internal\Entity\MessageTable;
use Bitrix\MessageService\Message;
use Bitrix\MessageService\MessageType;
use Bitrix\Main\ORM\Data\AddResult;
use Bitrix\MessageService\Sender\Result\SendMessage;
 
class SmsManager
{
    public const ON_MESSAGE_SUCCESSFULLY_SENT_EVENT = 'OnMessageSuccessfullySent';
 
    private static $senders;

    public static function getSenders()
    {
        if (self::$senders === null)
        {
            self::$senders = [];
 
            if (Sms\Twilio::isSupported())
            {
                self::$senders[] = new Sms\Twilio();
            }
            if (Sms\Twilio2::isSupported())
            {
                self::$senders[] = new Sms\Twilio2();
            }
            if (Sms\SmsLineBy::isSupported())
            {
                self::$senders[] = new Sms\SmsLineBy();
            }
            if (Sms\MfmsRu::isSupported())
            {
                self::$senders[] = new Sms\MfmsRu();
            }
            if (Sms\Rest::isSupported())
            {
                self::$senders[] = new Sms\Rest();
            }
            if (Sms\SmscUa::isSupported())
            {
                self::$senders[] = new Sms\SmscUa();
            }
            if (Sms\ISmsCenter::isSupported())
            {
                self::$senders[] = new Sms\ISmsCenter();
            }
 
            $sender = new Sms\SmsRu();
            if (Sms\SmsRu::isSupported() || $sender->isRegistered())
            {
                self::$senders[] = $sender;
            }
 
            $sender = new Sms\SmsAssistentBy();
            if (Sms\SmsAssistentBy::isSupported() || $sender->isRegistered())
            {
                self::$senders[] = $sender;
            }
 
            $sender = new Sms\SmsEdnaru();
            if (Sms\SmsEdnaru::isSupported() || $sender->isRegistered())
            {
                self::$senders[] = $sender;
            }
 
            $sender = new Sms\Ednaru();
            if (Sms\Ednaru::isSupported() || $sender->isRegistered())
            {
                self::$senders[] = $sender;
            }
 
            $sender = new Sms\EdnaruImHpx();
            if (Sms\EdnaruImHpx::isSupported() || $sender->isRegistered())
            {
                self::$senders[] = $sender;
            }
 
            self::fireSendersEvent();
        }
        return self::$senders;
    }
 
    private static function fireSendersEvent()
    {
        $event = new Event('messageservice', 'onGetSmsSenders');
        $event->send();
        foreach ($event->getResults() as $result)
        {
            if ($result->getType() === EventResult::ERROR)
            {
                continue;
            }
            $resultData = $result->getParameters();
            if (is_array($resultData))
            {
                foreach ($resultData as $sender)
                {
                    if (
                        $sender instanceof Base
                        && $sender->getType() === MessageType::SMS
                        && $sender::isSupported()
                    )
                    {
                        self::$senders[] = $sender;
                    }
                }
            }
        }
    }

    public static function getSenderSelectList()
    {
        $select = array();
        foreach (static::getSenders() as $sender)
        {
            $select[$sender->getId()] = $sender->getName();
        }
        return $select;
    }

    public static function getSenderInfoList()
    {
        $info = array();
        foreach (static::getSenders() as $sender)
        {
            $info[] = array(
                'id' => $sender->getId(),
                'type' => $sender->getType(),
                'isTemplatesBased' => ($sender->isConfigurable() && $sender->isTemplatesBased()),
                'name' => $sender->getName(),
                'shortName' => $sender->getShortName(),
                'canUse' => $sender->canUse()
            );
        }
        return $info;
    }

    public static function getSenderById($id)
    {
        foreach (static::getSenders() as $sender)
        {
            if ($sender->getId() === $id)
            {
                return $sender;
            }
        }
        return null;
    }

    public static function getDefaultSender()
    {
        $region = \Bitrix\Main\Application::getInstance()->getLicense()->getRegion();
 
        if ($region === 'ru')
        {
            return static::getSenderById(\Bitrix\MessageService\Sender\Sms\SmsRu::ID);
        }
        if ($region === 'by')
        {
            return static::getSenderById(\Bitrix\MessageService\Sender\Sms\SmsAssistentBy::ID);
        }
 
        return static::getSenders()[0];
    }

    public static function canUse()
    {
        return static::getUsableSender() !== null;
    }

    public static function getManageUrl()
    {
        $defaultProvider = static::getDefaultSender();
        return $defaultProvider instanceof BaseConfigurable ? $defaultProvider->getManageUrl() : '';
    }

    public static function getUsableSender()
    {
        foreach (static::getSenders() as $sender)
        {
            if ($sender->canUse())
            {
                return $sender;
            }
        }
        return null;
    }

    public static function getRegisteredSenderList(): array
    {
        $senderList = [];
        foreach (static::getSenders() as $sender)
        {
            if (
                $sender instanceof BaseConfigurable
                && $sender->isRegistered()
            )
            {
                $senderList[] = $sender;
            }
        }
 
        return $senderList;
    }

    public static function createMessage(array $messageFields, Base $sender = null)
    {
        if (!$sender && !isset($messageFields['SENDER_ID']))
        {
            $sender = static::getUsableSender();
        }
 
        if ($sender === null)
        {
            $message = new Message($sender);
            $message->setError(new Main\Error('There are no registered SMS providers.'));
        }
 
        if (isset($messageFields['MESSAGE_TO']))
        {
            $normalizedTo = \NormalizePhone($messageFields['MESSAGE_TO']);
            if ($normalizedTo)
            {
                $messageFields['MESSAGE_TO'] = '+'.$normalizedTo;
            }
        }
 
        $message = Message::createFromFields($messageFields, $sender);
        $message->setType(MessageType::SMS);
 
        $sender = $message->getSender();
        if ($sender && !$message->getFrom())
        {
            $message->setFrom($sender->getDefaultFrom());
        }
 
        return $message;
    }

    public static function createMessageListByTemplate(string $eventName, array $fields = []): array
    {
        $messageList = [];
        $event = new Main\Sms\Event($eventName, $fields);
        $templateMessageListResult = $event->createMessageList();
        if (!$templateMessageListResult->isSuccess())
        {
            return $messageList;
        }
 
        $templateMessages = $templateMessageListResult->getData();
        $sender = isset($fields['SENDER_ID']) ? static::getSenderById($fields['SENDER_ID']) : static::getUsableSender();

        foreach($templateMessages as $templateMessage)
        {
            $message = Message::createFromFields(
                [
                    'MESSAGE_FROM' => $fields['DEFAULT_FROM'] ?? $sender->getDefaultFrom(),
                    'MESSAGE_TO' => $templateMessage->getReceiver(),
                    'MESSAGE_BODY' => $templateMessage->getText(),
                ],
                $sender
            );
            $message->setType(MessageType::SMS);
            $messageList[] = $message;
        }
 
        return $messageList;
    }

    public static function sendMessage(array $messageFields, Base $sender = null)
    {
        if (!$sender && isset($messageFields['SENDER_ID']))
        {
            $sender = static::getSenderById($messageFields['SENDER_ID']);
 
            if ($sender === null)
            {
                return (new Result())->addError(new Main\Error('Incorrect sender id.'));
            }
        }
        $message = static::createMessage($messageFields, $sender);
 
        if ($message->getError() !== null)
        {
            return (new Result())->addError($message->getError());
        }
 
        $result = $message->send();
 
        if ($result->isSuccess())
        {
            (new Event(
                'messageservice',
                static::ON_MESSAGE_SUCCESSFULLY_SENT_EVENT,
                [
                    'ID' => $result->getId(),
                    'ADDITIONAL_FIELDS' => $messageFields['ADDITIONAL_FIELDS'] ?? [],
                ]
            ))->send();
        }
 
        return $result;
    }

    public static function sendMessageDirectly(array $messageFields, Base $sender = null)
    {
        $message = static::createMessage($messageFields, $sender);
 
        return $message->sendDirectly();
    }
 
    public static function getMessageStatus($messageId)
    {
        $message = MessageTable::getById($messageId)->fetch();
        if (!$message)
        {
            $result = new Result\MessageStatus();
            $result->setId($messageId);
            $result->addError(new Main\Error('Message not found'));
 
            return $result;
        }

        $sender = static::getSenderById($message['SENDER_ID']);
        if (!$sender || !$sender->isConfigurable())
        {
            $result = new Result\MessageStatus();
            $result->setId($messageId);
            $result->addError(new Main\Error('Incorrect sender id.'));
 
            return $result;
        }
 
        return $sender->getMessageStatus($message);
    }
}