GeneralChat.php

<?php
 
namespace Bitrix\Im\V2\Chat;
 
use Bitrix\Im\Model\ChatTable;
use Bitrix\Im\V2\Chat;
use Bitrix\Im\V2\Entity\User\User;
use Bitrix\Im\V2\Relation;
use Bitrix\Im\V2\Result;
use Bitrix\Im\V2\Service\Context;
use Bitrix\Intranet\Settings\CommunicationSettings;
use Bitrix\Main\Application;
use Bitrix\Main\Config\Option;
use Bitrix\Main\Data\Cache;
use Bitrix\Main\Loader;
use Bitrix\Main\Localization\Loc;
 
class GeneralChat extends GroupChat
{
    public const GENERAL_MESSAGE_TYPE_JOIN = 'join';
    public const GENERAL_MESSAGE_TYPE_LEAVE = 'leave';
    public const ID_CACHE_ID = 'general_chat_id';
    public const MANAGERS_CACHE_ID = 'general_chat_managers';
    public const DISABLE_GENERAL_CHAT_OPTION = 'disable_general_chat';
 
    protected static ?self $instance = null;
    protected static bool $wasSearched = false;
    protected static Result $resultFind;
 
    protected function getDefaultType(): string
    {
        return self::IM_TYPE_OPEN;
    }
 
    protected function getDefaultEntityType(): string
    {
        return self::ENTITY_TYPE_GENERAL;
    }
 
    public function hasPostAccess(?int $userId = null): bool
    {
        if ($this->getId() === null || $this->getId() === 0)
        {
            return false;
        }
 
        if ($this->getCanPost() === Chat::MANAGE_RIGHTS_NONE)
        {
            return false;
        }
 
        $userId ??= $this->getContext()->getUserId();
        if ($this->getCanPost() === Chat::MANAGE_RIGHTS_MEMBER)
        {
            return true;
        }
 
        if ($this->getAuthorId() === $userId)
        {
            return true;
        }
 
        if ($this->getCanPost() === Chat::MANAGE_RIGHTS_OWNER)
        {
            return false;
        }
 
        return in_array($userId, $this->getManagerList(), true);
    }
 
    public static function isEnable(): bool
    {
        return Option::get('im', self::DISABLE_GENERAL_CHAT_OPTION, 'N') === 'N';
    }
 
    public function getManagerList(): array
    {
        $cache = static::getCache(self::MANAGERS_CACHE_ID);
 
        $cachedManagerList = $cache->getVars();
 
        if ($cachedManagerList !== false)
        {
            return $cachedManagerList;
        }
 
        $managerList = $this->getRelations(['FILTER' => ['MANAGER' => 'Y']])->getUserIds();
 
        $cache->startDataCache();
        $cache->endDataCache($managerList);
 
        return $this->getRelations(['FILTER' => ['MANAGER' => 'Y']])->getUserIds();
    }
 
    public static function get(): ?GeneralChat
    {
        if (self::$wasSearched)
        {
            return self::$instance;
        }
 
        $chatId = static::getGeneralChatId();
        $chat = Chat::getInstance($chatId);
        self::$instance = ($chat instanceof NullChat) ? null : $chat;
        self::$wasSearched = true;
 
        return self::$instance;
    }
 
    public static function getGeneralChatId(): ?int
    {
        if (!static::isEnable())
        {
            return 0;
        }
 
        $cache = static::getCache(self::ID_CACHE_ID);
 
        $cachedId = $cache->getVars();
 
        if ($cachedId !== false)
        {
            return $cachedId ?? 0;
        }
 
        $result = ChatTable::query()
            ->setSelect(['ID'])
            ->where('TYPE', Chat::IM_TYPE_OPEN)
            ->where('ENTITY_TYPE', Chat::ENTITY_TYPE_GENERAL)
            ->fetch() ?: []
        ;
 
        $chatId = $result['ID'] ?? null;
        $cache->startDataCache();
        $cache->endDataCache($chatId);
 
        return $chatId ?? 0;
    }
 
    public function setManagers(array $managerIds): Chat
    {
        static::cleanGeneralChatCache(self::MANAGERS_CACHE_ID);
 
        return parent::setManagers($managerIds);
    }
 
