zoom.php

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

<?php
 
use Bitrix\Main\ArgumentException;
use Bitrix\Main\Engine\UrlManager;
use Bitrix\Main\Error;
use \Bitrix\Main\Localization\Loc;
use Bitrix\Main\ObjectPropertyException;
use Bitrix\Main\Result;
use Bitrix\Main\SystemException;
use Bitrix\Main\Type\DateTime;
use \Bitrix\Main\Web\HttpClient;
use \Bitrix\Main\Web\Json;
use \Bitrix\Main\Web\JWT;
use Bitrix\Socialservices\UserTable;
use Bitrix\Socialservices\ZoomMeetingTable;
 
IncludeModuleLangFile(__FILE__);
 
class CSocServZoom extends CSocServAuth
{
    public const ID = 'zoom';
    private const CONTROLLER_URL = 'https://www.bitrix24.com/controller';
    private const LOGIN_PREFIX = 'zoom_';
    public const EMPTY_TYPE = "EMPTY";
 
    protected $entityOAuth;
 
    public function __construct($userId = null)
    {
        $this->getEntityOAuth();
 
        parent::__construct($userId);
    }
 
    public function GetSettings()
    {
        return [
            ['zoom_client_id', Loc::getMessage('SOCSERV_ZOOM_CLIENT_ID'), '', ['text', 40]],
            ['zoom_client_secret', Loc::getMessage('SOCSERV_ZOOM_CLIENT_SECRET'), '', ['text', 40]],
            [
                'note' => Loc::getMessage(
                        'SOCSERV_ZOOM_SETT_NOTE_2',
                        ['#URL#'=>\CHTTP::URN2URI('/bitrix/tools/oauth/zoom.php')]
                )
            ],
        ];
    }

    public function getEntityOAuth($code = false): CZoomInterface
    {
        if (!$this->entityOAuth)
        {
            $this->entityOAuth = new CZoomInterface();
        }
 
        if ($code !== false)
        {
            $this->entityOAuth->setCode($code);
        }
 
        return $this->entityOAuth;
    }
 
    public function GetFormHtml($arParams)
    {
        $url = $this->getUrl($arParams);
 
        $phrase = ($arParams['FOR_INTRANET'])
            ? GetMessage('SOCSERV_ZOOM_NOTE_INTRANET')
            : GetMessage('SOCSERV_ZOOM_NOTE');
 
        return $arParams['FOR_INTRANET']
            ? array('ON_CLICK' => 'onclick="BX.util.popup(\'' . htmlspecialcharsbx(CUtil::JSEscape($url)) . '\', 700, 700)"')
            : '<a href="javascript:void(0)" onclick="BX.util.popup(\'' . htmlspecialcharsbx(CUtil::JSEscape($url)) . '\', 700, 700)" class="bx-ss-button zoom-button"></a><span class="bx-spacer"></span><span>' . $phrase . '</span>';
    }
 
    public function GetOnClickJs($arParams): string
    {
        $url = $this->getUrl($arParams);
        return "BX.util.popup('" . CUtil::JSEscape($url) . "', 460, 420)";
    }
 
    public function getUrl($arParams): string
    {
        global $APPLICATION;
 
        if (defined('BX24_HOST_NAME') && IsModuleInstalled('bitrix24'))
        {
            $redirect_uri = static::CONTROLLER_URL . '/redirect.php';
            $backurl = $APPLICATION->GetCurPageParam('', ['logout', 'auth_service_error', 'auth_service_id', 'backurl']);
            $state = $this->getEntityOAuth()->GetRedirectURI() .
                urlencode('?state=' . JWT::urlsafeB64Encode('backurl=' . $backurl . '&check_key=' . \CSocServAuthManager::getUniqueKey()));
        }
        else
        {
            $state = 'site_id=' . SITE_ID . '&backurl=' .
                urlencode($APPLICATION->GetCurPageParam('check_key=' . \CSocServAuthManager::getUniqueKey(), ['logout', 'auth_service_error', 'auth_service_id', 'backurl'])) .
                (isset($arParams['BACKURL']) ? '&redirect_url=' . urlencode($arParams['BACKURL']) : '');
 
            $redirect_uri = $this->getEntityOAuth()->GetRedirectURI();
        }
 
        return $this->getEntityOAuth()->GetAuthUrl($redirect_uri, $state);
    }
 
