access.php

<?php
 
namespace Bitrix\Rest\Engine;
 
use Bitrix\Main\Loader;
use Bitrix\Main\Config\Option;
use Bitrix\Main\ModuleManager;
use Bitrix\Main\Type\Date;
use Bitrix\Main\Web\Json;
use Bitrix\Rest\AppTable;
use Bitrix\Rest\Marketplace\Client;
use Bitrix\Rest\Marketplace\Immune;
 
class Access
{
    public const ENTITY_TYPE_APP = 'app';
    public const ENTITY_TYPE_APP_STATUS = 'status';
    public const ENTITY_TYPE_INTEGRATION = 'integration';
    public const ENTITY_TYPE_AP_CONNECT = 'ap_connect';
    public const ENTITY_TYPE_WEBHOOK = 'webhook';
    public const ENTITY_COUNT = 'count';
 
    public const ACTION_INSTALL = 'install';
    public const ACTION_OPEN = 'open';
    public const ACTION_BUY = 'buy';
 
    public const MODULE_ID = 'rest';
    public const OPTION_ACCESS_ACTIVE = 'access_active';
    public const OPTION_AVAILABLE_COUNT = 'app_available_count';
    public const OPTION_SUBSCRIPTION_AVAILABLE = 'subscription_available';
    private const OPTION_APP_USAGE_LIST = 'app_usage_list';
    private const OPTION_REST_UNLIMITED_FINISH = 'rest_unlimited_finish';
    private const OPTION_HOLD_CHECK_COUNT_APP = '~hold_check_count_app';
    private const DEFAULT_AVAILABLE_COUNT = -1;
    private const DEFAULT_AVAILABLE_COUNT_DEMO = 10;
 
    private static $availableApp = [];
    private static $availableAppCount = [];
 
    public static function isFeatureEnabled()
    {
        return
            !ModuleManager::isModuleInstalled('bitrix24')
            || (
                Loader::includeModule('bitrix24')
                && \Bitrix\Bitrix24\Feature::isFeatureEnabled('rest_access')
            )
        ;
    }
 
    public static function isAvailable($app = '') : bool
    {
        if (!static::isActiveRules())
        {
            return true;
        }
 
        if (!array_key_exists($app, static::$availableApp))
        {
            static::$availableApp[$app] = false;
            if (Client::isSubscriptionAvailable())
            {
                static::$availableApp[$app] = true;
            }
            elseif (static::isFeatureEnabled())
            {
                static::$availableApp[$app] = true;
            }
            elseif ($app !== '')
            {
                if (in_array($app, Immune::getList(), true))
                {
                    static::$availableApp[$app] = true;
                }
                else
                {
                    $appInfo = AppTable::getByClientId($app);
                    if ($appInfo['CODE'] && in_array($appInfo['CODE'], Immune::getList(), true))
                    {
                        static::$availableApp[$app] = true;
                    }
                }
            }
        }
 
        return static::$availableApp[$app];
    }
 
    public static function isAvailableCount(string $entityType, $entity = 0) : bool
    {
        if (!static::isActiveRules())
        {
            return true;
        }
 
        $key = $entityType . $entity;
        if (!array_key_exists($key, static::$availableAppCount))
        {
            static::$availableAppCount[$key] = true;
            if ($entityType === static::ENTITY_TYPE_APP)
            {
                $maxCount = static::getAvailableCount();
                if ($maxCount >= 0)
                {
                    $appInfo = AppTable::getByClientId($entity);
                    if (!isset($appInfo['STATUS']) || $appInfo['STATUS'] !== AppTable::STATUS_LOCAL)
                    {
                        if (isset($appInfo['CODE']) && $appInfo['CODE'])
                        {
                            $entity = $appInfo['CODE'];
                        }
 
                        $entityList = static::getActiveEntity(true);
                        if ($entityList[static::ENTITY_COUNT] > $maxCount)
                        {
                            static::$availableAppCount[$key] = false;
                        }
                        elseif (
                            $entityList[static::ENTITY_COUNT] === $maxCount
                            && !in_array($entity, $entityList[$entityType], true)
                        )
                        {
                            static::$availableAppCount[$key] = false;
                        }
 
                        if (
                            static::$availableAppCount[$key] === false
                            && (
                                in_array($entity, Immune::getList(), true)
                                || (
                                    !static::needCheckCount()
                                    && in_array($entity, $entityList[$entityType], true)
                                )
                            )
                        )
                        {
                            static::$availableAppCount[$key] = true;
                        }
                    }
                }
            }
        }
 
        return static::$availableAppCount[$key];
    }
 
