im_disk.php

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

<?php
 
use Bitrix\Disk;
use Bitrix\Disk\File;
use Bitrix\Disk\FileLink;
use Bitrix\Disk\SystemUser;
use \Bitrix\Im as IM;
use Bitrix\Main\Loader;
use \Bitrix\Main\Localization\Loc;
use Bitrix\Socialnetwork\Collab\Provider\CollabProvider;
 
Loc::loadMessages(__FILE__);
 
class CIMDisk
{
    const MODULE_ID = 'im';
 
    const PATH_TYPE_SHOW = 'show';
    const PATH_TYPE_PREVIEW = 'preview';
    const PATH_TYPE_DOWNLOAD = 'download';
 
    private static $chatList = [];
    private static $folderList = [];

    public static function GetStorage(?int $chatId = null)
    {
        if (!self::Enabled())
        {
            return false;
        }
 
        $storageModel = false;
        if ($storageId = self::GetStorageId($chatId))
        {
            $storageModel = \Bitrix\Disk\Storage::loadById($storageId);
            if (!$storageModel)
            {
                $storageModel = false;
            }
        }
 
        if (!$storageModel)
        {
            $data = [
                'NAME' => Loc::getMessage('IM_DISK_STORAGE_TITLE'),
                'USE_INTERNAL_RIGHTS' => 1,
                'MODULE_ID' => self::MODULE_ID,
                'ENTITY_TYPE' => IM\Disk\ProxyType\Im::className(),
                'ENTITY_ID' => self::MODULE_ID,
            ];
 
            $driver = \Bitrix\Disk\Driver::getInstance();
 
            // allow access for all on the top folder
            $storageModel = $driver->addStorageIfNotExist($data);
            if ($storageModel)
            {
                self::SetStorageId($storageModel->getId());
            }
            else
            {
                $storageModel = false;
            }
        }
 
        return $storageModel;
    }

    public static function UploadFileRegister($chatId, $files, $text = '', $linesSilentMode = false)
    {
        if ((int)$chatId <= 0 || empty($files))
        {
            return false;
        }
 
        $chatRelation = \CIMChat::GetRelationById($chatId, false, true, false);
        if (!$chatRelation[self::GetUserId()])
        {
            return false;
        }
 
        $folderModel = self::GetFolderModel($chatId);
        if (!$folderModel)
        {
            return false;
        }
 
        $result = [];
        $result['FILE_ID'] = [];
        $messageFileId = [];
        $filesModels = [];
        foreach ($files as $fileId => $fileData)
        {
            if (!$fileData['mimeType'])
            {
                $fileData['mimeType'] = "binary";
            }
            if (!$fileData['name'])
            {
                continue;
            }
            $newFile = $folderModel->addBlankFile(Array(
                'NAME' => $fileData['name'],
                'SIZE' => $fileData['size'],
                'CREATED_BY' => self::GetUserId(),
                'MIME_TYPE' => $fileData['mimeType'],
            ), Array(), true);
            if ($newFile)
            {
                $result['FILE_ID'][$fileId]['TMP_ID'] = $fileId;
                $result['FILE_ID'][$fileId]['FILE_ID'] = $newFile->getId();
                $result['FILE_ID'][$fileId]['FILE_NAME'] = $newFile->getName();
                $filesModels[] = $newFile;
 
                $messageFileId[] = $newFile->getId();
            }
            else
            {
                $result['FILE_ID'][$fileId]['TMP_ID'] = $fileId;
                $result['FILE_ID'][$fileId]['FILE_ID'] = 0;
            }
        }
        if (empty($messageFileId))
        {
            return false;
        }
 
        $result['MESSAGE_ID'] = 0;
        $arChat = \CIMChat::GetChatData(Array('ID' => $chatId));
        $ar = Array(
            "TO_CHAT_ID" => $chatId,
            "FROM_USER_ID" => self::GetUserId(),
            "MESSAGE_TYPE" => $arChat['chat'][$chatId]['message_type'],
            "SILENT_CONNECTOR" => $linesSilentMode?'Y':'N',
            "PARAMS" => Array(
                'FILE_ID' => $messageFileId
            ),
            "FILE_MODELS" => $filesModels
        );
 
        $text = trim($text);
        if ($text)
        {
            $ar['MESSAGE'] = $text;
        }
        $messageId = \CIMMessage::Add($ar);
        if ($messageId)
        {
        }
        else
        {
            if ($e = $GLOBALS["APPLICATION"]->GetException())
            {
                $result['MESSAGE_ERROR'] = $e->GetString();
            }
        }
 
        return $result;
    }

    public static function UploadFile($hash, &$file, &$package, &$upload, &$error)
    {
        $post = \Bitrix\Main\Context::getCurrent()->getRequest()->getPostList()->toArray();
        $post['PARAMS'] = IM\Text::convertSymbolsAfterJsonDecode(\CUtil::JsObjectToPhp($post['REG_PARAMS'], true));
        $post['MESSAGE_HIDDEN'] = $post['REG_MESSAGE_HIDDEN'] == 'Y' ? 'Y' : 'N';
        $post['PARAMS']['TEXT'] = $post['PARAMS']['TEXT'] ? trim($post['PARAMS']['TEXT']) : '';
 
        $chatId = (int)$post['CHAT_ID'];
        if ($chatId <= 0)
        {
            $error = Loc::getMessage('IM_DISK_ERR_UPLOAD').' (E100)';
            return false;
        }
 
        $chat =\Bitrix\Im\V2\Chat::getInstance($chatId);
        if (!$chat->isExist())
        {
            $error = Loc::getMessage('IM_DISK_ERR_UPLOAD').' (E101)';
            return false;
        }
 
        if (!$chat->checkAccess()->isSuccess())
        {
            $error = Loc::getMessage('IM_DISK_ERR_UPLOAD').' (E102)';
            return false;
        }
 
        if (!$chat->canDo(IM\V2\Permission\Action::Send))
        {
            $error = Loc::getMessage('IM_DISK_ERR_UPLOAD').' (E103)';
            return false;
        }
 
        $folderModel = self::GetFolderModel($chatId);
        if (!$folderModel)
        {
            $error = Loc::getMessage('IM_DISK_ERR_UPLOAD').' (E104)';
            return false;
        }
 
        if (!$file["files"]["default"])
        {
            $error = Loc::getMessage('IM_DISK_ERR_UPLOAD').' (E106)';
            return false;
        }
 
        $fileModel = $folderModel->uploadFile(
            $file['files']['default'],
            [
                'NAME' => $file['name'],
                'CREATED_BY' => self::GetUserId()
            ],
            [],
            true
        );
 
        if (!$fileModel || !$fileModel->getId())
        {
            $error = Loc::getMessage('IM_DISK_ERR_UPLOAD').' (E107)';
            return false;
        }
 
        $fileTmpId = $file["id"];
        $messageTmpId = $file["regTmpMessageId"];
        $isMessageHidden = $file["regHiddenMessageId"] === 'Y';
 
        if (!$fileTmpId || !$messageTmpId)
        {
            $error = Loc::getMessage('IM_DISK_ERR_UPLOAD').' (E108)';
            return false;
        }
        $uploadRealResult = self::UploadFileFromDisk(
            $chatId,
            ['upload'.$fileModel->getId()],
            $post['PARAMS']['TEXT'],
            [
                'LINES_SILENT_MODE' => $isMessageHidden,
                'TEMPLATE_ID' => $messageTmpId,
                'FILE_TEMPLATE_ID' => $fileTmpId
            ]
        );
 
        if (!$uploadRealResult)
        {
            $error = '';
            if ($e = $GLOBALS["APPLICATION"]->GetException())
            {
                $error = $e->GetString();
            }
            if ($error == '')
            {
                $error = Loc::getMessage('IM_DISK_ERR_UPLOAD').' (E109)';
            }
 
            return false;
        }
 
        $fileModel = $folderModel->getChild(['ID' => $fileModel->getId()]);
 
        $file['fileParams'] = self::GetFileParams($chatId, $fileModel);
        $file['fileParams']['date'] = date('c', $file['fileParams']['date']->getTimestamp());
 
        foreach(\GetModuleEvents("im", "OnAfterFileUpload", true) as $arEvent)
        {
            \ExecuteModuleEventEx($arEvent, [[
                'CHAT_ID' => $chatId,
                'FILE_ID' => $fileModel->getId(),
                'MESSAGE_ID' => $uploadRealResult['MESSAGE_ID'],
                'MESSAGE_OUT' => $post['PARAMS']['TEXT'],
                'MESSAGE_HIDDEN' => $isMessageHidden,
                'FILE' => $file['fileParams'],
            ]]);
        }
 
        return true;
    }