    public function addScope($scope): CZoomInterface
    {
        return $this->getEntityOAuth()->addScope($scope);
    }
 
    public function prepareUser($arUser, $short = false): array
    {
        $entityOAuth = $this->getEntityOAuth();
        $arFields = array(
            'EXTERNAL_AUTH_ID' => self::ID,
            'XML_ID' => $arUser["email"],
            'LOGIN' => self::LOGIN_PREFIX.$arUser["email"],
            'EMAIL' => $arUser["email"],
            'NAME' => $arUser["first_name"],
            'LAST_NAME' => $arUser["last_name"],
            'OATOKEN' => $entityOAuth->getToken(),
            'OATOKEN_EXPIRES' => $entityOAuth->getAccessTokenExpires(),
        );
 
        if (!$short && isset($arUser['pic_url']))
        {
            $picture_url = $arUser['pic_url'];
            $temp_path = CFile::GetTempName('', 'picture.jpg');
 
            $ob = new HttpClient(array(
                "redirect" => true
            ));
            $ob->download($picture_url, $temp_path);
 
            $arPic = CFile::MakeFileArray($temp_path);
            if ($arPic)
            {
                $arFields["PERSONAL_PHOTO"] = $arPic;
            }
        }
 
        if (SITE_ID <> '')
        {
            $arFields["SITE_ID"] = SITE_ID;
        }
 
        return $arFields;
    }
 
    public static function CheckUniqueKey($bUnset = true): bool
    {
        $arState = array();
 
        if (isset($_REQUEST['state']))
        {
            parse_str(urldecode(JWT::urlsafeB64Decode($_REQUEST['state'])), $arState);
 
            if (isset($arState['backurl']))
            {
                InitURLParam($arState['backurl']);
            }
        }
 
        if (!isset($_REQUEST['check_key']) && isset($_REQUEST['backurl']))
        {
            InitURLParam($_REQUEST['backurl']);
        }
 
        $checkKey = '';
        if (isset($_REQUEST['check_key']))
        {
            $checkKey = $_REQUEST['check_key'];
        }
        elseif (isset($arState['check_key']))
        {
            $checkKey = $arState['check_key'];
        }
 
        if ($_SESSION['UNIQUE_KEY'] !== '' && $checkKey !== '' && ($checkKey === $_SESSION['UNIQUE_KEY']))
        {
            if ($bUnset)
            {
                unset($_SESSION['UNIQUE_KEY']);
            }
 
            return true;
        }
        return false;
    }
 
