licensemanager.php

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

<?php
 
namespace Bitrix\Mail\Helper;
 
use Bitrix\Main\ORM\Query\Join;
use Bitrix\Main\ORM\Fields\Relations\Reference;
use Bitrix\Mail\Internals\MailEntityOptionsTable;
use Bitrix\Main;
use Bitrix\Bitrix24;
use Bitrix\Mail\MailboxTable;
use Bitrix\Main\Mail\Internal\SenderTable;
use Bitrix\Main\Type\DateTime;
use Bitrix\Mail\Integration\Im\Notification;

class LicenseManager
{
    private const MAILBOX_IS_LOCKED_PROPERTY = 1;
    private const MAILBOX_IS_AVAILABLE_PROPERTY = 0;
 
    private static function sendNotificationsAboutBlockedMailboxes($ids): void
    {
        foreach ($ids as $id)
        {
            Notification::add(
                null,
                'imposed_tariff_restrictions_on_the_mailbox',
                null,
                $id,
            );
        }
    }
 
    private static function getTariffRestrictionsMailboxListsByDBData($mailboxes, $filterByStatus = null): array
    {
        $lists = [
            'IDS_FOR_ADD' => [],
            'IDS_FOR_UPDATE' => [],
            'IDS_ALL' => [],
        ];
 
        foreach ($mailboxes as $mailbox)
        {
            $mailboxId = (int) $mailbox['ID'];
 
            if (is_null($mailbox['TARIFF_RESTRICTIONS']))
            {
                $lists['IDS_FOR_ADD'][] = $mailboxId;
                $lists['IDS_ALL'][] = $mailboxId;
            }
            else if(is_null($filterByStatus) || (int)$mailbox['TARIFF_RESTRICTIONS'] === $filterByStatus)
            {
                $lists['IDS_FOR_UPDATE'][] = $mailboxId;
                $lists['IDS_ALL'][] = $mailboxId;
            }
        }
 
        return $lists;
    }
 
    private static function checkIdInTariffRestrictionsMailboxLists($checkedMailboxId, $lists): bool
    {
        foreach ($lists as $list)
        {
            foreach ($list as $id)
            {
                if ($id === $checkedMailboxId)
                {
                    return true;
                }
            }
        }
 
        return false;
    }
 
    private static function getAvailabilitySyncStatusByMailboxList($checkedMailboxId, $mailboxList): bool
    {
        foreach ($mailboxList as $mailbox)
        {
            if ($checkedMailboxId === (int) $mailbox['ID'])
            {
                return !($mailbox['TARIFF_RESTRICTIONS']);
            }
        }
 
        return true;
    }
 
    public static function checkTheMailboxForSyncAvailability(int $checkedMailboxId, ?int $ownerMailboxUserId = null): bool
    {
        $maxCountAvailableMailboxes = self::getUserMailboxesLimit();
        static $checkedMailboxes = [];
 
        if (!array_key_exists($checkedMailboxId, $checkedMailboxes))
        {
            if (is_null($ownerMailboxUserId))
            {
                $checkedMailboxes[$checkedMailboxId] = MailboxTable::getList(([
                    'select' => [
                        'ID',
                        'USER_ID',
                    ],
                    'filter' => [
                        '=ID' => $checkedMailboxId,
                    ],
                ]))->fetch();
            }
            else
            {
                $checkedMailboxes[$checkedMailboxId] = [
                    'ID' => $checkedMailboxId,
                    'USER_ID' => $ownerMailboxUserId,
                ];
            }
        }
 
        if ($checkedMailboxes[$checkedMailboxId] && isset($checkedMailboxes[$checkedMailboxId]['USER_ID']))
        {
            $userId = (int) $checkedMailboxes[$checkedMailboxId]['USER_ID'];
 
            static $userMailboxes = [];
 
            if (!array_key_exists($userId, $userMailboxes))
            {
                $userMailboxes = MailboxTable::query()->addSelect('ID')
                ->setSelect([
                    'ID',
                    'TARIFF_RESTRICTIONS' => 'OPTIONS.VALUE',
                ])
                ->where('USER_ID', $userId)
                ->where('ACTIVE', 'Y')
                ->registerRuntimeField(
                    '',
                    new Reference(
                        'OPTIONS',
                        MailEntityOptionsTable::class,
                        Join::on('this.ID', 'ref.MAILBOX_ID')->where('ref.PROPERTY_NAME', 'TARIFF_RESTRICTIONS'),
                        ['join_type' => Join::TYPE_LEFT],
                    ),
                )->fetchAll();
            }
 
            if ($maxCountAvailableMailboxes < 0)
            {
                $activateMailboxes = self::getTariffRestrictionsMailboxListsByDBData(array_slice($userMailboxes, 0, count($userMailboxes)), static::MAILBOX_IS_LOCKED_PROPERTY);
                static::changeTariffRestrictionsOnTheMailboxes($activateMailboxes, static::MAILBOX_IS_AVAILABLE_PROPERTY);
                $mailboxAvailabilitySyncStatus = true;
            }
            else
            {
                $activateMailboxes = self::getTariffRestrictionsMailboxListsByDBData(array_slice($userMailboxes, 0, $maxCountAvailableMailboxes), static::MAILBOX_IS_LOCKED_PROPERTY);
                $blockMailboxes = self::getTariffRestrictionsMailboxListsByDBData(array_slice($userMailboxes, $maxCountAvailableMailboxes), static::MAILBOX_IS_AVAILABLE_PROPERTY);
 
                if (self::checkIdInTariffRestrictionsMailboxLists($checkedMailboxId, $activateMailboxes))
                {
                    $mailboxAvailabilitySyncStatus = true;
                }
                else if(self::checkIdInTariffRestrictionsMailboxLists($checkedMailboxId, $blockMailboxes))
                {
                    $mailboxAvailabilitySyncStatus = false;
                }
                else
                {
                    $mailboxAvailabilitySyncStatus = self::getAvailabilitySyncStatusByMailboxList($checkedMailboxId, $userMailboxes);
                }
 
                self::sendNotificationsAboutBlockedMailboxes($blockMailboxes['IDS_ALL']);
                static::changeTariffRestrictionsOnTheMailboxes($activateMailboxes, static::MAILBOX_IS_AVAILABLE_PROPERTY);
                static::changeTariffRestrictionsOnTheMailboxes($blockMailboxes, static::MAILBOX_IS_LOCKED_PROPERTY);
            }
 
            return $mailboxAvailabilitySyncStatus;
        }
 
        return false;
    }
 