    public static function getAvailableCount() : int
    {
        $result = -1;
        $subscriptionActive = Client::isSubscriptionAvailable();
        if (!$subscriptionActive)
        {
            $restUnlimitedFinish = false;
            $count = static::DEFAULT_AVAILABLE_COUNT;
            if (Loader::includeModule('bitrix24'))
            {
                if (Client::isSubscriptionAccess())
                {
                    $restUnlimitedFinish = Option::get(static::MODULE_ID, static::OPTION_REST_UNLIMITED_FINISH, null);
                    $count = (int) \Bitrix\Bitrix24\Feature::getVariable('rest_no_subscribe_access_limit');
                    if (\CBitrix24::getLicensePrefix() === 'ua')
                    {
                        $count = -1;
                    }
                }
            }
            else
            {
                $count = (int) Option::get(
                    static::MODULE_ID,
                    static::OPTION_AVAILABLE_COUNT,
                    static::DEFAULT_AVAILABLE_COUNT
                );
            }
            if (
                (!$restUnlimitedFinish || $restUnlimitedFinish < time())
                && $count >= 0
            )
            {
                $result = $count;
            }
        }
 
        return $result;
    }
 
    public static function getActiveEntity($force = false)
    {
        $option = Option::get(static::MODULE_ID, static::OPTION_APP_USAGE_LIST, null);
        if ($force || is_null($option))
        {
            $result = static::calcUsageEntity();
            Option::set(static::MODULE_ID, static::OPTION_APP_USAGE_LIST, Json::encode($result));
        }
        else
        {
            try
            {
                $result = Json::decode($option);
            }
            catch (\Exception $exception)
            {
                $result = [];
            }
            if (!is_array($result))
            {
                $result = [];
            }
        }
 
        return $result;
    }
 
    private static function calcUsageEntity()
    {
        $result = [
            static::ENTITY_TYPE_APP => [],
            static::ENTITY_TYPE_APP_STATUS => [],
            static::ENTITY_COUNT => 0
        ];
        $immuneList = Immune::getList();
 
        $res = AppTable::getList(
            [
                'filter' => [
                    '=ACTIVE' => AppTable::ACTIVE,
                ],
                'select' => [
                    'CODE',
                    'STATUS',
                ],
            ]
        );
        while ($item = $res->fetch())
        {
            if (!in_array($item['CODE'], $immuneList, true))
            {
                if (!isset($result[static::ENTITY_TYPE_APP_STATUS][$item['STATUS']]))
                {
                    $result[static::ENTITY_TYPE_APP_STATUS][$item['STATUS']] = 0;
                }
                $result[static::ENTITY_TYPE_APP_STATUS][$item['STATUS']]++;
 
                if ($item['STATUS'] === AppTable::STATUS_LOCAL)
                {
                    $result[static::ENTITY_TYPE_APP][] = $item['CODE'];
                }
 
                if ($item['STATUS'] === AppTable::STATUS_FREE)
                {
                    $result[static::ENTITY_TYPE_APP][] = $item['CODE'];
                    $result[static::ENTITY_COUNT]++;
                }
            }
        }
 
        return $result;
    }
 