    public function Authorize(): void
    {
        global $APPLICATION;
        $APPLICATION->RestartBuffer();
 
        $authError = SOCSERV_AUTHORISATION_ERROR;
 
        if (
            isset($_REQUEST['code']) && $_REQUEST['code'] <> ''
            && self::CheckUniqueKey()
        )
        {
            if (defined('BX24_HOST_NAME') && IsModuleInstalled('bitrix24'))
            {
                $redirect_uri = static::CONTROLLER_URL . '/redirect.php';
            }
            else
            {
                $redirect_uri = $this->getEntityOAuth()->GetRedirectURI();
            }
 
            $entityOAuth = $this->getEntityOAuth($_REQUEST['code']);
            if ($entityOAuth->GetAccessToken($redirect_uri) !== false)
            {
                $arUser = $entityOAuth->getCurrentUser();
                if (is_array($arUser) && isset($arUser["email"]))
                {
                    $arFields = $this->prepareUser($arUser);
                    $authError = $this->AuthorizeUser($arFields);
 
                    $userData = [
                        'externalUserId' => $arUser['id'],
                        'externalAccountId' => $arUser['account_id'],
                        'socServLogin' => $arFields['LOGIN'],
                    ];
                    $zc = new \Bitrix\SocialServices\Integration\Zoom\ZoomController();
                    $zc->registerZoomUser($userData);
                }
            }
        }
 
        $bSuccess = $authError === true;
 
        $url = ($APPLICATION->GetCurDir() == "/login/") ? "" : $APPLICATION->GetCurDir();
        $aRemove = array("logout", "auth_service_error", "auth_service_id", "code", "error_reason", "error", "error_description", "check_key", "current_fieldset");
 
        if (isset($_REQUEST["state"]))
        {
            $arState = array();
 
            $decodedState = urldecode(JWT::urlsafeB64Decode($_REQUEST["state"]));
            parse_str($decodedState, $arState);
 
            if (isset($arState['backurl']) || isset($arState['redirect_url']))
            {
                $url = !empty($arState['redirect_url']) ? $arState['redirect_url'] : $arState['backurl'];
                if (substr($url, 0, 1) !== "#")
                {
                    $parseUrl = parse_url($url);
 
                    $urlPath = $parseUrl["path"];
                    $arUrlQuery = explode('&', $parseUrl["query"]);
 
                    foreach ($arUrlQuery as $key => $value)
                    {
                        foreach ($aRemove as $param)
                        {
                            if (strpos($value, $param . "=") === 0)
                            {
                                unset($arUrlQuery[$key]);
                                break;
                            }
                        }
                    }
 
                    $url = (!empty($arUrlQuery)) ? $urlPath . '?' . implode("&", $arUrlQuery) : $urlPath;
                }
            }
        }
 
        if ($authError === SOCSERV_REGISTRATION_DENY)
        {
            $url = (preg_match("/\?/", $url)) ? $url . '&' : $url . '?';
            $url .= 'auth_service_id=' . self::ID . '&auth_service_error=' . $authError;
        }
        elseif ($bSuccess !== true)
        {
            $url = (isset($urlPath)) ? $urlPath . '?auth_service_id=' . self::ID . '&auth_service_error=' . $authError : $GLOBALS['APPLICATION']->GetCurPageParam(('auth_service_id=' . self::ID . '&auth_service_error=' . $authError), $aRemove);
        }
 
        if (CModule::IncludeModule("socialnetwork") && strpos($url, "current_fieldset=") === false)
        {
            $url .= ((strpos($url, "?") === false) ? '?' : '&') . "current_fieldset=SOCSERV";
        }
        ?>
        <script>
            if (window.opener)
                window.opener.location.reload();
            window.close();
        </script>
        <?php
        CMain::FinalActions();
    }
 
    public function setUser($userId)
    {
        $this->getEntityOAuth()->setUser($userId);
    }
 
    public function getStorageToken()
    {
        $accessToken = null;
        $userId = (int)$this->userId;
        if ($userId > 0)
        {
            $dbSocservUser = \Bitrix\Socialservices\UserTable::getList([
                'filter' => ['=USER_ID' => $userId, '=EXTERNAL_AUTH_ID' => static::ID],
                'select' => ['OATOKEN', 'REFRESH_TOKEN', 'OATOKEN_EXPIRES']
            ]);
            if ($arOauth = $dbSocservUser->fetch())
            {
                $accessToken = $arOauth['OATOKEN'];
 
                if (empty($accessToken) || (((int)$arOauth['OATOKEN_EXPIRES'] > 0) && ((int)($arOauth['OATOKEN_EXPIRES'] < (int)time()))))
                {
                    if (isset($arOauth['REFRESH_TOKEN']))
                    {
                        $this->getEntityOAuth()->getNewAccessToken($arOauth['REFRESH_TOKEN'], $userId, true);
                    }
 
                    if (($accessToken = $this->getEntityOAuth()->getToken()) === false)
                    {
                        return null;
                    }
                }
            }
        }
 
        return $accessToken;
    }
 