    public static function UploadFileUnRegister($chatId, $files, $messages)
    {
        if ((int)$chatId <= 0 || empty($files))
        {
            return false;
        }
 
        $chatRelation = \CIMChat::GetRelationById($chatId, false, true, false);
        if (!$chatRelation[self::GetUserId()])
        {
            return false;
        }
 
        $folderModel = self::GetFolderModel($chatId);
        if (!$folderModel)
        {
            return false;
        }
 
        $result = [];
        $result['CHAT_ID'] = $chatId;
        $result['FILE_ID'] = [];
        $result['MESSAGE_ID'] = [];
        foreach ($files as $fileTmpId => $fileId)
        {
            $fileModel = File::getById($fileId);
            if (
                !$fileModel
                || $fileModel->getParentId() != $folderModel->getId()
                || $fileModel->getCreatedBy() != self::GetUserId()
            )
            {
                continue;
            }
            $fileModel->delete(self::GetUserId());
            $result['FILE_ID'][$fileTmpId] = $fileId;
        }
        foreach ($messages as $fileTmpId => $messageId)
        {
            if (!isset($result['FILE_ID'][$fileTmpId]))
            {
                continue;
            }
 
            $CIMMessage = new \CIMMessage();
            $arMessage = $CIMMessage->GetMessage($messageId);
            if ($arMessage['AUTHOR_ID'] != self::GetUserId())
            {
                continue;
            }
            \CIMMessage::Delete($messageId);
            $result['MESSAGE_ID'][$fileTmpId] = $messageId;
        }
        if (empty($result['FILE_ID']) && empty($result['MESSAGE_ID']))
        {
            return false;
        }
 
        if (\Bitrix\Main\Loader::includeModule('pull'))
        {
            $pullMessage = Array(
                'module_id' => 'im',
                'command' => 'fileUnRegister',
                'params' => Array(
                    'chatId' => $result['CHAT_ID'],
                    'files' => $result['FILE_ID'],
                    'messages' => $result['MESSAGE_ID'],
                ),
                'extra' => \Bitrix\Im\Common::getPullExtra()
            );
            \Bitrix\Pull\Event::add(array_keys($chatRelation), $pullMessage);
 
            $orm = \Bitrix\Im\Model\ChatTable::getById($result['CHAT_ID']);
            $chat = $orm->fetch();
            if (CIMMessenger::needToSendPublicPull($chat['TYPE']))
            {
                \CPullWatch::AddToStack('IM_PUBLIC_'.$chat['ID'], $pullMessage);
            }
        }
 
        return $result;
    }

    public static function DeleteFile($chatId, $fileId)
    {
        if ((int)$chatId <= 0 || (int)$fileId <= 0)
        {
            return false;
        }
 
        $chatRelation = \CIMChat::GetRelationById($chatId, false, true, false);
        if (!$chatRelation[self::GetUserId()])
        {
            return false;
        }
 
        $folderModel = self::getFolderModel($chatId, false);
        if (!$folderModel)
        {
            return false;
        }
 
        $fileModel = File::getById($fileId);
        if (!$fileModel || $fileModel->getParentId() != $folderModel->getId())
        {
            return false;
        }

        global $USER;
        if (
            $fileModel->getCreatedBy() == self::GetUserId()
            || $USER->IsAdmin()
        )
        {
            // allow deleting only owned files
            $fileModel->delete(self::GetUserId());
            $notifyUsers = array_keys($chatRelation);
        }
        else
        {
            $driver = \Bitrix\Disk\Driver::getInstance();
            $rightsManager = $driver->getRightsManager();
 
            // hide file from user by access disabling
            $accessCodes = [
                // keep previous scheme with Uxx access code
                [
                    'ACCESS_CODE' => 'U'.self::GetUserId(),
                    'TASK_ID' => $rightsManager->getTaskIdByName($rightsManager::TASK_FULL),
                    'NEGATIVE' => 1,
                ]
            ];
            $rightsManager->append($fileModel, $accessCodes);
 
            $notifyUsers = [self::GetUserId()];
        }
 
        $fileService = new IM\V2\Link\File\FileService();
        if (\Bitrix\Main\Loader::includeModule('pull') && !$fileService->isMigrationFinished())
        {
            $orm = \Bitrix\Im\Model\ChatTable::getById($chatId);
            $chat = $orm->fetch();
            $pullMessage = Array(
                'module_id' => 'im',
                'command' => 'fileDelete',
                'params' => Array(
                    'chatId' => $chatId,
                    'fileId' => $fileId
                ),
                'extra' => \Bitrix\Im\Common::getPullExtra()
            );
            if ($chat['TYPE'] === IM\V2\Chat::IM_TYPE_COMMENT)
            {
                \CPullWatch::AddToStack('IM_PUBLIC_'.$chat['PARENT_ID'], $pullMessage);
            }
            else
            {
                \Bitrix\Pull\Event::add($notifyUsers, $pullMessage);
            }
 
            if (CIMMessenger::needToSendPublicPull($chat['TYPE']))
            {
                \CPullWatch::AddToStack('IM_PUBLIC_'.$chat['ID'], $pullMessage);
            }
        }
 
        return true;
    }