    public static function changeTariffRestrictionsOnTheMailboxes($tariffRestrictionsMailboxLists, $tariffRestrictionsType): void
    {
        if (isset($tariffRestrictionsMailboxLists['IDS_FOR_ADD']) && count($tariffRestrictionsMailboxLists['IDS_FOR_ADD']))
        {
            $rowsForAdd = [];
            foreach ($tariffRestrictionsMailboxLists['IDS_FOR_ADD'] as $id)
            {
                $rowsForAdd[] = [
                    'MAILBOX_ID' => $id,
                    'ENTITY_TYPE' => 'MAILBOX',
                    'ENTITY_ID' => $id,
                    'PROPERTY_NAME' => 'TARIFF_RESTRICTIONS',
                    'VALUE' => $tariffRestrictionsType,
                    'DATE_INSERT' => new DateTime(),
                ];
            }
 
            foreach ($rowsForAdd as $row)
            {
                $filter = [
                    '=MAILBOX_ID' => $row['MAILBOX_ID'],
                    '=ENTITY_TYPE' => 'MAILBOX',
                    '=ENTITY_ID' => $row['ENTITY_ID'],
                    '=PROPERTY_NAME' => 'TARIFF_RESTRICTIONS',
                ];
 
                $keyRow = [
                    'MAILBOX_ID' => $row['MAILBOX_ID'],
                    'ENTITY_TYPE' => 'MAILBOX',
                    'ENTITY_ID' => $row['ENTITY_ID'],
                    'PROPERTY_NAME' => 'TARIFF_RESTRICTIONS',
                ];
 
                if (MailEntityOptionsTable::getCount($filter))
                {
                    MailEntityOptionsTable::update(
                        $keyRow,
                        [
                            'VALUE' => $row['VALUE'],
                            'DATE_INSERT' => new DateTime(),
                        ],
                    );
                }
                else
                {
                    MailEntityOptionsTable::add($row);
                }
            }
        }
 
        if (isset($tariffRestrictionsMailboxLists['IDS_FOR_UPDATE']) && count($tariffRestrictionsMailboxLists['IDS_FOR_UPDATE']))
        {
            $rowsForUpdate = [];
            foreach ($tariffRestrictionsMailboxLists['IDS_FOR_UPDATE'] as $id)
            {
                $rowsForUpdate[] = [
                    'MAILBOX_ID' => $id,
                    'ENTITY_TYPE' => 'MAILBOX',
                    'ENTITY_ID' => $id,
                    'PROPERTY_NAME' => 'TARIFF_RESTRICTIONS',
                ];
            }
 
            if (count($rowsForUpdate))
            {
                MailEntityOptionsTable::updateMulti($rowsForUpdate, [
                    'VALUE' => $tariffRestrictionsType,
                    'DATE_INSERT' => new DateTime(),
                ]);
            }
        }
    }
 
    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(): bool
    {
        if (Main\Application::getConnection()->getType() === 'pgsql')
        {
            return false; // not implemented yet
        }
 
        return static::getSyncOldLimit() > 0;
    }
 
}