    public static function getHelperCode($action = '', $entityType = '', $entityData = []) : string
    {
        if ($action === static::ACTION_BUY)
        {
            return 'limit_subscription_market_trial_access';
        }
 
        if ($entityType === static::ENTITY_TYPE_APP && !is_array($entityData))
        {
            $entityData = AppTable::getByClientId($entityData);
        }
 
        $code = '';
        $dateFinish = Client::getSubscriptionFinalDate();
        $entity = static::getActiveEntity();
        $maxCount = static::getAvailableCount();
        $isB24 = ModuleManager::isModuleInstalled('bitrix24') && Loader::includeModule('bitrix24');
        $isSubscriptionFinished = $dateFinish && $dateFinish < (new Date());
        $isSubscriptionAccess = Client::isSubscriptionAccess();
        $isSubscriptionDemoAvailable = Client::isSubscriptionDemoAvailable() && !$dateFinish;
        $isSubscriptionAvailable = Client::isSubscriptionAvailable();
        $canBuySubscription = Client::canBuySubscription();
        $isDemoSubscription = Client::isSubscriptionDemo();
        $isCanInstallInDemo = true;
        if (
            !empty($entityData['HOLD_INSTALL_BY_TRIAL'])
            && $entityData['HOLD_INSTALL_BY_TRIAL'] === 'Y'
        )
        {
            $isCanInstallInDemo = false;
        }
 
        $license = $isB24 ? \CBitrix24::getLicenseFamily() : '';
        $isDemo = $license === 'demo';
        $isMinLicense = $isB24 && mb_strpos($license, 'project') === 0;
        $isMaxLicense = $isB24 && ($license === 'ent' || $license === 'pro' || mb_strpos($license, 'company') === 0);
 
        $isMaxApplication = false;
        if ($maxCount >= 0 && $entity[static::ENTITY_COUNT] >= $maxCount)
        {
            $isMaxApplication = true;
        }
 
        $isMaxApplicationDemo = false;
        if ($entity[static::ENTITY_COUNT] >= static::DEFAULT_AVAILABLE_COUNT_DEMO)
        {
            $isMaxApplicationDemo = true;
        }
 
        $hasPaidApplication = false;
        if (
            $entity[static::ENTITY_TYPE_APP_STATUS][AppTable::STATUS_PAID] > 0
            || $entity[static::ENTITY_TYPE_APP_STATUS][AppTable::STATUS_SUBSCRIPTION] > 0
        )
        {
            $hasPaidApplication = true;
        }
 
        $isFreeEntity = false;
        if ($entityType === static::ENTITY_TYPE_INTEGRATION || $entityType === static::ENTITY_TYPE_AP_CONNECT)
        {
            $isFreeEntity = true;
        }
        elseif (!empty($entityData))
        {
            if (
                $entityData['ID'] > 0
                && (isset($entityData['ACTIVE']) && $entityData['ACTIVE'])
                && (
                    $entityData['STATUS'] === AppTable::STATUS_FREE
                    || $entityData['STATUS'] === AppTable::STATUS_LOCAL
                )
            )
            {
                $isFreeEntity = true;
            }
            elseif (
                (
                !isset($entityData['ACTIVE'])
                || !$entityData['ACTIVE']
                )
                && !(
                    $entityData['BY_SUBSCRIPTION'] === 'Y'
                    || ($entityData['FREE'] === 'N' && !empty($entityData['PRICE']))
                )
            )
            {
                $isFreeEntity = true;
            }
        }
 
        $isUsedDemoLicense = false;
        if ($isB24 && (int) Option::get('bitrix24', 'DEMO_START', 0) > 0)
        {
            $isUsedDemoLicense = true;
        }
 
        if (!static::isActiveRules())
        {
            if (
                !empty($entityData)
                && (
                    $entityData['BY_SUBSCRIPTION'] === 'Y'
                    || ($entityData['ID'] > 0 && $entityData['STATUS'] === AppTable::STATUS_SUBSCRIPTION)
                )
            )
            {
                if ($isSubscriptionDemoAvailable)
                {
                    // activate demo subscription
                    $code = 'limit_subscription_market_access';
                }
                elseif ($isB24 && $isDemo)
                {
                    // choose license with subscription
                    $code = 'limit_subscription_market_tarifwithmarket';
                }
                else
                {
                    // choose subscription
                    $code = 'limit_subscription_market_marketpaid';
                }
            }
        }
        elseif (!$isSubscriptionAccess)
        {
            if ($isMinLicense)
            {
                if ($isUsedDemoLicense)
                {
                    $code = 'limit_free_rest_hold_no_demo';
                }
                elseif ($entityType === static::ENTITY_TYPE_AP_CONNECT)
                {
                    $code = 'limit_market_bus';
                }
                else
                {
                    $code = 'limit_free_rest_hold';
                }
            }
        }
        elseif (!static::isAvailable())
        {
            if ($hasPaidApplication || !$isFreeEntity)
            {
                if ($isSubscriptionDemoAvailable)
                {
                    // activate demo subscription
                    $code = 'limit_subscription_market_access';
                }
                elseif (!$isB24)
                {
                    // choose subscription
                    $code = 'plus_need_trial';
                }
                else
                {
                    // choose license with subscription
                    $code = 'limit_subscription_market_tarifwithmarket';
                    if ($action === static::ACTION_OPEN)
                    {
                        $code = 'installed_plus_buy_license_with_plus';
                    }
                }
            }
            elseif ($isB24 && !$isUsedDemoLicense)
            {
                // activate demo license
                if ($entityType === static::ENTITY_TYPE_AP_CONNECT)
                {
                    $code = 'limit_market_bus';
                }
                else
                {
                    $code = 'limit_free_rest_hold';
                }
            }
            elseif ($isB24 && !$isMaxApplicationDemo)
            {
                // choose license
                $code = 'limit_free_rest_hold_no_demo';
            }
            elseif ($isSubscriptionDemoAvailable)
            {
                // activate demo subscription
                $code = 'limit_subscription_market_marketpaid';
            }
            elseif ($isB24 && $isSubscriptionAccess)
            {
                // choose license with subscription
                $code = 'limit_subscription_market_tarifwithmarket';
                if ($action === static::ACTION_OPEN)
                {
                    $code = 'limit_free_apps_buy_license_with_plus';
                }
            }
            elseif (!$isB24 && $isSubscriptionAccess)
            {
                // choose subscription
                $code = 'plus_need_trial';
            }
        }
        elseif ($isB24 && !$isDemo && $isMaxApplication && $isFreeEntity && !$isMaxLicense)
        {
            if (!$isUsedDemoLicense)
            {
                // activate demo license
                if ($entityType === static::ENTITY_TYPE_AP_CONNECT)
                {
                    $code = 'limit_market_bus';
                }
                else
                {
                    $code = 'limit_free_apps_need_demo';
                }
            }
            else
            {
                // choose license
                $code = 'limit_free_apps_buy_license';
            }
        }
        elseif (
            $isSubscriptionDemoAvailable
            && $isCanInstallInDemo
            && ($hasPaidApplication || $isMaxApplication || !$isFreeEntity)
        )
        {
            if (!$isFreeEntity)
            {
                // activate demo subscription
                $code = 'limit_subscription_market_access_buy_marketplus';
            }
            elseif ($isB24 && $isDemo)
            {
                // activate demo subscription
                $code = 'limit_subscription_market_marketpaid';
            }
            else
            {
                // activate demo subscription
                $code = 'limit_subscription_market_access';
            }
        }
        elseif ($isDemoSubscription && !$isCanInstallInDemo)
        {
            // only paid subscription app
            $code = 'subscription_market_paid_access';
        }
        elseif ($canBuySubscription)
        {
            if ($isSubscriptionFinished)
            {
                // choose subscription
                $code = 'limit_subscription_market_access_buy_marketplus';
            }
            else
            {
                // choose new subscription
                $code = 'plus_need_trial';
            }
        }
        elseif ($isB24 && $isDemo)
        {
            if (!$isSubscriptionDemoAvailable)
            {
                // choose license with subscription
                $code = 'limit_subscription_market_tarifwithmarket';
            }
            else
            {
                // activate demo subscription
                $code = 'limit_subscription_market_access';
            }
        }
        elseif (!$isSubscriptionAvailable)
        {
            $code = 'limit_free_rest_hold_no_demo';
        }
 
        return $code;
    }
 