    public function createConference($params)
    {
        $result = new Result();
        $conferenceData = null;
        if (!$this->getEntityOAuth()->GetAccessToken())
        {
            return $result->addError(new Error('Could not get oauth token'));
        }
 
        if (isset($params['ENTITY_TYPE_ID']))
        {
            $entityTypeId = $params['ENTITY_TYPE_ID'];
            unset($params['ENTITY_TYPE_ID']);
        }
 
        if (isset($params['ENTITY_ID']))
        {
            $entityId = $params['ENTITY_ID'];
            unset($params['ENTITY_ID']);
        }
 
        $requestConferenceResult = $this->getEntityOAuth()->requestConference($params);
        if(!$requestConferenceResult->isSuccess())
        {
            return $result->addErrors($requestConferenceResult->getErrors());
        }
        $conferenceData = $requestConferenceResult->getData();
 
        $userData = $this->getEntityOAuth()->getCurrentUser();
        if(!is_array($userData))
        {
            return $result->addError(new Error('Cannot get user data'));
        }
        $conferenceData['externalUserId'] = $userData['id'];
        $conferenceData['externalAccountId'] = $userData['account_id'];
 
        $conference['join_url'] = $this->attachPasswordToUrl($conferenceData['join_url'], $conferenceData['encrypted_password']);
 
        $startTimeStamp = \DateTime::createFromFormat(DATE_ATOM, $conferenceData['start_time'])->getTimestamp();
        $startDateTime = DateTime::createFromTimestamp($startTimeStamp);
 
        $params = [
            'ENTITY_TYPE_ID' => ($entityTypeId ?? self::EMPTY_TYPE),
            'ENTITY_ID' => ($entityId ?? 0),
            'CONFERENCE_EXTERNAL_ID' => $conferenceData['id'],
            'CONFERENCE_URL' => $conferenceData['join_url'],
            'CONFERENCE_PASSWORD' => $conferenceData['encrypted_password'],
            'CONFERENCE_CREATED' => (new DateTime()),
            'CONFERENCE_STARTED' => $startDateTime,
            'DURATION' => $conferenceData['duration'],
            'TITLE' => $conferenceData['topic'],
            'SHORT_LINK' => $this->getShortLink($conferenceData['id']),
        ];
 
        $addResult = ZoomMeetingTable::add($params);
        if (!$addResult->isSuccess())
        {
            return $result->addErrors($addResult->getErrors());
        }
        $conferenceData['bitrix_internal_id'] = $addResult->getId();
 
        return $result->setData($conferenceData);
    }
 
    private function getShortLink(int $conferenceId): string
    {
        $host = UrlManager::getInstance()->getHostUrl();
        $controllerUrl = \Bitrix\Main\Engine\UrlManager::getInstance()->create(
            'crm.api.zoomUser.registerJoinMeeting',
            ['conferenceId' => $conferenceId]
        )->getUri();
 
        return $host.\CBXShortUri::GetShortUri($controllerUrl);
    }

    public function updateConference(array $updateParams): Result
    {
        $result = new Result();
        $params = [];
 
        if (!$this->getEntityOAuth()->GetAccessToken())
        {
            return $result->addError(new Error('Could not get oauth token'));
        }
 
        $preparedData = $this->prepareDataToUpdate($updateParams);
        if (empty($preparedData))
        {
            return $result;
        }
 
        $externalConferenceId = $preparedData['id'];
        unset($preparedData['id']);
 
        $requestConferenceResult = $this->getEntityOAuth()->updateConference($externalConferenceId, $preparedData);
        if (!$requestConferenceResult->isSuccess())
        {
            return $result->addErrors($requestConferenceResult->getErrors());
        }
 
        if (isset($updateParams['start_time']))
        {
            $params['CONFERENCE_STARTED'] = DateTime::createFromUserTime($updateParams['start_time']);
        }
 
        if (isset($preparedData['duration']))
        {
            $params['DURATION'] = $preparedData['duration'];
        }
 
        if (!empty($params))
        {
            $addResult = ZoomMeetingTable::update($updateParams['meeting_id'], $params);
            if (!$addResult->isSuccess())
            {
                return $result->addErrors($addResult->getErrors());
            }
        }
 
        return $result;
    }

    private function prepareDataToUpdate(array $updateParams): ?array
    {
        $preparedDataToUpdate = [];
 
        //get activity start and end timestamps
        $activityStartTimeStamp = DateTime::createFromUserTime($updateParams['start_time'])->getTimestamp();
        $activityEndTimeStamp = DateTime::createFromUserTime($updateParams['end_time'])->getTimestamp();
 
        $meetingData = ZoomMeetingTable::getRowById($updateParams['meeting_id']);
        if (!$meetingData)
        {
            return null;
        }
 
        //Prepare start_time only if the activity start_time does not match the conference start_time.
        $meetingStartTimeStamp = $meetingData['CONFERENCE_STARTED']->getTimestamp();
        if ($meetingStartTimeStamp !== $activityStartTimeStamp)
        {
            $preparedDataToUpdate['start_time'] = DateTime::createFromUserTime($updateParams['start_time'])
                ->setTimeZone(new \DateTimeZone('UTC'))
                ->format(DATE_ATOM);
        }
 
        //Prepare duration only if the activity duration does not match the conference duration.
        $currentActivityDuration = ($activityEndTimeStamp - $activityStartTimeStamp) / 60;
        if ($currentActivityDuration !== (int)$meetingData['DURATION'])
        {
            $preparedDataToUpdate['duration'] = $currentActivityDuration;
        }
 
        //Continue only if duration or start_time has been changed ($preparedDataToUpdate is not empty).
        if (!empty($preparedDataToUpdate))
        {
            $preparedDataToUpdate['id'] = $meetingData['CONFERENCE_EXTERNAL_ID'];
        }
 
        return $preparedDataToUpdate;
    }
 