    public static function find(array $params = [], ?Context $context = null): Result
    {
        if (isset(self::$resultFind))
        {
            return self::$resultFind;
        }
 
        $result = new Result;
 
        $row = ChatTable::query()
            ->setSelect(['ID', 'TYPE', 'ENTITY_TYPE', 'ENTITY_ID'])
            ->where('ENTITY_TYPE', self::ENTITY_TYPE_GENERAL)
            ->setLimit(1)
            ->setOrder(['ID' => 'DESC'])
            ->fetch()
        ;
 
        if ($row)
        {
            $result->setResult([
                'ID' => (int)$row['ID'],
                'TYPE' => $row['TYPE'],
                'ENTITY_TYPE' => $row['ENTITY_TYPE'],
                'ENTITY_ID' => $row['ENTITY_ID'],
            ]);
        }
 
        self::$resultFind = $result;
 
        return $result;
    }
 
    public function add(array $params, ?Context $context = null): Result
    {
        $result = new Result;
 
        $generalChatResult = self::find();
        if ($generalChatResult->hasResult())
        {
            $generalChat = new GeneralChat(['ID' => $generalChatResult->getResult()['ID']]);
            return  $result->setResult([
                'CHAT_ID' => $generalChat->getChatId(),
                'CHAT' => $generalChat,
            ]);
        }
 
        $installUsers = $this->getUsersForInstall();
 
        $params = [
            'TYPE' => self::IM_TYPE_OPEN,
            'ENTITY_TYPE' => self::ENTITY_TYPE_GENERAL,
            'COLOR' => 'AZURE',
            'TITLE' => Loc::getMessage('IM_CHAT_GENERAL_TITLE'),
            'DESCRIPTION' => Loc::getMessage('IM_CHAT_GENERAL_DESCRIPTION'),
            'AUTHOR_ID' => 0,
            'USER_COUNT' => count($installUsers),
        ];
 
        $chat = new static($params);
        $chat->setExtranet(false);
        $chat->save();
 
        if (!$chat->getChatId())
        {
            return $result->addError(new ChatError(ChatError::CREATION_ERROR));
        }
 
        $chat->sendBanner();
 
        $adminIds = [];
        if (Loader::includeModule('bitrix24'))
        {
            $adminIds = \CBitrix24::getAllAdminId();
        }
 
        foreach ($installUsers as $user)
        {
            $relation = new Relation();
            $relation->setChatId($chat->getChatId());
            $relation->setUserId((int)$user['ID']);
            $relation->setManager(in_array((int)$user['ID'], $adminIds, true));
            $relation->setMessageType(self::IM_TYPE_OPEN);
            $relation->setStatus(IM_STATUS_READ);
            $relation->save();
        }
 
        $chat->addIndex();
 
        self::linkGeneralChat($chat->getChatId());
 
        $result->setResult([
            'CHAT_ID' => $chat->getChatId(),
            'CHAT' => $chat,
        ]);
 
        self::cleanGeneralChatCache(self::ID_CACHE_ID);
        self::cleanGeneralChatCache(self::MANAGERS_CACHE_ID);
        self::cleanCache($chat->getChatId());
 
        return $result;
    }
 
    public static function linkGeneralChat(?int $chatId = null): bool
    {
        if (!$chatId)
        {
            $chatId = self::getGeneralChatId();
        }
 
        if (!$chatId)
        {
            return false;
        }
 
        if (Loader::includeModule('pull'))
        {
            \CPullStack::AddShared([
                'module_id' => 'im',
                'command' => 'generalChatId',
                'params' => [
                    'id' => $chatId
                ],
                'extra' => \Bitrix\Im\Common::getPullExtra()
            ]);
        }
 
        return true;
    }
 
    public static function cleanGeneralChatCache(string $cacheId): void
    {
        Application::getInstance()->getCache()->clean($cacheId, static::getCacheDir());
    }
 
    public static function unlinkGeneralChat(): bool
    {
        if (Loader::includeModule('pull'))
        {
            \CPullStack::AddShared([
                'module_id' => 'im',
                'command' => 'generalChatId',
                'params' => [
                    'id' => 0
                ],
                'extra' => \Bitrix\Im\Common::getPullExtra()
            ]);
        }
 
        static::cleanGeneralChatCache(self::ID_CACHE_ID);
        static::cleanGeneralChatCache(self::MANAGERS_CACHE_ID);
 
        return true;
    }
 
