licensemanager.php

<?php
 
namespace Bitrix\Mail\Helper;
 
use Bitrix\Mail\Internals\MailEntityOptionsTable;
use Bitrix\Main;
use Bitrix\Bitrix24;
use Bitrix\Mail\MailboxTable;
use Bitrix\Mail\Integration\Im\Notification;
use Bitrix\Main\Mail\Internal\SenderTable;
 
class LicenseManager
{
    private const MAILBOX_IS_LOCKED_PROPERTY = 1;
    private const MAILBOX_IS_AVAILABLE_PROPERTY = 0;
 
    public static function checkTheMailboxForSyncAvailability(int $checkedMailboxId): bool
    {
        $maxCountAvailableMailboxes = self::getUserMailboxesLimit();
 
        if ($maxCountAvailableMailboxes < 0)
        {
            return true;
        }
 
        static $checkedMailboxes = [];
 
        if (!array_key_exists($checkedMailboxId, $checkedMailboxes))
        {
            $checkedMailboxes[$checkedMailboxId] = MailboxTable::getById($checkedMailboxId)->fetch();
        }
 
        $mailboxAvailabilitySyncStatus = false;
 
        if ($checkedMailboxes[$checkedMailboxId] && isset($checkedMailboxes[$checkedMailboxId]['USER_ID']))
        {
            $userId = (int) $checkedMailboxes[$checkedMailboxId]['USER_ID'];
 
            static $userMailboxes = [];
 
            if (!array_key_exists($userId, $userMailboxes))
            {
                $userMailboxes[$userId] = MailboxTable::getList([
                    'select' => [
                        'ID',
                    ],
                    'filter' => [
                        '=USER_ID' => $userId,
                        '=ACTIVE' => 'Y',
                    ],
                    'order' => [
                        'ID' => 'ASC',
                    ],
                ])->fetchAll();
            }
 
            $mailboxNumber = 1;
 
            foreach ($userMailboxes[$userId] as $mailbox)
            {
                if (isset($mailbox['ID']))
                {
                    $mailboxId = (int) $mailbox['ID'];
                    if ($mailboxNumber <= $maxCountAvailableMailboxes)
                    {
                        if ($mailboxId === $checkedMailboxId)
                        {
                            $mailboxAvailabilitySyncStatus = true;
                        }
 
                        static::removeTariffRestrictionsOnTheMailbox($mailboxId);
                    }
                    else
                    {
                        static::imposeTariffRestrictionsOnTheMailbox($mailboxId);
                    }
                }
 
                $mailboxNumber ++;
            }
        }
 
        return $mailboxAvailabilitySyncStatus;
    }
 
    private static function getMailboxTariffRestrictions($mailboxId, $overwriteCache = false): int
    {
        static $mailboxesRestriction = [];
 
        if ($overwriteCache || !array_key_exists($mailboxId, $mailboxesRestriction))
        {
            $filter = [
                '=MAILBOX_ID' => $mailboxId,
                '=ENTITY_TYPE' => 'MAILBOX',
                '=ENTITY_ID' => $mailboxId,
                '=PROPERTY_NAME' => 'TARIFF_RESTRICTIONS',
            ];
 
            $restriction = MailEntityOptionsTable::getList([
                'select' => [
                    'VALUE',
                ],
                'filter' => $filter,
                'limit' => 1,
            ])->fetch();
 
            if (isset($restriction['VALUE']))
            {
                $mailboxesRestriction[$mailboxId] = (int) $restriction['VALUE'];
            }
            else
            {
                $mailboxesRestriction[$mailboxId] = 0;
            }
        }
 
        return $mailboxesRestriction[$mailboxId];
    }
 
    private static function removeTariffRestrictionsOnTheMailbox($mailboxId): void
    {
        if (static::getMailboxTariffRestrictions($mailboxId) !== static::MAILBOX_IS_AVAILABLE_PROPERTY)
        {
            static::setTheOptionOfTariffRestrictions($mailboxId, static::MAILBOX_IS_AVAILABLE_PROPERTY);
            static::getMailboxTariffRestrictions($mailboxId, true);
        }
    }
 
    private static function imposeTariffRestrictionsOnTheMailbox($mailboxId): void
    {
        if (static::getMailboxTariffRestrictions($mailboxId) !== static::MAILBOX_IS_LOCKED_PROPERTY)
        {
            Notification::add(
                null,
                'imposed_tariff_restrictions_on_the_mailbox',
                null,
                $mailboxId
            );
 
            static::setTheOptionOfTariffRestrictions($mailboxId, static::MAILBOX_IS_LOCKED_PROPERTY);
            static::getMailboxTariffRestrictions($mailboxId, true);
        }
    }
 