    public function getConferenceById(int $confId): ?array
    {
        $conference = null;
        if ($this->getEntityOAuth()->GetAccessToken())
        {
            $conference = $this->getEntityOAuth()->getConferenceById($confId);
        }
 
        return $conference;
    }
 
    private function attachPasswordToUrl(string $conferenceUrl, string $password): string
    {
        $url = new \Bitrix\Main\Web\Uri($conferenceUrl);
        $queryParams = $url->getQuery();
        $parsedParams = [];
        parse_str($queryParams, $parsedParams);
        if (!isset($parsedParams['pwd']))
        {
            $url->addParams(['pwd' => $password]);
            $conferenceUrl = $url->getUri();
        }
 
        return $conferenceUrl;
    }

    public function sendComplianceRequest(array $payload): Result
    {
        return $this->getEntityOAuth()->sendComplianceNotify($payload);
    }
}
 
class CZoomInterface extends CSocServOAuthTransport
{
    const SERVICE_ID = "zoom";
 
    const AUTH_URL = 'https://zoom.us/oauth/authorize';
    const TOKEN_URL = 'https://zoom.us/oauth/token';
    const COMPLIANCE_URL = 'https://api.zoom.us/oauth/data/compliance';
 
    private const API_ENDPOINT = 'https://api.zoom.us/v2/';
 
    private const USER_INFO_URL = 'users/me';
    private const CREATE_MEETING_ENDPOINT = 'users/me/meetings';
    private const UPDATE_MEETING_ENDPOINT = 'meetings/';
 
    private const CACHE_TIME_CONNECT_INFO = "86400"; //One day
    public const CACHE_DIR_CONNECT_INFO = "/socialservices/zoom/";
 
    protected $userId = false;
    protected $responseData = array();
    protected $idToken;
 
    protected $scope = [
        'meeting:write', 'user:read:admin', 'meeting:read', 'recording:read'
    ];
 
    public function __construct($appID = false, $appSecret = false, $code = false)
    {
        if ($appID === false)
        {
            $appID = trim(CSocServAuth::GetOption("zoom_client_id"));
        }
 
        if ($appSecret === false)
        {
            $appSecret = trim(CSocServAuth::GetOption("zoom_client_secret"));
        }
 
        parent::__construct($appID, $appSecret, $code);
    }
 
    public function GetRedirectURI(): string
    {
        return \CHTTP::URN2URI('/bitrix/tools/oauth/zoom.php');
    }
 
    public function GetAuthUrl($redirect_uri, $state = ''): string
    {
        return self::AUTH_URL .
            '?client_id=' . $this->appID .
            '&redirect_uri=' . urlencode($redirect_uri) .
            '&response_type=' . 'code' .
            '&response_mode=' . 'form_post' .
            ($state <> '' ? '&state=' . JWT::urlsafeB64Encode($state) : '');
    }
 
    public function getResult()
    {
        return $this->responseData;
    }
 