    public function canJoinGeneralChat(int $userId): bool
    {
        if (
            $userId <= 0
            || !self::getGeneralChatId()
            || !Loader::includeModule('intranet')
        )
        {
            return false;
        }
 
        $connection = \Bitrix\Main\Application::getConnection();
        $sql = "
            SELECT DISTINCT U.ID
            FROM
                b_user U
                INNER JOIN b_user_field F ON F.ENTITY_ID = 'USER' AND F.FIELD_NAME = 'UF_DEPARTMENT'
                INNER JOIN b_utm_user UF ON
                    UF.FIELD_ID = F.ID
                    AND UF.VALUE_ID = U.ID
                    AND UF.VALUE_INT > 0
            WHERE
                U.ACTIVE = 'Y'
                AND U.ID = " . $userId . "
                AND F.ENTITY_ID = 'USER'
                AND F.FIELD_NAME = 'UF_DEPARTMENT'
            LIMIT 1
        ";
        if ($connection->query($sql)->fetch())
        {
            return true;
        }
 
        return false;
    }
 
    private function getUsersForInstall(): array
    {
        $externalUserTypes = \Bitrix\Main\UserTable::getExternalUserTypes();
        $types = implode("', '", $externalUserTypes);
        if (Loader::includeModule('intranet'))
        {
            $sql = "
                SELECT DISTINCT U.ID
                FROM
                    b_user U
                    INNER JOIN b_user_field F ON F.ENTITY_ID = 'USER' AND F.FIELD_NAME = 'UF_DEPARTMENT'
                    INNER JOIN b_utm_user UF ON
                        UF.FIELD_ID = F.ID
                        AND UF.VALUE_ID = U.ID
                        AND UF.VALUE_INT > 0
                WHERE
                    U.ACTIVE = 'Y'
                    AND (U.EXTERNAL_AUTH_ID IS NULL OR U.EXTERNAL_AUTH_ID NOT IN ('{$types}') )
                    AND F.ENTITY_ID = 'USER'
                    AND F.FIELD_NAME = 'UF_DEPARTMENT'
            ";
        }
        else
        {
            $sql = "
                SELECT ID
                FROM b_user U
                WHERE 
                    U.ACTIVE = 'Y'
                    AND (U.EXTERNAL_AUTH_ID IS NULL OR U.EXTERNAL_AUTH_ID NOT IN ('{$types}') )
            ";
        }
 
        $connection = \Bitrix\Main\Application::getConnection();
        return $connection->query($sql)->fetchAll();
    }
 
    protected function sendBanner(?int $authorId = null): void
    {
        \CIMMessage::Add([
            'MESSAGE_TYPE' => self::IM_TYPE_CHAT,
            'TO_CHAT_ID' => $this->getChatId(),
            'FROM_USER_ID' => 0,
            'MESSAGE' => Loc::getMessage('IM_CHAT_GENERAL_DESCRIPTION'),
            'SYSTEM' => 'Y',
            'PUSH' => 'N',
            'PARAMS' => [
                'COMPONENT_ID' => 'ChatCreationMessage',
            ]
        ]);
    }
 
    public static function getAutoMessageStatus(string $type): bool
    {
        switch ($type)
        {
            case self::GENERAL_MESSAGE_TYPE_JOIN:
                return (bool)\COption::GetOptionString("im", "general_chat_message_join");
            case self::GENERAL_MESSAGE_TYPE_LEAVE:
                return (bool)\COption::GetOptionString("im", "general_chat_message_leave");
            default:
                return false;
        }
    }
 