    public static function resetToFree()
    {
        static::reset();
        Option::delete(static::MODULE_ID, ['name' => static::OPTION_HOLD_CHECK_COUNT_APP]);
        \Bitrix\Rest\Marketplace\Notification::setLastCheckTimestamp(time());
 
        return true;
    }
 
    public static function onBitrix24LicenseChange($licenseType)
    {
        static::reset();
        if (
            !Client::isSubscriptionAccess()
            && Loader::includeModule('bitrix24')
            && in_array($licenseType, \CBitrix24::PAID_EDITIONS, true)
        )
        {
            Option::set(static::MODULE_ID, static::OPTION_HOLD_CHECK_COUNT_APP, 'Y');
        }
    }
 
    public static function needCheckCount()
    {
        if (!static::isActiveRules())
        {
            return false;
        }
 
        return Option::get(static::MODULE_ID, static::OPTION_HOLD_CHECK_COUNT_APP, 'N') === 'N';
    }
 
    public static function isActiveRules()
    {
        return
            ModuleManager::isModuleInstalled('bitrix24')
            || Option::get(static::MODULE_ID, static::OPTION_ACCESS_ACTIVE, 'N') === 'Y'
        ;
    }
 
    public static function calcUsageEntityAgent($period = false)
    {
        static::getActiveEntity(true);
        return $period === true ? '\Bitrix\Rest\Engine\Access::calcUsageEntityAgent(true);' : '';
    }
 
    public static function reset() : bool
    {
        static::$availableApp = [];
        static::$availableAppCount = [];
 
        return true;
    }
}