    public function GetAccessToken($redirect_uri = ''): bool
    {
        $token = $this->getStorageTokens();
        if (is_array($token))
        {
            $this->access_token = $token['OATOKEN'];
            $this->accessTokenExpires = $token['OATOKEN_EXPIRES'];
 
            if (!$this->code)
            {
                if ($this->checkAccessToken())
                {
                    return true;
                }
 
                if (isset($token['REFRESH_TOKEN']) && $this->getNewAccessToken($token['REFRESH_TOKEN'], $this->userId, true))
                {
                    return true;
                }
            }
 
            $this->deleteStorageTokens();
        }
 
        if ($this->code === false)
        {
            return false;
        }
 
        $query = [
            'code' => $this->code,
            'grant_type' => 'authorization_code',
            'redirect_uri' => $redirect_uri,
        ];
 
        $httpClient = new HttpClient([
            'socketTimeout' => $this->httpTimeout,
            'streamTimeout' => $this->httpTimeout,
        ]);
        $httpClient->setAuthorization($this->appID, $this->appSecret);
 
        $result = $httpClient->post(self::TOKEN_URL, $query);
        try
        {
            $result = \Bitrix\Main\Web\Json::decode($result);
        }
        catch (\Bitrix\Main\ArgumentException $e)
        {
            $result = [];
        }
 
        if ((isset($result['access_token']) && $result['access_token'] <> ''))
        {
            $this->access_token = $result['access_token'];
            $this->accessTokenExpires = time() + $result['expires_in'];
            $this->refresh_token = $result['refresh_token'];
 
            $_SESSION["OAUTH_DATA"] = [
                "OATOKEN" => $this->access_token,
                "OATOKEN_EXPIRES" => $this->accessTokenExpires,
                "REFRESH_TOKEN" => $this->refresh_token,
            ];
            return true;
        }
 
        return false;
    }
 
    public function getNewAccessToken($refreshToken = false, $userId = 0, $save = false): bool
    {
        if (!$this->appID || !$this->appSecret)
        {
            return false;
        }
 
        if (!$refreshToken)
        {
            $refreshToken = $this->refresh_token;
        }
 
        $httpClient = new HttpClient(array(
            'socketTimeout' => $this->httpTimeout,
            'streamTimeout' => $this->httpTimeout,
        ));
        $httpClient->setAuthorization($this->appID, $this->appSecret);
        $queryPrams = http_build_query([
            'refresh_token' => $refreshToken,
            'grant_type' => 'refresh_token',
        ]);
        $url = static::TOKEN_URL.'?'.$queryPrams;
        $result = $httpClient->post($url);
 
        try
        {
            $arResult = Json::decode($result);
        }
        catch (\Bitrix\Main\ArgumentException $e)
        {
            $arResult = array();
        }
 
        if (!empty($arResult['access_token']))
        {
            $this->access_token = $arResult['access_token'];
            $this->accessTokenExpires = $arResult['expires_in'] + time();
            $this->refresh_token = $arResult['refresh_token'];
 
            if ($save && (int)$userId > 0)
            {
                $dbSocservUser = \Bitrix\Socialservices\UserTable::getList(array(
                    'filter' => array(
                        '=EXTERNAL_AUTH_ID' => static::SERVICE_ID,
                        '=USER_ID' => $userId,
                    ),
                    'select' => array('ID')
                ));
                if ($arOauth = $dbSocservUser->fetch())
                {
                    \Bitrix\Socialservices\UserTable::update($arOauth['ID'], array(
                            'OATOKEN' => $this->access_token,
                            'REFRESH_TOKEN' => $this->refresh_token,
                            'OATOKEN_EXPIRES' => $this->accessTokenExpires,
                        )
                    );
                }
            }
 
            return true;
        }
 
        return false;
    }
 
    public function getCurrentUser()
    {
        if ($this->access_token === false)
        {
            return false;
        }
 
        $endPoint = self::API_ENDPOINT . self::USER_INFO_URL;
        $requestResult = $this->sendRequest(HttpClient::HTTP_GET, $endPoint);
 
        if (!$requestResult->isSuccess())
        {
            return null;
        }
 
        return $requestResult->getData();
    }
 
    public function requestConference($params): Result
    {
        $result = new Result();
 
        $endPoint = self::API_ENDPOINT . self::CREATE_MEETING_ENDPOINT;
        $requestResult = $this->sendRequest(HttpClient::HTTP_POST, $endPoint, $params);
 
        if (!$requestResult->isSuccess())
        {
            return $result->addErrors($requestResult->getErrors());
        }
        $response = $requestResult->getData();
 
        if (isset($response['code']) && $response['code'] != 200)
        {
            // zoom api error
            return $result->addError(new Error($response['message'], $response['code']));
        }
 
        return $result->setData($response);
    }
 
    public function updateConference(int $conferenceId, array $params): Result
    {
        $endPoint = self::API_ENDPOINT . self::UPDATE_MEETING_ENDPOINT . $conferenceId;
 
        return $this->sendRequest(HttpClient::HTTP_PATCH, $endPoint, $params);
    }
 