    public static function UploadFileFromDisk($chatId, $files, $text = '', $options = [], $robot = false)
    {
        if ((int)$chatId <= 0 || empty($files))
        {
            return false;
        }
 
        $chat = IM\V2\Chat::getInstance($chatId);
        if ($chat instanceof IM\V2\Chat\NullChat)
        {
            return false;
        }
 
        if (isset($options['USER_ID']))
        {
            $userId = (int)$options['USER_ID'];
        }
        else
        {
            $userId = self::GetUserId();
            if (!$userId)
            {
                return false;
            }
        }
 
        $skipUserCheck = isset($options['SKIP_USER_CHECK']) && $options['SKIP_USER_CHECK'] === true;
        $linesSilentMode = isset($options['LINES_SILENT_MODE']) && $options['LINES_SILENT_MODE'] === true;
        $makeSymlink = isset($options['SYMLINK']) && $options['SYMLINK'] === true;
        $templateId = isset($options['TEMPLATE_ID']) && $options['TEMPLATE_ID'] <> '' ? $options['TEMPLATE_ID'] : '';
        $fileTemplateId = isset($options['FILE_TEMPLATE_ID']) && $options['FILE_TEMPLATE_ID'] <> '' ? $options['FILE_TEMPLATE_ID'] : '';
        $attach = $options['ATTACH'] ?? null;
        $asFile = isset($options['AS_FILE']) && $options['AS_FILE'] === 'Y';
        $params = isset($options['PARAMS']) && is_array($options['PARAMS']) ? $options['PARAMS'] : null;
        $waitFullExecution = $options['WAIT_FULL_EXECUTION'] ?? 'Y';
        if ($chat->getEntityType() === 'LINES' || $chat->getEntityType() === 'LIVECHAT')
        {
            $waitFullExecution = 'Y';
        }
 
        $chatRelation = $chat->getRelations();
 
        if ($chat->getEntityType() !== 'LIVECHAT' && $userId > 0 && !$skipUserCheck)
        {
            if (!$chatRelation->hasUser($userId, $chatId))
            {
                return false;
            }
 
            if (
                $chat->getEntityType() === 'ANNOUNCEMENT'
                && !$chatRelation->getByUserId($userId, $chatId)->getManager()
            )
            {
                return false;
            }
        }
 
        $result = [];
        $result['FILES'] = [];
        $result['DISK_ID'] = [];
        $result['FILE_MODELS'] = [];
        foreach ($files as $fileId)
        {
            if (mb_substr($fileId, 0, 6) === 'upload')
            {
                $newFile = self::uploadFromLocalDisk($chatId, mb_substr($fileId, 6), $skipUserCheck ? 0 : $userId, $asFile);
            }
            else
            {
                $newFile = self::SaveFromLocalDisk($chatId, mb_substr($fileId, 4), $makeSymlink, $skipUserCheck? 0: $userId);
            }
 
            if ($newFile)
            {
                $result['FILES'][$fileId] = self::GetFileParams($chatId, $newFile);
                $result['DISK_ID'][] = $newFile->getId();
                $result['FILE_MODELS'][$fileId] = $newFile;
 
                if ($robot)
                {
                    if ($userId)
                    {
                        // temporary - waiting for fix in Disk
                        $recentItem = \Bitrix\Disk\Internals\RecentlyUsedTable::getList([
                            'select' => ['ID'],
                            'filter' => [
                                '=USER_ID' => $userId,
                                '=OBJECT_ID' => $newFile->getId()
                            ]
                        ])->fetch();
 
                        if ($recentItem)
                        {
                            \Bitrix\Disk\Internals\RecentlyUsedTable::delete($recentItem['ID']);
                        }
                    }
                }
                else if (!$skipUserCheck)
                {
                    if ($chat->getEntityType() == 'LINES')
                    {
                        if ($userId)
                        {
                            \Bitrix\Disk\Driver::getInstance()->getRecentlyUsedManager()->push($userId, $newFile);
                        }
                    }
                    else if ($chat->getEntityType() != 'LIVECHAT')
                    {
                        foreach ($chatRelation as $relation)
                        {
                            if ($relation->getMessageType() != \IM_MESSAGE_PRIVATE)
                            {
                                break;
                            }
 
                            if ($userId == $relation->getUserId())
                            {
                                continue;
                            }
 
                            \Bitrix\Disk\Driver::getInstance()->getRecentlyUsedManager()->push($relation->getUserId(), $newFile);
                        }
                    }
                }
            }
            else
            {
                $result['FILES'][$fileId]['id'] = 0;
            }
        }
        if (empty($result['DISK_ID']))
        {
            return false;
        }
 
        $result['MESSAGE_ID'] = 0;
 
        $ar = [
            "TO_CHAT_ID" => $chatId,
            "FROM_USER_ID" => $userId,
            "MESSAGE_TYPE" => $chat->getType(),
            "SILENT_CONNECTOR" => $linesSilentMode?'Y':'N',
            "SKIP_USER_CHECK" => ($skipUserCheck || !$userId || $chat->getEntityType() == 'LIVECHAT'),
            "TEMPLATE_ID" => $templateId,
            "FILE_TEMPLATE_ID" => $fileTemplateId,
            "FILE_MODELS" => $result['FILE_MODELS'] ?? [],
            "WAIT_FULL_EXECUTION" => $waitFullExecution,
        ];
 
        if ($chat->getEntityType() == 'LIVECHAT')
        {
            [$lineId] = explode("|", $chat->getEntityId());
            $ar["EXTRA_PARAMS"] = [
                "CONTEXT" => "LIVECHAT",
                "LINE_ID" => $lineId
            ];
            //TODO: fix 0135872
            //$ar['SKIP_CONNECTOR'] = 'Y';
        }
 
        $ar['FILES'] = $result['DISK_ID'];
 
        if ($params)
        {
            $ar['PARAMS'] = $params;
        }
 
        if ($attach)
        {
            $ar['ATTACH'] = $attach;
        }
 
        $text = trim($text);
        if ($text)
        {
            $ar["MESSAGE"] = $text;
        }
 
        $messageId = \CIMMessage::Add($ar);
        if (!$messageId)
        {
            foreach ($result['FILE_MODELS'] as $file)
            {
                $file->delete($userId);
            }
            return false;
        }
 
        $result['MESSAGE_ID'] = $messageId;
 
        if (
            !$robot
            && !$linesSilentMode
            && ($chat->getEntityType() == 'LINES' || $chat->getEntityType() == 'LIVECHAT')
        )
        {
            $fileIds = array_map(function($item){
                return 'disk' . $item;
            }, $result['DISK_ID']);
 
            $uploadResult = false;
 
            if ($chat->getEntityType() == 'LIVECHAT' && \Bitrix\Main\Loader::includeModule('imopenlines'))
            {
                [$lineId, $clientUserId] = explode("|", $chat->getEntityId());
 
                $session = new \Bitrix\Imopenlines\Session();
                if ($session->load([
                    'USER_CODE' => 'livechat|'.$lineId.'|'.$chat->getId().'|'.$clientUserId,
                    'DEFERRED_JOIN' => 'Y',
                ]))
                {
                    if ($session->isNowCreated())
                    {
                        \Bitrix\ImOpenLines\Connector::saveCustomData($session->getData('CHAT_ID'), $_SESSION['LIVECHAT']['CUSTOM_DATA']);
 
                        $session->joinUser();
 
                        $messageParams = [
                            'IMOL_SID' => $session->getData('ID'),
                            "IMOL_FORM" => "welcome",
                            "TYPE" => "lines",
                            "COMPONENT_ID" => "bx-imopenlines-message",
                        ];
                        \CIMMessageParam::Set($messageId, $messageParams);
                        \CIMMessageParam::SendPull($messageId, array_keys($messageParams));
                    }
                    $session->getData('CHAT_ID');
                    //TODO: fix 0135872
                    /*$uploadResult = self::UploadFileFromDisk(
                        $session->getData('CHAT_ID'),
                        $fileIds,
                        $text,
                        ['USER_ID' => $userId],
                        true
                    );*/
                }
            }
 
            if (
                !empty($uploadResult) &&
                $uploadResult['MESSAGE_ID'] &&
                $result['MESSAGE_ID']
            )
            {
                \Bitrix\Im\Model\MessageParamTable::add([
                    "MESSAGE_ID" => $result['MESSAGE_ID'],
                    "PARAM_NAME" => 'CONNECTOR_MID',
                    "PARAM_VALUE" => $uploadResult['MESSAGE_ID']
                ]);
                \Bitrix\Im\Model\MessageParamTable::add([
                    "MESSAGE_ID" => $uploadResult['MESSAGE_ID'],
                    "PARAM_NAME" => 'CONNECTOR_MID',
                    "PARAM_VALUE" => $result['MESSAGE_ID']
                ]);
 
                \CIMMessageParam::SendPull($result['MESSAGE_ID'], ['CONNECTOR_MID']);
                \CIMMessageParam::SendPull($uploadResult['MESSAGE_ID'], ['CONNECTOR_MID']);
 
                $event = new \Bitrix\Main\Event("imopenlines", "OnLivechatUploadFile", ['FILES' => $uploadResult['DISK_ID']]);
                $event->send();
            }
        }
 
        return $result;
    }
 
    protected static function checkDirectlyUseFileAccess(
        File $fileModel,
        Disk\Folder $folderModel,
        int $userId
    ): IM\V2\Result
    {
        $result = new IM\V2\Result();
 
        if ((int)$fileModel->getParentId() !== (int)$folderModel->getId())
        {
            $result->addError(
                new IM\V2\Entity\File\FileError(
                    IM\V2\Entity\File\FileError::UPLOAD_FILE_INCORRECT_FOLDER,
                    'The parent folder of the original file and the destination folder must match.'
                )
            );
        }
 
        if ((int)$fileModel->getCreatedBy() !== $userId)
        {
            $result->addError(
                new IM\V2\Entity\File\FileError(
                    IM\V2\Entity\File\FileError::UPLOAD_FILE_INCORRECT_AUTHOR,
                    'You must be the author of the original file to upload it.'
                )
            );
        }
 
        return $result;
    }
 
    protected static function uploadFromLocalDisk(
        int $chatId,
        int $fileId,
        ?int $userId = null,
        bool $asFile = false
    ): File|false
    {
        $fileModel = self::getFileModel($fileId, $userId);
        $chat = Bitrix\Im\V2\Chat::getInstance($chatId);
        if (!isset($fileModel) || $chat instanceof IM\V2\Chat\NullChat)
        {
            return false;
        }
 
        $folderModel = self::GetFolderModel($chatId);
        if (!isset($folderModel))
        {
            return false;
        }
 
        $checkResult = self::checkDirectlyUseFileAccess($fileModel, $folderModel, (int)$userId);
 
        if (!$checkResult->isSuccess())
        {
            (new IM\V2\Logger('chat_incorrect_file_upload'))->logErrors($checkResult->getErrorCollection());
        }
 
        $fileModel->increaseGlobalContentVersion();
 
        if ($asFile)
        {
            (new IM\V2\Entity\File\FileItem($fileModel, $chatId))->markAsFile();
        }
 
        (new IM\V2\Analytics\ChatAnalytics($chat))->addUploadFile($fileModel);
 
        return $fileModel;
    }

