twilio.php

<?php
namespace Bitrix\MessageService\Sender\Sms;
 
use Bitrix\Main\Application;
use Bitrix\Main\ArgumentException;
use Bitrix\Main\Config\Option;
use Bitrix\Main\Error;
use Bitrix\Main\ErrorCollection;
use Bitrix\Main\Event;
use Bitrix\Main\EventResult;
use Bitrix\Main\Localization\Loc;
use Bitrix\Main\Result;
use Bitrix\Main\Web\HttpClient;
use Bitrix\Main\Web\Json;
 
use Bitrix\MessageService;
use Bitrix\MessageService\Providers\Twilio\ErrorInformant;
use Bitrix\MessageService\Sender;
use Bitrix\MessageService\Sender\Result\MessageStatus;
use Bitrix\MessageService\Sender\Result\SendMessage;
 
Loc::loadMessages(__FILE__);
 
class Twilio extends Sender\BaseConfigurable
{
    public const ID = 'twilio';
 
    public const NOT_SUPPORT_ALPHANUMERIC_NUMBER_STATUS_CODE = 21612;
    public const ON_BEFORE_TWILIO_MESSAGE_SEND = 'OnBeforeTwilioMessageSend';
 
    public function getId()
    {
        return static::ID;
    }
 
    public function getName()
    {
        return Loc::getMessage('MESSAGESERVICE_SENDER_SMS_TWILIO_NAME');
    }
 
    public function getShortName()
    {
        return 'twilio.com';
    }
 
    public function isRegistered()
    {
        return ($this->getOption('account_sid') !== null);
    }
 
    public function isDemo()
    {
        return false;
    }
 
    public function canUse()
    {
        return $this->isRegistered();
    }
 
    public function getFromList()
    {
        $from = $this->getOption('from_list');
        return is_array($from) ? $from : array();
    }
 
    public function register(array $fields)
    {
        $sid = (string)$fields['account_sid'];
        $token = (string)$fields['account_token'];
 
        $result = $this->callExternalMethod(
            HttpClient::HTTP_GET,
            'Accounts/'.$sid, array(), $sid, $token
        );
        if ($result->isSuccess())
        {
            $data = $result->getData();
 
            if ($data['status'] !== 'active')
            {
                $result->addError(new Error(Loc::getMessage('MESSAGESERVICE_SENDER_SMS_TWILIO_ERROR_ACCOUNT_INACTIVE')));
            }
            else
            {
                $this->setOption('account_sid', $sid);
                $this->setOption('account_token', $token);
                $this->setOption('account_friendly_name', $data['friendly_name']);
            }
        }
 
        return $result;
    }
 
    public function getOwnerInfo()
    {
        return array(
            'sid' => $this->getOption('account_sid'),
            'friendly_name' => $this->getOption('account_friendly_name')
        );
    }
 
    public function getExternalManageUrl()
    {
        return 'https://www.twilio.com/console';
    }
 
    public function sendMessage(array $messageFields): SendMessage
    {
        $sid = $this->getOption('account_sid');
 
        if (!$sid)
        {
            $result = new SendMessage();
            $result->addError(new Error(Loc::getMessage('MESSAGESERVICE_SENDER_SMS_TWILIO_CAN_USE_ERROR')));
            return $result;
        }
 
        $eventResults = self::fireEventBeforeMessageSend($messageFields);
        foreach ($eventResults as $eventResult)
        {
            $eventParams = $eventResult->getParameters();
 
            if ($eventResult->getType() === \Bitrix\Main\EventResult::ERROR)
            {
                $result = new SendMessage();
                if ($eventParams && is_string($eventParams))
                {
                    $result->addError(new Error($eventParams));
                }
                else
                {
                    $result->addError(new Error(Loc::getMessage("MESSAGESERVICE_SENDER_SMS_TWILIO_MESSAGE_HAS_NOT_BEEN_SENT")));
                }
                return $result;
            }
 
            if (is_array($eventParams))
            {
                $messageFields = array_merge($messageFields, $eventParams);
            }
        }
 
        if (isset($messageFields['MESSAGE_FROM_ALPHANUMERIC']))
        {
            $apiResult = $this->sendMessageByAlphanumericNumber($sid, $messageFields);
            if (
                !$apiResult->isSuccess()
                && $this->checkSupportErrorAlphanumericNumber($apiResult->getErrorCollection())
            )
            {
                $apiResult = $this->sendMessageByNumber($sid, $messageFields);
            }
        }
        else
        {
            $apiResult = $this->sendMessageByNumber($sid, $messageFields);
        }
 
        $result = new SendMessage();
        $result->setServiceRequest($apiResult->getHttpRequest());
        $result->setServiceResponse($apiResult->getHttpResponse());
 
        if (!$apiResult->isSuccess())
        {
            $result->addErrors($apiResult->getErrors());
        }
        else
        {
            $resultData = $apiResult->getData();
            if (isset($resultData['sid']))
            {
                $result->setExternalId($resultData['sid']);
            }
            $result->setAccepted();
        }
 
        return $result;
    }
 