    private static function setTheOptionOfTariffRestrictions($mailboxId, $optionValue): void
    {
        $filter = [
            '=MAILBOX_ID' => $mailboxId,
            '=ENTITY_TYPE' => 'MAILBOX',
            '=ENTITY_ID' => $mailboxId,
            '=PROPERTY_NAME' => 'TARIFF_RESTRICTIONS',
        ];
 
        $keyRow = [
            'MAILBOX_ID' => $mailboxId,
            'ENTITY_TYPE' => 'MAILBOX',
            'ENTITY_ID' => $mailboxId,
            'PROPERTY_NAME' => 'TARIFF_RESTRICTIONS',
        ];
 
        $fields = $keyRow;
 
        $fields['DATE_INSERT'] = new Main\Type\DateTime();
        $fields['VALUE'] = $optionValue;
 
        if (MailEntityOptionsTable::getCount($filter))
        {
            MailEntityOptionsTable::update(
                $keyRow,
                [
                    'VALUE' => $optionValue,
                    'DATE_INSERT' => new Main\Type\DateTime(),
                ],
            );
        }
        else
        {
            MailEntityOptionsTable::add(
                $fields
            );
        }
    }
 
    public static function isEnabledNotificationOfMailMessageInCrm($userId): bool
    {
        if (Main\Loader::includeModule('crm') && Main\Loader::includeModule('im'))
        {
            foreach (
                [
                    \CIMSettings::CLIENT_SITE,
                    \CIMSettings::CLIENT_MAIL,
                    \CIMSettings::CLIENT_PUSH,
                ] as $clientId
            )
            {
                if (
                    \CIMSettings::GetNotifyAccess(
                        $userId,
                        'crm',
                        \CCrmNotifierSchemeType::IncomingEmailName,
                        $clientId
                    )
                )
                {
                    return true;
                }
            }
        }
 
        return false;
    }
 
    private static function getCountSenders(int $userId = 0)
    {
        global $USER;
 
        if (!($userId > 0 || (is_object($USER) && $USER->isAuthorized())))
        {
            return false;
        }
 
        if (!($userId > 0))
        {
            $userId = $USER->getId();
        }
 
 
        return SenderTable::getCount([
            'IS_CONFIRMED' => true,
            [
                'LOGIC' => 'OR',
                '=USER_ID' => $userId,
                'IS_PUBLIC' => true,
            ],
        ]);
    }
 
    public static function isMailClientReadyToUse($userId = null): bool
    {
        global $USER;
 
        if (!($userId > 0 || (is_object($USER) && $USER->isAuthorized())))
        {
            return false;
        }
 
        if (!($userId > 0))
        {
            $userId = $USER->getId();
        }
 
        if (
            self::isSyncAvailable()
            && (self::getCountSenders($userId) || count(MailboxTable::getUserMailboxes($userId)) > 0 )
            && self::checkUserHasNotExceededTheConnectedMailboxesLimit($userId)
        )
        {
            return true;
        }
 
        return false;
    }
 
    public static function checkUserHasNotExceededTheConnectedMailboxesLimit($userId = null): bool
    {
        global $USER;
 
        if (!($userId > 0 || (is_object($USER) && $USER->isAuthorized())))
        {
            return false;
        }
 
        if (!($userId > 0))
        {
            $userId = $USER->getId();
        }
 
        $userMailboxesLimit = LicenseManager::getUserMailboxesLimit();
 
        if (
            $userMailboxesLimit >= 0
            && count(MailboxTable::getTheOwnersMailboxes($userId)) > $userMailboxesLimit
        )
        {
            return false;
        }
 
        return true;
    }
 
    public static function isSyncAvailable()
    {
        if (!Main\Loader::includeModule('bitrix24'))
        {
            return true;
        }
 
        return (bool) Bitrix24\Feature::isFeatureEnabled('mail_mailbox_sync');
    }
 
    public static function getSharedMailboxesLimit()
    {
        if (!Main\Loader::includeModule('bitrix24'))
        {
            return -1;
        }
 
        return (int) Bitrix24\Feature::getVariable('mail_shared_mailboxes_limit');
    }
 
    public static function getUserMailboxesLimit()
    {
        if (!Main\Loader::includeModule('bitrix24'))
        {
            return -1;
        }
 
        if (!static::isSyncAvailable())
        {
            return 0;
        }
 
        return (int) Bitrix24\Feature::getVariable('mail_user_mailboxes_limit');
    }
 
    public static function getEmailsLimitToSendMessage(): int
    {
        if (Main\Loader::includeModule('bitrix24') && (!static::isSyncAvailable() || \CBitrix24::IsDemoLicense()))
        {
            return 1;
        }
 
        return -1;
    }
 
    public static function getSyncOldLimit()
    {
        if (!Main\Loader::includeModule('bitrix24'))
        {
            return (int) Main\Config\Option::get('mail', 'sync_old_limit2', -1);
        }
 
        return (int) Bitrix24\Feature::getVariable('mail_sync_old_limit');
    }
 
    public static function isCleanupOldEnabled()
    {
        return static::getSyncOldLimit() > 0;
    }
 
}