    public static function UploadFileFromMain($chatId, $files, ?int $authorId = null)
    {
        if ((int)$chatId <= 0 || empty($files))
        {
            return false;
        }
 
        $chatRelation = \CIMChat::GetRelationById($chatId, false, true, false);
        if (!$chatRelation)
        {
            return false;
        }
 
        $folderModel = self::GetFolderModel($chatId);
        if (!$folderModel)
        {
            return false;
        }
 
        $messageFileId = [];
        foreach ($files as $fileId)
        {
            $res = \CFile::GetByID($fileId);
            $file = $res->Fetch();
            if (!$file)
            {
                continue;
            }
 
            if (empty($file['ORIGINAL_NAME']))
            {
                $fileName = $file['FILE_NAME'];
            }
            else
            {
                $fileName = $file['ORIGINAL_NAME'];
            }
 
            $fileName = \Bitrix\Disk\Ui\Text::correctFilename($fileName);
            $newFile = $folderModel->addFile(array(
                'NAME' => $fileName,
                'FILE_ID' => $fileId,
                'SIZE' => $file['FILE_SIZE'],
                'CREATED_BY' => $authorId ?? SystemUser::SYSTEM_USER_ID,
            ), Array(), true);
            if ($newFile)
            {
                $newFile->increaseGlobalContentVersion();
                $messageFileId[] = $newFile->getId();
            }
        }
 
        return !empty($messageFileId) ? $messageFileId : false;
    }

    public static function SaveToLocalDisk($fileId)
    {
        if (!self::Enabled())
        {
            return false;
        }
 
        if ((int)$fileId <= 0)
        {
            return false;
        }
 
        $fileModel = File::getById($fileId, array('STORAGE'));
        if (!$fileModel)
        {
            return false;
        }
        if ($fileModel instanceof FileLink)
        {
            $fileModel = $fileModel->getRealObject();
            if (!$fileModel)
            {
                return false;
            }
        }
 
        $storageModel = $fileModel->getStorage();
        if (!$storageModel)
        {
            return false;
        }
 
        if (!$fileModel->canRead($storageModel->getCurrentUserSecurityContext()))
        {
            return false;
        }
 
        $folderModel = self::GetLocalDiskSavedModel();
        if (!$folderModel)
        {
            return false;
        }
 
        $newFileModel = $fileModel->copyTo($folderModel, self::GetUserId(), true);
        if (!$newFileModel)
        {
            return false;
        }
 
        return [
            'FILE' => $newFileModel,
            'FOLDER' => $folderModel,
        ];
    }

    public static function IncreaseFileVersionDisk($chatId, $fileId, ?int $userId = null)
    {
        if (!self::Enabled())
        {
            return false;
        }
 
        if ((int)$fileId <= 0 || (int)$chatId <= 0)
        {
            return false;
        }
 
        $fileModel = File::getById($fileId, array('STORAGE'));
        if (!$fileModel)
        {
            return false;
        }
 
        $storageModel = $fileModel->getStorage();
        if (!$storageModel)
        {
            return false;
        }
 
        $securityContext = null;
        if (is_null($userId))
        {
            $securityContext = $storageModel->getCurrentUserSecurityContext();
        }
        else if ($userId > 0)
        {
            $securityContext = $storageModel->getSecurityContext($userId);
        }
 
        if ($securityContext && !$fileModel->canRead($securityContext))
        {
            return false;
        }
 
        $fileModel->increaseGlobalContentVersion();
 
        return $fileModel;
    }

    public static function SaveFromLocalDisk($chatId, $fileId, bool $symlink = false, ?int $userId = null)
    {
        if (!self::Enabled())
        {
            return false;
        }
 
        $fileModel = self::getFileModel((int)$fileId, $userId);
        $folderModel = self::GetFolderModel($chatId);
        $chat = IM\V2\Chat::getInstance($chatId);
 
        if (
            !$folderModel
            || !$fileModel
            || $chat instanceof IM\V2\Chat\NullChat
        )
        {
            return false;
        }
 
        if (
            $chat instanceof IM\V2\Chat\CollabChat
            && (int)$fileModel->getParentId() === (int)$folderModel->getId()
        )
        {
            $fileModel->increaseGlobalContentVersion();
 
            return $fileModel;
        }
 
        if ($fileModel instanceof FileLink)
        {
            $fileModel = $fileModel->getRealObject();
            if (!$fileModel)
            {
                return false;
            }
        }
 
        if ($symlink)
        {
            $newFileModel = self::createSymlink($fileModel, $chatId, (int)$userId);
        }
        else
        {
            $newFileModel = $fileModel->copyTo($folderModel, (int)$userId, true);
        }
 
        if (!$newFileModel)
        {
            return false;
        }
 
        $newFileModel->increaseGlobalContentVersion();
 
        return $newFileModel;
    }
 
    protected static function createSymlink(
        File $fileModel,
        int $chatId,
        int $userId,
        bool $withSharingRights = true
    ): ?File
    {
        if (!self::Enabled())
        {
            return null;
        }
 
        $folderModel = self::GetFolderModel($chatId);
 
        if ($withSharingRights)
        {
            $accessProvider = new \Bitrix\Im\Access\ChatAuthProvider;
            $rightsManager = \Bitrix\Disk\Driver::getInstance()->getRightsManager();
 
            $rightsManager->append(
                $fileModel,
                [[
                    // allow reading for access code `CHATxxx`
                    'ACCESS_CODE' => $accessProvider->generateAccessCode($chatId),
                    'TASK_ID' => $rightsManager->getTaskIdByName($rightsManager::TASK_READ)
                ]]
            );
        }
 
        return $folderModel->addFileLink(
            $fileModel,
            [
                'CREATED_BY' => $userId,
                'GLOBAL_CONTENT_VERSION' => 1
            ],
            [],// link inherits access rights from parent folder
            true
        );
    }
 
    protected static function getFileModel(int $fileId, ?int $contextUserId): ?File
    {
        if (!self::Enabled())
        {
            return null;
        }
 
        if ($fileId <= 0)
        {
            return null;
        }
 
        $fileModel = File::getById($fileId, array('STORAGE'));
        if (!$fileModel)
        {
            return null;
        }
 
        $storageModel = $fileModel->getStorage();
        if (!$storageModel)
        {
            return null;
        }
 
        $securityContext = null;
        if (!isset($contextUserId))
        {
            $securityContext = $storageModel->getCurrentUserSecurityContext();
        }
        else if ($contextUserId > 0)
        {
            $securityContext = $storageModel->getSecurityContext($contextUserId);
        }
 
        if ($securityContext && !$fileModel->canRead($securityContext))
        {
            return null;
        }
 
        return $fileModel;
    }

    public static function RecordShare(int $chatId, int $fileId, ?int $userId = null): bool
    {
        if (!self::Enabled())
        {
            return false;
        }
 
        if ($chatId <= 0 || $fileId <= 0)
        {
            return false;
        }
 
        $chat = \Bitrix\Im\Model\ChatTable::getByPrimary($chatId, [
            'select' => ['TITLE', 'ENTITY_TYPE', 'ENTITY_ID']
        ])->fetch();
        if (!$chat)
        {
            return false;
        }
 
        if (!\CIMChat::GetRelationById($chatId, $userId, true, false))
        {
            return false;
        }
 
        $fileModel = File::getById($fileId, array('STORAGE'));
        if (!$fileModel)
        {
            return false;
        }
 
        $storageModel = $fileModel->getStorage();
        if (!$storageModel)
        {
            return false;
        }
 
        $securityContext = null;
        if (is_null($userId))
        {
            $securityContext = $storageModel->getCurrentUserSecurityContext();
        }
        else if ($userId > 0)
        {
            $securityContext = $storageModel->getSecurityContext($userId);
        }
 
        if ($securityContext && !$fileModel->canRead($securityContext))
        {
            return false;
        }
 
        self::UploadFileFromDisk($chatId, ['disk'.$fileId], '', ['SYMLINK' => true]);
 
        if (!empty($chat['ENTITY_TYPE']) && !empty($chat['ENTITY_ID']))
        {
            $event = new \Bitrix\Main\Event('im', 'onDiskRecordShare', [
                'DISK_ID' => $fileId,
                'CHAT' => [
                    'ID' => $chatId,
                    'TITLE' => $chat['TITLE'],
                    'ENTITY_TYPE' => $chat['ENTITY_TYPE'],
                    'ENTITY_ID' => $chat['ENTITY_ID']
                ],
                'USER_ID' => $userId,
            ]);
            $event->send();
        }
 
        return true;
    }