    public function getMessageStatus(array $messageFields)
    {
        $result = new MessageStatus();
        $result->setId($messageFields['ID']);
        $result->setExternalId($messageFields['EXTERNAL_ID']);
 
        $sid = $this->getOption('account_sid');
        if (!$sid)
        {
            $result->addError(new Error(Loc::getMessage('MESSAGESERVICE_SENDER_SMS_TWILIO_CAN_USE_ERROR')));
            return $result;
        }
 
        $apiResult = $this->callExternalMethod(
            HttpClient::HTTP_GET,
            'Accounts/'.$sid.'/Messages/'.$result->getExternalId()
        );
        if (!$apiResult->isSuccess())
        {
            $result->addErrors($apiResult->getErrors());
        }
        else
        {
            $resultData = $apiResult->getData();
            $result->setStatusCode($resultData['status']);
            $result->setStatusText($resultData['status']);
            if (in_array($resultData['status'],
                array('accepted', 'queued', 'sending', 'sent', 'delivered', 'undelivered', 'failed')))
            {
                $result->setStatusText(
                    Loc::getMessage('MESSAGESERVICE_SENDER_SMS_TWILIO_MESSAGE_STATUS_'.mb_strtoupper($resultData['status']))
                );
            }
        }
 
        return $result;
    }
 
    public static function resolveStatus($serviceStatus)
    {
        $status = parent::resolveStatus($serviceStatus);
 
        switch ((string)$serviceStatus)
        {
            case 'accepted':
                return MessageService\MessageStatus::ACCEPTED;
                break;
            case 'queued':
                return MessageService\MessageStatus::QUEUED;
                break;
            case 'sending':
                return MessageService\MessageStatus::SENDING;
                break;
            case 'sent':
                return MessageService\MessageStatus::SENT;
                break;
            case 'delivered':
                return MessageService\MessageStatus::DELIVERED;
                break;
            case 'undelivered':
                return MessageService\MessageStatus::UNDELIVERED;
                break;
            case 'failed':
                return MessageService\MessageStatus::FAILED;
                break;
        }
 
        return $status;
    }
 
    public function sync()
    {
        if ($this->isRegistered())
        {
            $this->loadFromList();
        }
        return $this;
    }
 
    private function callExternalMethod($httpMethod, $apiMethod, array $params = array(), $sid = null, $token = null): Sender\Result\HttpRequestResult
    {
        $url = $this->getRequestUrl($apiMethod);
 
        $httpClient = new HttpClient(array(
            "socketTimeout" => $this->socketTimeout,
            "streamTimeout" => $this->streamTimeout,
            "waitResponse" => true,
        ));
        $httpClient->setHeader('User-Agent', 'Bitrix24');
        $httpClient->setCharset('UTF-8');
 
        if (!$sid || !$token)
        {
            $sid = $this->getOption('account_sid');
            $token = $this->getOption('account_token');
        }
 
        $httpClient->setAuthorization($sid, $token);
 
        $isUtf = Application::getInstance()->isUtfMode();
 
        if (!$isUtf)
        {
            $params = \Bitrix\Main\Text\Encoding::convertEncoding($params, SITE_CHARSET, 'UTF-8');
        }
 
        $result = new Sender\Result\HttpRequestResult();
        $answer = array();
 
        $result->setHttpRequest(new MessageService\DTO\Request([
            'method' => HttpClient::HTTP_POST,
            'uri' => $url,
            'headers' => method_exists($httpClient, 'getRequestHeaders') ? $httpClient->getRequestHeaders()->toArray() : [],
            'body' => $params,
        ]));
        if ($httpClient->query($httpMethod, $url, $params))
        {
            try
            {
                $answer = Json::decode($httpClient->getResult());
            }
            catch (ArgumentException $e)
            {
                $result->addError(new Error('Service error'));
            }
 
            $httpStatus = $httpClient->getStatus();
            if ($httpStatus >= 400)
            {
                $errorInformant = new ErrorInformant($answer['message'], $answer['code'], $answer['more_info'], $httpStatus);
                $result->addError($errorInformant->getError());
                // if (isset($answer['message']) && isset($answer['code']))
                // {
                //  $result->addError(new Error($answer['message'], $answer['code']));
                // }
                // else
                // {
                //  $result->addError(new Error('Service error (HTTP Status '.$httpStatus.')'));
                // }
            }
        }
        $result->setHttpResponse(new MessageService\DTO\Response([
            'statusCode' => $httpClient->getStatus(),
            'headers' => $httpClient->getHeaders()->toArray(),
            'body' => $httpClient->getResult(),
            'error' => Sender\Util::getHttpClientErrorString($httpClient)
        ]));
 
        if ($result->isSuccess())
        {
            $result->setData($answer);
        }
 
        return $result;
    }
 