    public function getConferenceById($confId): ?array
    {
        $newMeetingEndpoint = self::API_ENDPOINT. 'meetings/' . $confId;
        $conferenceDataResult = $this->sendRequest(HttpClient::HTTP_GET, $newMeetingEndpoint);
 
        if (!$conferenceDataResult->isSuccess())
        {
            return null;
        }
 
        $conferenceData = $conferenceDataResult->getData();
        if (!is_array($conferenceData) || $conferenceData['id'] <= 0)
        {
            return null;
        }
 
        return $conferenceData;
    }
 
    public function getConferenceFiles($confId): ?array
    {
        $endPoint = self::API_ENDPOINT . "/meetings/{$confId}/recordings";
        $requestResult = $this->sendRequest(HttpClient::HTTP_GET, $endPoint);
        if (!$requestResult->isSuccess())
        {
            return null;
        }
 
        return $requestResult->getData();
    }

    public function sendComplianceNotify(array $params): Result
    {
        $requestParams = [
            'client_id' => $this->appID,
            'user_id' => $params['user_id'],
            'account_id' => $params['account_id'],
            'deauthorization_event_received' => $params,
            'compliance_completed' => true,
        ];
 
        $result = new Result();
        $http = new HttpClient([
            'socketTimeout' => $this->httpTimeout,
            'streamTimeout' => $this->httpTimeout,
        ]);
 
        $http->setAuthorization($this->appID, $this->appSecret);
        $http->setHeader('Content-type', 'application/json');
        $requestResult = $http->post(self::COMPLIANCE_URL, Json::encode($requestParams));
 
        try
        {
            $decodedData = Json::decode($requestResult);
            $result->setData($decodedData);
        }
        catch (ArgumentException $e)
        {
            return $result->addError(new Error('Could not decode service response'));
        }
 
        return $result;
    }
 
    private function sendRequest(string $method, string $endPoint, array $params = []): Result
    {
        $result = new Result();
 
        $http = new HttpClient(array(
            'socketTimeout' => $this->httpTimeout,
            'streamTimeout' => $this->httpTimeout,
        ));
        $http->setHeader('Authorization', 'Bearer '.$this->access_token);
 
        switch ($method)
        {
            case HttpClient::HTTP_PATCH:
                $http->setHeader('Content-type', 'application/json');
                $http->query(HttpClient::HTTP_PATCH, $endPoint, Json::encode($params));
                if ($http->getStatus() != 204)
                {
                    // zoom api error
                    $requestResult = $http->getResult();
                    $response = Json::decode($requestResult);
                    return $result->addError(new Error($response['message'], $response['code']));
                }
                return $result;
 
            case HttpClient::HTTP_POST:
                $http->setHeader('Content-type', 'application/json');
                $requestResult = $http->post($endPoint, Json::encode($params));
                break;
 
            case HttpClient::HTTP_GET:
                $requestResult = $http->get($endPoint);
                break;
 
            default:
                return $result->addError(new Error('Unsupported request method'));
        }
 
        try
        {
            $decodedData = Json::decode($requestResult);
            $result->setData($decodedData);
        }
        catch (ArgumentException $e)
        {
            return $result->addError(new Error('Could not decode service response'));
        }
 
        return $result;
    }

    public static function isConnected(int $userId): bool
    {
        $cache = \Bitrix\Main\Data\Cache::createInstance();
        $cacheId = self::SERVICE_ID .'|'. $userId;
        $user = null;
        if ($cache->initCache(self::CACHE_TIME_CONNECT_INFO, $cacheId, self::CACHE_DIR_CONNECT_INFO))
        {
            $user = $cache->getVars()['user'];
        }
        elseif ($cache->startDataCache())
        {
            $user = UserTable::getRow([
                    'filter' => [
                        '=USER_ID' => $userId,
                        '=EXTERNAL_AUTH_ID' => self::SERVICE_ID
                    ]
                ]);
 
            $cache->endDataCache(['user' => $user]);
        }
 
        return $user !== null;
    }
 
    public function GetAppInfo(): bool
    {
        return false;
    }
 
    public function getScopeEncode(): string
    {
        return implode(' ', array_map('urlencode', array_unique($this->getScope())));
    }
}