    public static function UploadAvatar($hash, &$file, &$package, &$upload, &$error)
    {
        $post = \Bitrix\Main\Context::getCurrent()->getRequest()->getPostList()->toArray();
 
        $chatId = (int)$post['CHAT_ID'];
        if ($chatId <= 0)
        {
            return false;
        }
 
        $chat = IM\Model\ChatTable::getById($chatId)->fetch();
        if (!$chat)
        {
            return false;
        }
 
        $relationError = true;
        $chatRelation = \CIMChat::GetRelationById($chatId, false, true, false);
        foreach ($chatRelation as $relation)
        {
            if ($relation["EXTERNAL_AUTH_ID"] == 'imconnector')
            {
                unset($chatRelation[$relation["USER_ID"]]);
                continue;
            }
            if ($relation['USER_ID'] == self::GetUserId())
            {
                $relationError = false;
            }
        }
        if ($relationError)
        {
            $error = Loc::getMessage('IM_DISK_ERR_AVATAR_1');
            return false;
        }
 
        if ($chat['ENTITY_TYPE'] === 'ANNOUNCEMENT' && $chatRelation[self::GetUserId()]['MANAGER'] !== 'Y')
        {
            return false;
        }
 
        $file["files"]["default"]["MODULE_ID"] = "im";
 
        $checkResponse = \CFile::CheckImageFile($file["files"]["default"], (10*1024*1024), 5000, 5000);
        if ($checkResponse !== null)
        {
            return false;
        }
 
        $fileId = \CFile::saveFile($file["files"]["default"], self::MODULE_ID);
        if ($fileId > 0)
        {
            if ($chat['AVATAR'] > 0)
            {
                \CFile::DeLete($chat['AVATAR']);
            }
            IM\Model\ChatTable::update($chatId, Array('AVATAR' => $fileId));
 
            $file['chatId'] = $chatId;
            $file['chatAvatar'] = \CIMChat::GetAvatarImage($fileId);
 
            if ($chat["ENTITY_TYPE"] != 'CALL')
            {
                \CIMChat::AddSystemMessage(Array(
                    'CHAT_ID' => $chatId,
                    'USER_ID' => self::GetUserId(),
                    'MESSAGE_CODE' => 'IM_DISK_AVATAR_CHANGE_'
                ));
            }
 
            if (\Bitrix\Main\Loader::includeModule('pull'))
            {
                $pullMessage = Array(
                    'module_id' => 'im',
                    'command' => 'chatAvatar',
                    'params' => Array(
                        'chatId' => $chatId,
                        'avatar' => $file['chatAvatar'],
                    ),
                    'extra' => \Bitrix\Im\Common::getPullExtra()
                );
                \Bitrix\Pull\Event::add(array_keys($chatRelation), $pullMessage);
                if (CIMMessenger::needToSendPublicPull($chat['TYPE']))
                {
                    \CPullWatch::AddToStack('IM_PUBLIC_'.$chat['ID'], $pullMessage);
                }
                if ($chat['TYPE'] === IM\V2\Chat::IM_TYPE_OPEN_CHANNEL)
                {
                    IM\V2\Chat\OpenChannelChat::sendSharedPull($pullMessage);
                }
            }
        }
        else
        {
            return false;
        }
 
        return true;
    }

    public static function UpdateAvatarId($chatId, $fileId, $userId = null)
    {
        $chatId = (int)$chatId;
        $fileId = (int)$fileId;
        if ($chatId <= 0 || $fileId <= 0)
        {
            return false;
        }
 
        $chat = IM\Model\ChatTable::getById($chatId)->fetch();
        if (!$chat || in_array($chat['TYPE'], Array(\IM_MESSAGE_PRIVATE, \IM_MESSAGE_SYSTEM)))
        {
            return false;
        }
 
        $relationError = true;
        $chatRelation = \CIMChat::GetRelationById($chatId, false, true, false);
        foreach ($chatRelation as $relation)
        {
            if ($relation["EXTERNAL_AUTH_ID"] == 'imconnector')
            {
                unset($chatRelation[$relation["USER_ID"]]);
                continue;
            }
            if ($relation['USER_ID'] == \Bitrix\Im\Common::getUserId($userId))
            {
                $relationError = false;
            }
        }
        if ($relationError)
        {
            return false;
        }
 
        if ($chat['AVATAR'] > 0)
        {
            \CFile::DeLete($chat['AVATAR']);
        }
        IM\Model\ChatTable::update($chatId, Array('AVATAR' => $fileId));
 
        $file['chatId'] = $chatId;
        $file['chatAvatar'] = \CIMChat::GetAvatarImage($fileId);
 
        if ($chat["ENTITY_TYPE"] != 'CALL')
        {
            \CIMChat::AddSystemMessage(Array(
                'CHAT_ID' => $chatId,
                'USER_ID' => \Bitrix\Im\Common::getUserId($userId),
                'MESSAGE_CODE' => 'IM_DISK_AVATAR_CHANGE_'
            ));
        }
 
        if (\Bitrix\Main\Loader::includeModule('pull'))
        {
            $pullMessage = Array(
                'module_id' => 'im',
                'command' => 'chatAvatar',
                'params' => Array(
                    'chatId' => $chatId,
                    'avatar' => $file['chatAvatar'],
                ),
                'extra' => \Bitrix\Im\Common::getPullExtra()
            );
            \Bitrix\Pull\Event::add(array_keys($chatRelation), $pullMessage);
 
            if (CIMMessenger::needToSendPublicPull($chat['TYPE']))
            {
                \CPullWatch::AddToStack('IM_PUBLIC_'.$chat['ID'], $pullMessage);
            }
            if ($chat['TYPE'] === IM\V2\Chat::IM_TYPE_OPEN_CHANNEL)
            {
                IM\V2\Chat\OpenChannelChat::sendSharedPull($pullMessage);
            }
        }
 
        return true;
    }

    public static function GetHistoryFiles($chatId, $historyPage = 1)
    {
        $fileArray = [];
        if (!self::Enabled())
        {
            return $fileArray;
        }
 
        if ((int)$chatId <= 0)
        {
            return $fileArray;
        }
 
        $offset = (int)$historyPage - 1;
        if ($offset < 0)
        {
            return $fileArray;
        }
 
        $folderModel = self::getFolderModel($chatId, false);
        if (!$folderModel)
        {
            return $fileArray;
        }
 
        $filter = Array(
            'PARENT_ID' => $folderModel->getId(),
            'STORAGE_ID' => $folderModel->getStorageId()
        );
 
        $relation = \CIMChat::GetRelationById($chatId, self::GetUserId(), true, false);
        if (!$relation)
        {
            return $fileArray;
        }
 
        if ($relation['LAST_FILE_ID'] > 0)
        {
            $filter['>ID'] = $relation['LAST_FILE_ID'];
        }

        $securityContext = new \Bitrix\Disk\Security\DiskSecurityContext(self::GetUserId());
 
        $parameters = Array(
            'filter' => $filter,
            'with' => Array('CREATE_USER'),
            'limit' => 15,
            'offset' => $offset*15,
            'order' => Array('UPDATE_TIME' => 'DESC')
        );
        $parameters = \Bitrix\Disk\Driver::getInstance()->getRightsManager()->addRightsCheck($securityContext, $parameters, array('ID', 'CREATED_BY'));
 
        $fileCollection = File::getModelList($parameters);
 
        foreach ($fileCollection as $fileModel)
        {
            $fileArray[$fileModel->getId()] = self::GetFileParams($chatId, $fileModel);
        }
 
        return $fileArray;
    }