    private function loadFromList()
    {
        $sid = $this->getOption('account_sid');
        $result = $this->callExternalMethod(
            HttpClient::HTTP_GET,
            'Accounts/'.$sid.'/IncomingPhoneNumbers'
        );
 
        if ($result->isSuccess())
        {
            $from = array();
            $resultData = $result->getData();
            if (isset($resultData['incoming_phone_numbers']) && is_array($resultData['incoming_phone_numbers']))
            {
                foreach ($resultData['incoming_phone_numbers'] as $phoneNumber)
                {
                    if ($phoneNumber['capabilities']['sms'] === true)
                    {
                        $from[] = array(
                            'id' => $phoneNumber['phone_number'],
                            'name' => $phoneNumber['friendly_name']
                        );
                    }
                }
            }
 
            $this->setOption('from_list', $from);
        }
    }
 
    private function checkSupportErrorAlphanumericNumber(ErrorCollection $collection): bool
    {
        if ($collection->getErrorByCode(self::NOT_SUPPORT_ALPHANUMERIC_NUMBER_STATUS_CODE))
        {
            return true;
        }
 
        return false;
    }
 
    private function sendMessageByAlphanumericNumber(string $sid, array $messageFields): Sender\Result\HttpRequestResult
    {
        $params = [
            'To' => $messageFields['MESSAGE_TO'],
            'Body' => $this->prepareMessageBodyForSend($messageFields['MESSAGE_BODY']),
            'From' => $messageFields['MESSAGE_FROM_ALPHANUMERIC'],
            'StatusCallback' => $this->getCallbackUrl()
        ];
 
        return $this->callExternalMethod(
            HttpClient::HTTP_POST,
            'Accounts/'.$sid.'/Messages/',
            $params
        );
    }
 
    private function sendMessageByNumber(string $sid, array $messageFields): Sender\Result\HttpRequestResult
    {
        $params = [
            'To' => $messageFields['MESSAGE_TO'],
            'Body' => $this->prepareMessageBodyForSend($messageFields['MESSAGE_BODY']),
            'From' => $messageFields['MESSAGE_FROM'],
            'StatusCallback' => $this->getCallbackUrl()
        ];
 
        if (!$params['From'])
        {
            $params['From'] = $this->getDefaultFrom();
        }
        if (is_string($params['From']) && mb_strlen($params['From']) === 34) //unique id of the Messaging Service
        {
            $params['MessagingServiceSid'] = $params['From'];
            unset($params['From']);
        }
 
        return $this->callExternalMethod(
            HttpClient::HTTP_POST,
            'Accounts/'.$sid.'/Messages/',
            $params
        );
    }
 
    public static function fireEventBeforeMessageSend(array $messageFields): array
    {
        $event = new Event('messageservice', self::ON_BEFORE_TWILIO_MESSAGE_SEND, $messageFields);
        $event->send();
 
        return $event->getResults();
    }
 
    private function getRequestUrl(string $apiMethod): string
    {
        $url = Option::get(
            'messageservice',
            'twilio_api_uri_tpl',
            'https://api.twilio.com/2010-04-01/%apiMethod%.json'
        );
 
        return str_replace('%apiMethod%', $apiMethod, $url);
    }
}