    public function getRightsForIntranetConfig(): array
    {
        $result['generalChatCanPostList'] = self::getCanPostList();
        $result['generalChatCanPost'] = $this->getCanPost();
        $result['generalChatShowManagersList'] = self::MANAGE_RIGHTS_MANAGERS;
        $managerIds = $this->getRelations([
            'FILTER' => [
                'MANAGER' => 'Y'
            ]
        ])->getUserIds();
        $managers = array_map(function ($managerId) {
            return 'U' . $managerId;
        }, $managerIds);
        Loader::includeModule('intranet');
        if (method_exists('\Bitrix\Intranet\Settings\CommunicationSettings', 'processOldAccessCodes'))
        {
            $result['generalChatManagersList'] = CommunicationSettings::processOldAccessCodes($managers);
        }
        else
        {
            $result['generalChatManagersList'] = \IntranetConfigsComponent::processOldAccessCodes($managers);
        }
 
        return $result;
    }
 
    protected function getAccessCodesForDiskFolder(): array
    {
        $accessCodes = parent::getAccessCodesForDiskFolder();
        $departmentCode = \CIMDisk::GetTopDepartmentCode();
 
        if ($departmentCode)
        {
            $driver = \Bitrix\Disk\Driver::getInstance();
            $rightsManager = $driver->getRightsManager();
            $accessCodes[] = [
                'ACCESS_CODE' => $departmentCode,
                'TASK_ID' => $rightsManager->getTaskIdByName($rightsManager::TASK_READ)
            ];
        }
 
        return $accessCodes;
    }
 
    public static function deleteGeneralChat(): Result
    {
        $generalChat = self::get();
        if (!$generalChat)
        {
            return (new Result())->addError(new ChatError(ChatError::NOT_FOUND));
        }
 
        return $generalChat->deleteChat();
    }
 
    protected function sendMessageUsersAdd(array $usersToAdd, bool $skipRecent = false): void
    {
        if ($this->getContext()->getUserId() > 0)
        {
            parent::sendMessageUsersAdd($usersToAdd, $skipRecent);
 
            return;
        }
 
        if (!self::getAutoMessageStatus(self::GENERAL_MESSAGE_TYPE_JOIN))
        {
            return;
        }
 
        $userCodes = [];
        foreach ($usersToAdd as $userId)
        {
            $userCodes[] = "[USER={$userId}][/USER]";
        }
        $userCodesString = implode(', ', $userCodes);
 
        if (count($usersToAdd) > 1)
        {
            $messageText = Loc::getMessage("IM_CHAT_GENERAL_JOIN_PLURAL", ['#USER_NAME#' => $userCodesString]);
        }
        else
        {
            $user = User::getInstance(current($usersToAdd));
            $genderModifier = $user->getGender() === 'F' ? '_F' : '';
            $messageText = Loc::getMessage('IM_CHAT_GENERAL_JOIN' . $genderModifier, ['#USER_NAME#' => $userCodesString]);
        }
 
        \CIMChat::AddMessage([
            "TO_CHAT_ID" => $this->getId(),
            "MESSAGE" => $messageText,
            "FROM_USER_ID" => $this->getContext(),
            "SYSTEM" => 'Y',
            "RECENT_ADD" => $skipRecent ? 'N' : 'Y',
            "PARAMS" => [
                "CODE" => 'CHAT_JOIN',
                "NOTIFY" => $this->getEntityType() === self::ENTITY_TYPE_LINE? 'Y': 'N',
            ],
            "PUSH" => 'N',
            "SKIP_USER_CHECK" => 'Y',
        ]);
    }
 
    protected function sendMessageUserDelete(int $userId, bool $skipRecent = false): void
    {
        if (!self::getAutoMessageStatus(self::GENERAL_MESSAGE_TYPE_LEAVE))
        {
            return;
        }
 
        parent::sendMessageUserDelete($userId, $skipRecent);
    }
 
    protected function getMessageUserDeleteText(int $userId): string
    {
        $user = User::getInstance($userId);
 
        return Loc::getMessage("IM_CHAT_GENERAL_LEAVE_{$user->getGender()}", Array('#USER_NAME#' => htmlspecialcharsback($user->getName())));
    }
 
    private static function getCache(string $cacheId): Cache
    {
        $cache = Application::getInstance()->getCache();
        $cacheTTL = 18144000;
        $cacheDir = static::getCacheDir();
        $cache->initCache($cacheTTL, $cacheId, $cacheDir);
 
        return $cache;
    }
 
    private static function getCacheDir(): string
    {
        return '/bx/imc/general_chat';
    }
}