    public static function GetHistoryFilesByName($chatId, $name)
    {
        $fileArray = [];
        if (!self::Enabled())
        {
            return $fileArray;
        }
 
        if ((int)$chatId <= 0)
        {
            return $fileArray;
        }
 
        $name = trim($name);
        if ($name == '')
        {
            return $fileArray;
        }
 
        $folderModel = self::getFolderModel($chatId, false);
        if (!$folderModel)
        {
            return $fileArray;
        }
 
        $filter = Array(
            'PARENT_ID' => $folderModel->getId(),
            'STORAGE_ID' => $folderModel->getStorageId(),
            '%=NAME' => str_replace("%", '', $name)."%",
        );
 
        $relation = \CIMChat::GetRelationById($chatId, self::GetUserId(), true, false);
        if (!$relation)
        {
            return $fileArray;
        }
 
        if ($relation['LAST_FILE_ID'] > 0)
        {
            $filter['>ID'] = $relation['LAST_FILE_ID'];
        }

        $securityContext = new \Bitrix\Disk\Security\DiskSecurityContext(self::GetUserId());
 
        $parameters = Array(
            'filter' => $filter,
            'with' => Array('CREATE_USER'),
            'limit' => 100,
            'order' => Array('UPDATE_TIME' => 'DESC')
        );
        $parameters = \Bitrix\Disk\Driver::getInstance()->getRightsManager()->addRightsCheck($securityContext, $parameters, array('ID', 'CREATED_BY'));
 
        $fileCollection = File::getModelList($parameters);
 
        foreach ($fileCollection as $fileModel)
        {
            $fileArray[$fileModel->getId()] = self::GetFileParams($chatId, $fileModel);
        }
 
        return $fileArray;
    }

    public static function GetMaxFileId($chatId)
    {
        $maxId = 0;
        if (!self::Enabled())
        {
            return $maxId;
        }
 
        if ((int)$chatId <= 0)
        {
            return $maxId;
        }
 
        $folderModel = self::getFolderModel($chatId, false);
        if (!$folderModel)
        {
            return $maxId;
        }
 
        $result = \Bitrix\Disk\Internals\ObjectTable::getList(array(
            'select' => array('MAX_ID'),
            'filter' => array(
                '=PARENT_ID' => $folderModel->getId(),
                '=TYPE' => \Bitrix\Disk\Internals\ObjectTable::TYPE_FILE
            ),
            'runtime' => array(
                'MAX_ID' => array(
                    'data_type' => 'integer',
                    'expression' => array('MAX(ID)')
                )
            )
        ));
        if ($data = $result->fetch())
        {
            $maxId = $data['MAX_ID'];
        }
 
        return (int)$maxId;
    }

    public static function GetFiles($chatId, $fileId = false, $checkPermission = true)
    {
        $fileArray = Array();
        if (!self::Enabled())
        {
            return $fileArray;
        }
 
        if ((int)$chatId <= 0)
        {
            return $fileArray;
        }
 
        if ($fileId === false || $fileId === null)
        {
            if (!is_array($fileId))
            {
                $fileId = Array($fileId);
            }
            foreach ($fileId as $key => $value)
            {
                $fileId[$key] = (int)$value;
            }
        }
        if (empty($fileId))
        {
            return $fileArray;
        }
        $folderModel = self::getFolderModel($chatId, false);
        if (!$folderModel)
        {
            return $fileArray;
        }
        $filter = Array(
            'PARENT_ID' => $folderModel->getId(),
            'STORAGE_ID' => $folderModel->getStorageId()
        );
        if ($fileId)
        {
            $filter['ID'] = array_values($fileId);
        }
 
        if ($checkPermission)
        {
            $securityContext = new \Bitrix\Disk\Security\DiskSecurityContext(self::GetUserId());
        }
        else
        {
            $securityContext = \Bitrix\Disk\Driver::getInstance()->getFakeSecurityContext();
        }
 
        $parameters = Array(
            'filter' => $filter,
            'with' => Array('CREATE_USER')
        );
        $parameters = \Bitrix\Disk\Driver::getInstance()->getRightsManager()->addRightsCheck($securityContext, $parameters, array('ID', 'CREATED_BY'));
 
        $fileCollection = File::getModelList($parameters);
        foreach ($fileCollection as $fileModel)
        {
            $fileArray[$fileModel->getId()] = self::GetFileParams($chatId, $fileModel);
        }
 
        return $fileArray;
    }

    public static function GetFileParams($chatId, $fileModel, $options = [])
    {
        if (!self::Enabled())
        {
            return false;
        }
 
        if ($fileModel instanceof File)
        {
        }
        elseif ((int)$fileModel > 0)
        {
            $fileModel = File::getById($fileModel);
        }
        else
        {
            return false;
        }
 
        if (!$fileModel || $fileModel->getId() <= 0)
        {
            return false;
        }
 
        $file = new IM\V2\Entity\File\FileItem($fileModel, $chatId);
        $params = $file->toRestFormat();
        $params['date'] = $fileModel->getCreateTime(); // backward compatibility
 
        return $params;
    }

    public static function Enabled()
    {
        static $isEnable;
        if ($isEnable === null)
        {
            $isEnable =
                \Bitrix\Main\Loader::includeModule('pull')
                && \CPullOptions::GetNginxStatus()
                && \Bitrix\Main\Loader::includeModule('disk')
                && \Bitrix\Disk\Driver::isSuccessfullyConverted()
            ;
        }
 
        return $isEnable;
    }
 
    public static function updateFolderRights(int $chatId, bool $fullRights = false): bool
    {
        if (!self::Enabled() || $chatId <= 0)
        {
            return false;
        }
 
        $result = IM\Model\ChatTable::getById($chatId);
        if (!$chat = $result->fetch())
        {
            return false;
        }
 
        if ($chat['TYPE'] !== IM\V2\Chat::IM_TYPE_CHAT)
        {
            return false;
        }
 
        $folderId = (int)$chat['DISK_FOLDER_ID'];
        if ($folderId <= 0)
        {
            return false;
        }
 
        $folderModel = \Bitrix\Disk\Folder::getById($folderId);
        if (
            !$folderModel
            || !($folderModel instanceof \Bitrix\Disk\Folder)
            || ($folderModel->getStorageId() != self::GetStorageId($chatId))
        )
        {
            return false;
        }
 
        $driver = \Bitrix\Disk\Driver::getInstance();
        $accessProvider = new \Bitrix\Im\Access\ChatAuthProvider;
        $rightsManager = $driver->getRightsManager();
 
        if ($fullRights)
        {
            $accessCode = self::GetTopDepartmentCode();
        }
        else
        {
            $accessCode = $accessProvider->generateAccessCode($chatId);
        }
 
        $rightsManager->delete($folderModel);
        return $rightsManager->append(
            $folderModel,
            [[
                'ACCESS_CODE' => $accessCode,
                'TASK_ID' => $rightsManager->getTaskIdByName($rightsManager::TASK_READ)
            ]]
        );
    }

    public static function GetFolderModel($chatId, $createFolder = true)
    {
        if (!self::Enabled())
        {
            return false;
        }
 
        if ((int)$chatId <= 0)
        {
            return false;
        }
 
        $folderModel = false;
 
        if (isset(self::$chatList[$chatId]))
        {
            $chat = self::$chatList[$chatId];
        }
        else
        {
            $chat = IM\Model\ChatTable::getRow([
                'select' => [
                    'TYPE',
                    'DISK_FOLDER_ID',
                    'PARENT_ID'
                ],
                'filter' => [
                    'ID' => $chatId,
                ]
            ]);
 
            self::$chatList[$chatId] = $chat;
        }
 
        if (!$chat)
        {
            return false;
        }
 
        $folderId = (int)$chat['DISK_FOLDER_ID'];
        if ($folderId > 0)
        {
            if (isset(self::$folderList[$folderId]) && self::$folderList[$folderId] instanceof \Bitrix\Disk\Folder)
            {
                $folderModel = self::$folderList[$folderId];
            }
            else
            {
                $folderModel = \Bitrix\Disk\Folder::getById($folderId);
                self::$folderList[$folderId] = $folderModel;
            }
 
            if (
                !$folderModel
                || !($folderModel instanceof \Bitrix\Disk\Folder)
                || ($folderModel->getStorageId() != self::GetStorageId($chatId))
            )
            {
                $folderId = 0;
            }
        }
 
        if ($folderId || !$createFolder)
        {
            return $folderModel;
        }
 
        $chatType = $chat['TYPE'];
        $withRights = true;
 
        if ($chatType === IM\V2\Chat::IM_TYPE_COMMENT)
        {
            $folderModel = self::createSubFolder($chatId, (int)$chat['PARENT_ID']);
            $withRights = false;
        }
        else
        {
            $folderModel = self::createFolder($chatId, $chatType);
        }
 
        if ($folderModel)
        {
            IM\Model\ChatTable::update($chatId, ['DISK_FOLDER_ID' => $folderModel->getId()]);
 
            if (isset(self::$chatList[$chatId]))
            {
                self::$chatList[$chatId]['DISK_FOLDER_ID'] = $folderModel->getId();
            }
            self::$folderList[$folderId] = $folderModel;
 
            if ($withRights)
            {
                (new \Bitrix\Im\Access\ChatAuthProvider)->updateChatCodesByRelations($chatId);
            }
        }
 
        return $folderModel;
    }

    protected static function createSubFolder(int $chatId, int $parentId)
    {
        $parentChat = IM\V2\Chat::getInstance($parentId);
        $parentFolder = $parentChat->getOrCreateDiskFolder();
        if (!$parentFolder)
        {
            return false;
        }
        return $parentFolder->addSubFolder(
            [
                'NAME' => 'chat'.$chatId,
                'CREATED_BY' => self::GetUserId()
            ],
            [],
            true
        );
    }

    protected static function createFolder(int $chatId, string $chatType)
    {
        $driver = \Bitrix\Disk\Driver::getInstance();
        $storageModel = self::GetStorage($chatId);
        if (!$storageModel)
        {
            return false;
        }
 
        $accessProvider = new \Bitrix\Im\Access\ChatAuthProvider;
        $rightsManager = $driver->getRightsManager();
 
        $accessCodes = [];
        // allow for access code `CHATxxx`
        $accessCodes[] = [
            'ACCESS_CODE' => $accessProvider->generateAccessCode($chatId),
            'TASK_ID' => $rightsManager->getTaskIdByName($rightsManager::TASK_EDIT)
        ];
 
        if ($chatType === IM\V2\Chat::IM_TYPE_COLLAB)
        {
            $folder = $storageModel->getFolderForUploadedFiles();
            if (!$folder)
            {
                return false;
            }
 
            $driver->getRightsManager()->append($folder, $accessCodes);
 
            return $folder;
        }
 
        if ($chatType === IM\V2\Chat::IM_TYPE_OPEN || $chatType === IM\V2\Chat::IM_TYPE_OPEN_CHANNEL)
        {
            // allow reading for top department, access code `DRxxx`
            $departmentCode = self::GetTopDepartmentCode();
            if ($departmentCode)
            {
                $accessCodes[] = Array(
                    'ACCESS_CODE' => $departmentCode,
                    'TASK_ID' => $rightsManager->getTaskIdByName($rightsManager::TASK_READ)
                );
            }
        }
 
        return $storageModel->addFolder(
            [
                'NAME' => 'chat'.$chatId,
                'CREATED_BY' => self::GetUserId()
            ],
            $accessCodes,
            true
        );
    }

    public static function ChangeFolderMembers($chatId, $userId, $append = true)
    {
        $chatId = (int)$chatId;
        if (!is_array($userId))
        {
            $userIds = Array($userId);
        }
        else
        {
            $userIds = $userId;
        }
        if ($chatId <= 0 || empty($userIds))
        {
            return false;
        }
 
        if (isset(self::$chatList[$chatId]))
        {
            $chat = self::$chatList[$chatId];
        }
        else
        {
            $chat = IM\Model\ChatTable::getRow([
                'select' => [
                    'TYPE',
                    'DISK_FOLDER_ID',
                ],
                'filter' => [
                    'ID' => $chatId,
                ]
            ]);
 
            self::$chatList[$chatId] = $chat;
        }
 
        if (!$chat)
        {
            return false;
        }
 
        if ($chat['TYPE'] === IM\V2\Chat::IM_TYPE_COMMENT)
        {
            return true;
        }
 
        $folderModel = self::getFolderModel($chatId, false);
        if (!$folderModel)
        {
            return false;
        }
 
        $accessProvider = new \Bitrix\Im\Access\ChatAuthProvider;
 
        if ($append)
        {
            $accessProvider->addChatCodes($chatId, $userIds);
            $result = true;
        }
        else
        {
            $accessProvider->deleteChatCodes($chatId, $userIds);
 
            // keep removing disk access codes `Uxxx` for previous access scheme
            $accessCodes = Array();
            if ($chat['TYPE'] == \IM_MESSAGE_OPEN)
            {
                $users = \CIMContactList::GetUserData(array(
                    'ID' => array_values($userIds),
                    'DEPARTMENT' => 'N',
                    'SHOW_ONLINE' => 'N',
                ));
                foreach ($users['users'] as $userData)
                {
                    if ($userData['extranet'])
                    {
                        $accessCodes[] = 'U'.$userData['id'];
                    }
                }
            }
            else
            {
                foreach ($userIds as $uid)
                {
                    $uid = (int)$uid;
                    if ($uid <= 0)
                    {
                        continue;
                    }
 
                    $accessCodes[] = 'U'.$uid;
                }
            }
            $driver = \Bitrix\Disk\Driver::getInstance();
            $rightsManager = $driver->getRightsManager();
            $result = $rightsManager->revokeByAccessCodes($folderModel, $accessCodes);
        }
 
        return $result;
    }

    public static function GetBackgroundFolderModel($userId = null)
    {
        if (!self::Enabled())
        {
            return null;
        }
 
        $userId = IM\Common::getUserId($userId);
        if (!$userId)
        {
            return null;
        }
 
        $storageModel = self::GetStorage();
        if (!$storageModel)
        {
            return null;
        }
 
        $folderModel = $storageModel->getSpecificFolderByCode('CALL_BACKGROUND_'.$userId);
        if ($folderModel)
        {
            return $folderModel;
        }
 
        $backgroundFolderModel = $storageModel->getSpecificFolderByCode('CALL_BACKGROUND');
        if (!$backgroundFolderModel)
        {
            $backgroundFolderModel = $storageModel->addFolder([
                'NAME' => 'CALL_BACKGROUND',
                'CODE' => 'CALL_BACKGROUND',
                'CREATED_BY' => SystemUser::SYSTEM_USER_ID,
            ], [], true);
        }
        if (!$backgroundFolderModel)
        {
            return null;
        }
 
        $rightsManager = \Bitrix\Disk\Driver::getInstance()->getRightsManager();
 
        $folderModel = $backgroundFolderModel->addSubFolder(
            [
                'NAME' => 'CALL_BACKGROUND_'.$userId,
                'CODE' => 'CALL_BACKGROUND_'.$userId,
                'CREATED_BY' => $userId,
            ],
            [
                // allow only for user, access code `Uxxx`
                ['ACCESS_CODE' => 'U'.$userId, 'TASK_ID' => $rightsManager->getTaskIdByName($rightsManager::TASK_FULL)],
            ],
            true
        );
 
        return $folderModel;
    }

    public static function CommitBackgroundFile($userId, $fileId)
    {
        $folderModel = self::GetBackgroundFolderModel($userId);
        if (!$folderModel)
        {
            return false;
        }
 
        $fileModel = File::getById($fileId);
        if (!$fileModel || $fileModel->getParentId() != $folderModel->getId())
        {
            return false;
        }
 
        $fileModel->increaseGlobalContentVersion();
 
        return true;
    }

    public static function DeleteBackgroundFile($userId, $fileId)
    {
        $folderModel = self::GetBackgroundFolderModel($userId);
        if (!$folderModel)
        {
            return false;
        }
 
        $fileModel = File::getById($fileId);
        if (!$fileModel || $fileModel->getParentId() != $folderModel->getId())
        {
            return false;
        }
 
        $fileModel->delete($userId);
 
        return true;
    }

    public static function GetLocalDiskSavedModel($userId = null)
    {
        if (!self::Enabled())
        {
            return false;
        }
 
        $userId = IM\Common::getUserId($userId);
        if (!$userId)
        {
            return false;
        }
 
        $storageModel = \Bitrix\Disk\Driver::getInstance()->getStorageByUserId($userId);
        if (!$storageModel)
        {
            return false;
        }
 
        return $storageModel->getFolderForSavedFiles();
    }

    public static function GetStorageId(?int $chatId = null)
    {
        if ($chatId === null)
        {
            return (int)\Bitrix\Main\Config\Option::get('im', 'disk_storage_id', 0);
        }
 
        return IM\V2\Chat::getInstance($chatId)->getStorageId();
    }

    public static function SetStorageId($id)
    {
        $id = (int)$id;
        if ($id <= 0)
        {
            return false;
        }
 
        $oldId = self::GetStorageId();
        if ($oldId > 0 && $oldId != $id)
        {
            $connection = \Bitrix\Main\Application::getConnection();
            $connection->queryExecute("UPDATE b_im_chat SET DISK_FOLDER_ID = 0");
            $connection->queryExecute("DELETE FROM b_im_message_param WHERE PARAM_NAME = 'FILE_ID'");
        }
 
        \Bitrix\Main\Config\Option::set('im', 'disk_storage_id', $id);
 
        return true;
    }

    public static function GetLocalDiskFolderPath()
    {
        if (!self::Enabled())
        {
            return '';
        }
 
        $folderModel = self::GetLocalDiskSavedModel();
        if (!$folderModel)
        {
            return '';
        }
 
        return \Bitrix\Disk\Driver::getInstance()->getUrlManager()->getUrlFocusController('openFolderList', array('folderId' => $folderModel->getId()));
    }

    public static function GetLocalDiskFilePath($fileId = 0)
    {
        if (!self::Enabled())
        {
            return '';
        }
 
        $fileId = (int)$fileId;
 
        return \Bitrix\Disk\Driver::getInstance()->getUrlManager()->getUrlFocusController('showObjectInGrid', array('objectId' => $fileId? $fileId: '_FILE_ID_'));
    }

    public static function GetPublicPath($type, File $fileModel, $checkContentVersion = true)
    {
        $result = '';
 
        if (!in_array($type, Array(self::PATH_TYPE_DOWNLOAD, self::PATH_TYPE_SHOW, self::PATH_TYPE_PREVIEW)))
        {
            return $result;
        }
 
        if ($checkContentVersion && $fileModel->getGlobalContentVersion() <= 1)
        {
            return $result;
        }
 
        $urlManager = \Bitrix\Main\Engine\UrlManager::getInstance();
 
        $isImage = \Bitrix\Disk\TypeFile::isImage($fileModel);
        $isVideo = \Bitrix\Disk\TypeFile::isVideo($fileModel->getName());
 
        if ($type == self::PATH_TYPE_SHOW)
        {
            if ($isImage)
            {
                $result = $urlManager->create('disk.api.file.showImage', [
                    'humanRE' => 1,
                    'fileId' => $fileModel->getId(),
                    'fileName' => $fileModel->getName()
                ])->getUri();
            }
            else
            {
                $result = $urlManager->create('disk.api.file.download', [
                    'humanRE' => 1,
                    'fileId' => $fileModel->getId(),
                    'fileName' => $fileModel->getName()
                ])->getUri();
            }
        }
        else if ($type == self::PATH_TYPE_PREVIEW)
        {
            if (!($isImage || $isVideo))
            {
                return $result;
            }
 
            if ($fileModel->getView()->getPreviewData())
            {
                $linkType = 'disk.api.file.showPreview';
                $fileName = 'preview.jpg';
            }
            else if ($isImage)
            {
                $linkType = 'disk.api.file.showImage';
                $fileName = $fileModel->getName();
            }
            else
            {
                return $result;
            }
 
            $result = $urlManager->create($linkType, [
                'humanRE' => 1,
                'width' => 640,
                'height' => 640,
                'signature' => \Bitrix\Disk\Security\ParameterSigner::getImageSignature($fileModel->getId(), 640, 640),
                'fileId' => $fileModel->getId(),
                'fileName' => $fileName
            ])->getUri();
        }
        else if ($type == self::PATH_TYPE_DOWNLOAD)
        {
            $result = $urlManager->create('disk.api.file.download', [
                'humanRE' => 1,
                'fileId' => $fileModel->getId(),
                'fileName' => $fileModel->getName()
            ])->getUri();
        }
 
        return $result;
    }

    public static function GetFileLink(File $fileModel)
    {
        if (!\Bitrix\Main\Loader::includeModule('disk'))
        {
            return false;
        }
 
        $fileId = $fileModel->getId();
 
        $signer = new \Bitrix\Main\Security\Sign\Signer;
        $signKey = self::GetFileLinkSign();
        if (is_string($signKey))
        {
            $signer->setKey($signKey);
        }
        $signedValue = $signer->sign($fileId);
 
        $urlManager = \Bitrix\Main\Engine\UrlManager::getInstance();
        $host = $urlManager->getHostUrl();
        $isImage = \Bitrix\Disk\TypeFile::isImage($fileModel);
 
        $link = $host.'/pub/im.file.php?FILE_ID='.$fileId.'&SIGN='.$signedValue;
        if ($isImage)
        {
            $link .= '&img=y';
        }
 
        $shortLink = $host. \CBXShortUri::GetShortUri($link);
        if ($isImage)
        {
            $shortLink .= '#img.'.$fileModel->getExtension();
        }
 
        return $shortLink;
    }

    public static function GetFileLinkSign()
    {
        $key = \Bitrix\Main\Config\Option::get('im', 'file_link_default_key', null);
        if (!$key)
        {
            $key = \Bitrix\Main\Config\Option::get('main', 'signer_default_key', null);
            if (is_string($key))
            {
                \Bitrix\Main\Config\Option::set('im', 'file_link_default_key', $key);
            }
        }
        return $key;
    }

    public static function RemoveTmpFileAgent(): string
    {
        $storageModel = self::GetStorage();
        if (!$storageModel)
        {
            return "CIMDisk::RemoveTmpFileAgent();";
        }
        $date = new \Bitrix\Main\Type\DateTime();
        $date->add('YESTERDAY');
 
        $fileModels = File::getModelList(Array(
            'filter' => Array(
                'GLOBAL_CONTENT_VERSION' => 1,
                '=TYPE' => \Bitrix\Disk\Internals\FileTable::TYPE,
                'STORAGE_ID' => $storageModel->getId(),
                '<CREATE_TIME' => $date
            ),
            'limit' => 200
        ));
        foreach ($fileModels as $fileModel)
        {
            $fileModel->delete(SystemUser::SYSTEM_USER_ID);
        }
 
        return __METHOD__. '();';
    }

    public static function GetUserId()
    {
        global $USER;
        return $USER instanceOf \CUser ? (int)$USER->getId() : 0;
    }

    public static function EnabledExternalLink()
    {
        if (!\Bitrix\Main\Loader::includeModule('disk'))
        {
            return false;
        }
 
        return \Bitrix\Disk\Configuration::isEnabledExternalLink();
    }

    public static function SetEnabledExternalLink($flag = true)
    {
        if (!\Bitrix\Main\Loader::includeModule('disk'))
        {
            return false;
        }
 
        if (!\CIMMessenger::IsAdmin())
        {
            return false;
        }
 
        \Bitrix\Main\Config\Option::set('disk', 'disk_allow_use_external_link', $flag ? 'Y': 'N');
 
        return true;
    }

    public static function GetTopDepartmentCode(): false|string
    {
        $topCode = IM\V2\Integration\HumanResources\Department\Department::getInstance()->getTopCode();
 
        return $topCode ?? false;
    }

    public static function OnAfterDeleteFile($fileId, $userId, $fileParams = Array())
    {
        if (
            !isset($fileParams['STORAGE_ID'])
            || !self::isStorageAssociatedWithChat((int)$fileParams['STORAGE_ID'])
        )
        {
            return true;
        }
 
        $messageIds = \CIMMessageParam::GetMessageIdByParam('FILE_ID', $fileId);
        \CIMMessageParam::DeleteByParam('FILE_ID', $fileId);
        (new IM\V2\Link\File\FileService())->deleteFilesByDiskFileId($fileId);
        foreach ($messageIds as $messageId)
        {
            \CIMMessageParam::SendPull((int)$messageId, Array('FILE_ID'));
        }
 
        return true;
    }

    protected static function isStorageAssociatedWithChat(int $storageId): bool
    {
        if ($storageId === self::GetStorageId())
        {
            return true;
        }
 
        if (
            !Loader::includeModule('disk')
            || !Loader::includeModule('socialnetwork')
        )
        {
            return false;
        }
 
        $storage = Disk\Storage::loadById($storageId);
        if ($storage === null)
        {
            return false;
        }
 
        if (!($storage->getProxyType() instanceof Disk\ProxyType\Group))
        {
            return false;
        }
 
        $groupId = (int)$storage->getEntityId();
 
        return CollabProvider::getInstance()->isCollab($groupId);
    }
}